Down integrate to Github
diff --git a/cmake/libprotobuf-lite.cmake b/cmake/libprotobuf-lite.cmake
index 890074f..81a091f 100644
--- a/cmake/libprotobuf-lite.cmake
+++ b/cmake/libprotobuf-lite.cmake
@@ -7,6 +7,7 @@
${protobuf_source_dir}/src/google/protobuf/implicit_weak_message.cc
${protobuf_source_dir}/src/google/protobuf/parse_context.cc
${protobuf_source_dir}/src/google/protobuf/io/coded_stream.cc
+ ${protobuf_source_dir}/src/google/protobuf/io/io_win32.cc
${protobuf_source_dir}/src/google/protobuf/io/strtod.cc
${protobuf_source_dir}/src/google/protobuf/io/zero_copy_stream.cc
${protobuf_source_dir}/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
@@ -15,7 +16,6 @@
${protobuf_source_dir}/src/google/protobuf/stubs/bytestream.cc
${protobuf_source_dir}/src/google/protobuf/stubs/common.cc
${protobuf_source_dir}/src/google/protobuf/stubs/int128.cc
- ${protobuf_source_dir}/src/google/protobuf/stubs/io_win32.cc
${protobuf_source_dir}/src/google/protobuf/stubs/status.cc
${protobuf_source_dir}/src/google/protobuf/stubs/statusor.cc
${protobuf_source_dir}/src/google/protobuf/stubs/stringpiece.cc
diff --git a/cmake/tests.cmake b/cmake/tests.cmake
index f4679d1..7226961 100644
--- a/cmake/tests.cmake
+++ b/cmake/tests.cmake
@@ -156,6 +156,7 @@
${protobuf_source_dir}/src/google/protobuf/extension_set_unittest.cc
${protobuf_source_dir}/src/google/protobuf/generated_message_reflection_unittest.cc
${protobuf_source_dir}/src/google/protobuf/io/coded_stream_unittest.cc
+ ${protobuf_source_dir}/src/google/protobuf/io/io_win32_unittest.cc
${protobuf_source_dir}/src/google/protobuf/io/printer_unittest.cc
${protobuf_source_dir}/src/google/protobuf/io/tokenizer_unittest.cc
${protobuf_source_dir}/src/google/protobuf/io/zero_copy_stream_unittest.cc
@@ -175,7 +176,6 @@
${protobuf_source_dir}/src/google/protobuf/stubs/bytestream_unittest.cc
${protobuf_source_dir}/src/google/protobuf/stubs/common_unittest.cc
${protobuf_source_dir}/src/google/protobuf/stubs/int128_unittest.cc
- ${protobuf_source_dir}/src/google/protobuf/stubs/io_win32_unittest.cc
${protobuf_source_dir}/src/google/protobuf/stubs/status_test.cc
${protobuf_source_dir}/src/google/protobuf/stubs/statusor_test.cc
${protobuf_source_dir}/src/google/protobuf/stubs/stringpiece_unittest.cc
diff --git a/conformance/text_format_conformance_suite.cc b/conformance/text_format_conformance_suite.cc
index 76f398c..97b7b90 100644
--- a/conformance/text_format_conformance_suite.cc
+++ b/conformance/text_format_conformance_suite.cc
@@ -236,7 +236,7 @@
RunValidTextFormatTest("FloatFieldWithVeryPreciseNumber", REQUIRED,
"optional_float: 3.123456789123456789");
RunValidTextFormatTest("FloatFieldMaxValue", REQUIRED,
- "optional_float: 3.40282e+38");
+ "optional_float: 3.4028235e+38");
RunValidTextFormatTest("FloatFieldMinValue", REQUIRED,
"optional_float: 1.17549e-38");
RunValidTextFormatTest("FloatFieldNaNValue", REQUIRED,
@@ -286,6 +286,31 @@
message.add_repeated_int32(2);
message.add_repeated_int32(3);
RunValidUnknownTextFormatTest("RepeatedUnknownFields", message);
+
+ // Any fields
+ RunValidTextFormatTest("AnyField", REQUIRED,
+ R"(
+ optional_any: {
+ [type.googleapis.com/protobuf_test_messages.proto3.TestAllTypesProto3] {
+ optional_int32: 12345
+ }
+ }
+ )");
+ RunValidTextFormatTest("AnyFieldWithRawBytes", REQUIRED,
+ R"(
+ optional_any: {
+ type_url: "type.googleapis.com/protobuf_test_messages.proto3.TestAllTypesProto3"
+ value: "\b\271`"
+ }
+ )");
+ ExpectParseFailure("AnyFieldWithInvalidType", REQUIRED,
+ R"(
+ optional_any: {
+ [type.googleapis.com/unknown] {
+ optional_int32: 12345
+ }
+ }
+ )");
}
} // namespace protobuf
diff --git a/conformance/text_format_failure_list_java.txt b/conformance/text_format_failure_list_java.txt
index 4902d46..81433b4 100755
--- a/conformance/text_format_failure_list_java.txt
+++ b/conformance/text_format_failure_list_java.txt
@@ -2,3 +2,5 @@
Recommended.Proto3.ProtobufInput.MessageUnknownFields_Drop.TextFormatOutput
Recommended.Proto3.ProtobufInput.RepeatedUnknownFields_Drop.TextFormatOutput
Recommended.Proto3.ProtobufInput.ScalarUnknownFields_Drop.TextFormatOutput
+Required.Proto3.TextFormatInput.AnyField.ProtobufOutput
+Required.Proto3.TextFormatInput.AnyField.TextFormatOutput
diff --git a/conformance/text_format_failure_list_python.txt b/conformance/text_format_failure_list_python.txt
index 9a8709d..b2db95e 100644
--- a/conformance/text_format_failure_list_python.txt
+++ b/conformance/text_format_failure_list_python.txt
@@ -1,3 +1,5 @@
# This is the list of text format conformance tests that are known to fail right
# now.
# TODO: These should be fixed.
+Required.Proto3.TextFormatInput.FloatFieldMaxValue.ProtobufOutput
+Required.Proto3.TextFormatInput.FloatFieldMaxValue.TextFormatOutput
diff --git a/java/core/src/main/java/com/google/protobuf/AbstractMessageLite.java b/java/core/src/main/java/com/google/protobuf/AbstractMessageLite.java
index 1720575..ba0138a 100644
--- a/java/core/src/main/java/com/google/protobuf/AbstractMessageLite.java
+++ b/java/core/src/main/java/com/google/protobuf/AbstractMessageLite.java
@@ -106,6 +106,56 @@
}
+ @ExperimentalApi
+ protected final boolean isInitializedInternal() {
+ return Protobuf.getInstance().schemaFor(this).isInitialized(this);
+ }
+
+ @ExperimentalApi
+ protected final int getSerializedSizeInternal() {
+ return Protobuf.getInstance().schemaFor(this).getSerializedSize(this);
+ }
+
+ int getSerializedSize(Schema schema) {
+ int memoizedSerializedSize = getMemoizedSerializedSize();
+ if (memoizedSerializedSize == -1) {
+ memoizedSerializedSize = schema.getSerializedSize(this);
+ setMemoizedSerializedSize(memoizedSerializedSize);
+ }
+ return memoizedSerializedSize;
+ }
+
+ @ExperimentalApi
+ protected final void writeToInternal(CodedOutputStream output) throws IOException {
+ Protobuf.getInstance()
+ .schemaFor(getClassInternal())
+ .writeTo(this, CodedOutputStreamWriter.forCodedOutput(output));
+ }
+
+ @ExperimentalApi
+ protected void mergeFromInternal(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
+ throws InvalidProtocolBufferException {
+ try {
+ Protobuf.getInstance()
+ .schemaFor(getClassInternal())
+ .mergeFrom(this, CodedInputStreamReader.forCodedInput(input), extensionRegistry);
+ } catch (InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (IOException e) {
+ throw new InvalidProtocolBufferException(e).setUnfinishedMessage(this);
+ }
+ }
+
+ @ExperimentalApi
+ protected void makeImmutableInternal() {
+ Protobuf.getInstance().schemaFor(getClassInternal()).makeImmutable(this);
+ }
+
+ @SuppressWarnings("unchecked")
+ private Class<AbstractMessageLite<MessageType, BuilderType>> getClassInternal() {
+ return (Class<AbstractMessageLite<MessageType, BuilderType>>) getClass();
+ }
+
/** Package private helper method for AbstractParser to create UninitializedMessageException. */
UninitializedMessageException newUninitializedMessageException() {
return new UninitializedMessageException(this);
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 100755
index 0000000..a01a6c1
--- /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
+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 <i>(optional operation)</i>.
+ *
+ * <p>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 <i>(optional operation)</i>.
+ *
+ * <p>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
+ * <i>(optional operation)</i>.
+ *
+ * <p>If this buffer is backed by an array then {@link #position()} corresponds to the array index
+ * {@link #position()} {@code +} {@link #arrayOffset()}.
+ *
+ * <p>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, length=%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/ArrayDecoders.java b/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java
new file mode 100755
index 0000000..a969c04
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java
@@ -0,0 +1,1076 @@
+// 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.MessageSchema.getMutableUnknownFields;
+
+import com.google.protobuf.Internal.ProtobufList;
+import java.io.IOException;
+
+/**
+ * Helper functions to decode protobuf wire format from a byte array.
+ *
+ * <p>Note that these functions don't do boundary check on the byte array but instead rely on Java
+ * VM to check it. That means parsing rountines utilizing these functions must catch
+ * IndexOutOfBoundsException and convert it to protobuf's InvalidProtocolBufferException when
+ * crossing protobuf public API boundaries.
+ */
+final class ArrayDecoders {
+ /**
+ * A helper used to return multiple values in a Java function. Java doesn't natively support
+ * returning multiple values in a function. Creating a new Object to hold the return values will
+ * be too expensive. Instead, we pass a Registers instance to functions that want to return
+ * multiple values and let the function set the return value in this Registers instance instead.
+ *
+ * <p>TODO(xiaofeng): This could be merged into CodedInputStream or CodedInputStreamReader which
+ * is already being passed through all the parsing rountines.
+ */
+ static final class Registers {
+ public int int1;
+ public long long1;
+ public Object object1;
+ public final ExtensionRegistryLite extensionRegistry;
+
+ Registers() {
+ this.extensionRegistry = ExtensionRegistryLite.getEmptyRegistry();
+ }
+
+ Registers(ExtensionRegistryLite extensionRegistry) {
+ if (extensionRegistry == null) {
+ throw new NullPointerException();
+ }
+ this.extensionRegistry = extensionRegistry;
+ }
+ }
+
+ /**
+ * Decodes a varint. Returns the position after the varint. The decoded varint is stored in
+ * registers.int1.
+ */
+ static int decodeVarint32(byte[] data, int position, Registers registers) {
+ int value = data[position++];
+ if (value >= 0) {
+ registers.int1 = value;
+ return position;
+ }
+ return decodeVarint32(value, data, position, registers);
+ }
+
+ /** Like decodeVarint32 except that the first byte is already read. */
+ static int decodeVarint32(int firstByte, byte[] data, int position, Registers registers) {
+ int value = firstByte & 0x7F;
+ final byte b2 = data[position++];
+ if (b2 >= 0) {
+ registers.int1 = value | ((int) b2 << 7);
+ return position;
+ }
+ value |= (b2 & 0x7F) << 7;
+
+ final byte b3 = data[position++];
+ if (b3 >= 0) {
+ registers.int1 = value | ((int) b3 << 14);
+ return position;
+ }
+ value |= (b3 & 0x7F) << 14;
+
+ final byte b4 = data[position++];
+ if (b4 >= 0) {
+ registers.int1 = value | ((int) b4 << 21);
+ return position;
+ }
+ value |= (b4 & 0x7F) << 21;
+
+ final byte b5 = data[position++];
+ if (b5 >= 0) {
+ registers.int1 = value | ((int) b5 << 28);
+ return position;
+ }
+ value |= (b5 & 0x7F) << 28;
+
+ while (data[position++] < 0) {}
+
+ registers.int1 = value;
+ return position;
+ }
+
+ /**
+ * Decodes a varint. Returns the position after the varint. The decoded varint is stored in
+ * registers.long1.
+ */
+ static int decodeVarint64(byte[] data, int position, Registers registers) {
+ long value = data[position++];
+ if (value >= 0) {
+ registers.long1 = value;
+ return position;
+ } else {
+ return decodeVarint64(value, data, position, registers);
+ }
+ }
+
+ /** Like decodeVarint64 except that the first byte is already read. */
+ static int decodeVarint64(long firstByte, byte[] data, int position, Registers registers) {
+ long value = firstByte & 0x7F;
+ byte next = data[position++];
+ int shift = 7;
+ value |= (long) (next & 0x7F) << 7;
+ while (next < 0) {
+ next = data[position++];
+ shift += 7;
+ value |= (long) (next & 0x7F) << shift;
+ }
+ registers.long1 = value;
+ return position;
+ }
+
+ /** Decodes and returns a fixed32 value. */
+ static int decodeFixed32(byte[] data, int position) {
+ return (data[position] & 0xff)
+ | ((data[position + 1] & 0xff) << 8)
+ | ((data[position + 2] & 0xff) << 16)
+ | ((data[position + 3] & 0xff) << 24);
+ }
+
+ /** Decodes and returns a fixed64 value. */
+ static long decodeFixed64(byte[] data, int position) {
+ return (data[position] & 0xffL)
+ | ((data[position + 1] & 0xffL) << 8)
+ | ((data[position + 2] & 0xffL) << 16)
+ | ((data[position + 3] & 0xffL) << 24)
+ | ((data[position + 4] & 0xffL) << 32)
+ | ((data[position + 5] & 0xffL) << 40)
+ | ((data[position + 6] & 0xffL) << 48)
+ | ((data[position + 7] & 0xffL) << 56);
+ }
+
+ /** Decodes and returns a double value. */
+ static double decodeDouble(byte[] data, int position) {
+ return Double.longBitsToDouble(decodeFixed64(data, position));
+ }
+
+ /** Decodes and returns a float value. */
+ static float decodeFloat(byte[] data, int position) {
+ return Float.intBitsToFloat(decodeFixed32(data, position));
+ }
+
+ /** Decodes a string value. */
+ static int decodeString(byte[] data, int position, Registers registers)
+ throws InvalidProtocolBufferException {
+ position = decodeVarint32(data, position, registers);
+ final int length = registers.int1;
+ if (length < 0) {
+ throw InvalidProtocolBufferException.negativeSize();
+ } else if (length == 0) {
+ registers.object1 = "";
+ return position;
+ } else {
+ registers.object1 = new String(data, position, length, Internal.UTF_8);
+ return position + length;
+ }
+ }
+
+ /** Decodes a string value with utf8 check. */
+ static int decodeStringRequireUtf8(byte[] data, int position, Registers registers)
+ throws InvalidProtocolBufferException {
+ position = decodeVarint32(data, position, registers);
+ final int length = registers.int1;
+ if (length < 0) {
+ throw InvalidProtocolBufferException.negativeSize();
+ } else if (length == 0) {
+ registers.object1 = "";
+ return position;
+ } else {
+ registers.object1 = Utf8.decodeUtf8(data, position, length);
+ return position + length;
+ }
+ }
+
+ /** Decodes a bytes value. */
+ static int decodeBytes(byte[] data, int position, Registers registers)
+ throws InvalidProtocolBufferException {
+ position = decodeVarint32(data, position, registers);
+ final int length = registers.int1;
+ if (length < 0) {
+ throw InvalidProtocolBufferException.negativeSize();
+ } else if (length > data.length - position) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ } else if (length == 0) {
+ registers.object1 = ByteString.EMPTY;
+ return position;
+ } else {
+ registers.object1 = ByteString.copyFrom(data, position, length);
+ return position + length;
+ }
+ }
+
+ /** Decodes a message value. */
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ static int decodeMessageField(
+ Schema schema, byte[] data, int position, int limit, Registers registers) throws IOException {
+ int length = data[position++];
+ if (length < 0) {
+ position = decodeVarint32(length, data, position, registers);
+ length = registers.int1;
+ }
+ if (length < 0 || length > limit - position) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ Object result = schema.newInstance();
+ schema.mergeFrom(result, data, position, position + length, registers);
+ schema.makeImmutable(result);
+ registers.object1 = result;
+ return position + length;
+ }
+
+ /** Decodes a group value. */
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ static int decodeGroupField(
+ Schema schema, byte[] data, int position, int limit, int endGroup, Registers registers)
+ throws IOException {
+ // A group field must has a MessageSchema (the only other subclass of Schema is MessageSetSchema
+ // and it can't be used in group fields).
+ final MessageSchema messageSchema = (MessageSchema) schema;
+ Object result = messageSchema.newInstance();
+ // It's OK to directly use parseProto2Message since proto3 doesn't have group.
+ final int endPosition =
+ messageSchema.parseProto2Message(result, data, position, limit, endGroup, registers);
+ messageSchema.makeImmutable(result);
+ registers.object1 = result;
+ return endPosition;
+ }
+
+ /** Decodes a repeated 32-bit varint field. Returns the position after all read values. */
+ static int decodeVarint32List(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers) {
+ final IntArrayList output = (IntArrayList) list;
+ position = decodeVarint32(data, position, registers);
+ output.addInt(registers.int1);
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ position = decodeVarint32(data, nextPosition, registers);
+ output.addInt(registers.int1);
+ }
+ return position;
+ }
+
+ /** Decodes a repeated 64-bit varint field. Returns the position after all read values. */
+ static int decodeVarint64List(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers) {
+ final LongArrayList output = (LongArrayList) list;
+ position = decodeVarint64(data, position, registers);
+ output.addLong(registers.long1);
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ position = decodeVarint64(data, nextPosition, registers);
+ output.addLong(registers.long1);
+ }
+ return position;
+ }
+
+ /** Decodes a repeated fixed32 field. Returns the position after all read values. */
+ static int decodeFixed32List(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers) {
+ final IntArrayList output = (IntArrayList) list;
+ output.addInt(decodeFixed32(data, position));
+ position += 4;
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ output.addInt(decodeFixed32(data, nextPosition));
+ position = nextPosition + 4;
+ }
+ return position;
+ }
+
+ /** Decodes a repeated fixed64 field. Returns the position after all read values. */
+ static int decodeFixed64List(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers) {
+ final LongArrayList output = (LongArrayList) list;
+ output.addLong(decodeFixed64(data, position));
+ position += 8;
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ output.addLong(decodeFixed64(data, nextPosition));
+ position = nextPosition + 8;
+ }
+ return position;
+ }
+
+ /** Decodes a repeated float field. Returns the position after all read values. */
+ static int decodeFloatList(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers) {
+ final FloatArrayList output = (FloatArrayList) list;
+ output.addFloat(decodeFloat(data, position));
+ position += 4;
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ output.addFloat(decodeFloat(data, nextPosition));
+ position = nextPosition + 4;
+ }
+ return position;
+ }
+
+ /** Decodes a repeated double field. Returns the position after all read values. */
+ static int decodeDoubleList(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers) {
+ final DoubleArrayList output = (DoubleArrayList) list;
+ output.addDouble(decodeDouble(data, position));
+ position += 8;
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ output.addDouble(decodeDouble(data, nextPosition));
+ position = nextPosition + 8;
+ }
+ return position;
+ }
+
+ /** Decodes a repeated boolean field. Returns the position after all read values. */
+ static int decodeBoolList(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers) {
+ final BooleanArrayList output = (BooleanArrayList) list;
+ position = decodeVarint64(data, position, registers);
+ output.addBoolean(registers.long1 != 0);
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ position = decodeVarint64(data, nextPosition, registers);
+ output.addBoolean(registers.long1 != 0);
+ }
+ return position;
+ }
+
+ /** Decodes a repeated sint32 field. Returns the position after all read values. */
+ static int decodeSInt32List(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers) {
+ final IntArrayList output = (IntArrayList) list;
+ position = decodeVarint32(data, position, registers);
+ output.addInt(CodedInputStream.decodeZigZag32(registers.int1));
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ position = decodeVarint32(data, nextPosition, registers);
+ output.addInt(CodedInputStream.decodeZigZag32(registers.int1));
+ }
+ return position;
+ }
+
+ /** Decodes a repeated sint64 field. Returns the position after all read values. */
+ static int decodeSInt64List(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers) {
+ final LongArrayList output = (LongArrayList) list;
+ position = decodeVarint64(data, position, registers);
+ output.addLong(CodedInputStream.decodeZigZag64(registers.long1));
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ position = decodeVarint64(data, nextPosition, registers);
+ output.addLong(CodedInputStream.decodeZigZag64(registers.long1));
+ }
+ return position;
+ }
+
+ /** Decodes a packed 32-bit varint field. Returns the position after all read values. */
+ static int decodePackedVarint32List(
+ byte[] data, int position, ProtobufList<?> list, Registers registers) throws IOException {
+ final IntArrayList output = (IntArrayList) list;
+ position = decodeVarint32(data, position, registers);
+ final int fieldLimit = position + registers.int1;
+ while (position < fieldLimit) {
+ position = decodeVarint32(data, position, registers);
+ output.addInt(registers.int1);
+ }
+ if (position != fieldLimit) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ return position;
+ }
+
+ /** Decodes a packed 64-bit varint field. Returns the position after all read values. */
+ static int decodePackedVarint64List(
+ byte[] data, int position, ProtobufList<?> list, Registers registers) throws IOException {
+ final LongArrayList output = (LongArrayList) list;
+ position = decodeVarint32(data, position, registers);
+ final int fieldLimit = position + registers.int1;
+ while (position < fieldLimit) {
+ position = decodeVarint64(data, position, registers);
+ output.addLong(registers.long1);
+ }
+ if (position != fieldLimit) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ return position;
+ }
+
+ /** Decodes a packed fixed32 field. Returns the position after all read values. */
+ static int decodePackedFixed32List(
+ byte[] data, int position, ProtobufList<?> list, Registers registers) throws IOException {
+ final IntArrayList output = (IntArrayList) list;
+ position = decodeVarint32(data, position, registers);
+ final int fieldLimit = position + registers.int1;
+ while (position < fieldLimit) {
+ output.addInt(decodeFixed32(data, position));
+ position += 4;
+ }
+ if (position != fieldLimit) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ return position;
+ }
+
+ /** Decodes a packed fixed64 field. Returns the position after all read values. */
+ static int decodePackedFixed64List(
+ byte[] data, int position, ProtobufList<?> list, Registers registers) throws IOException {
+ final LongArrayList output = (LongArrayList) list;
+ position = decodeVarint32(data, position, registers);
+ final int fieldLimit = position + registers.int1;
+ while (position < fieldLimit) {
+ output.addLong(decodeFixed64(data, position));
+ position += 8;
+ }
+ if (position != fieldLimit) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ return position;
+ }
+
+ /** Decodes a packed float field. Returns the position after all read values. */
+ static int decodePackedFloatList(
+ byte[] data, int position, ProtobufList<?> list, Registers registers) throws IOException {
+ final FloatArrayList output = (FloatArrayList) list;
+ position = decodeVarint32(data, position, registers);
+ final int fieldLimit = position + registers.int1;
+ while (position < fieldLimit) {
+ output.addFloat(decodeFloat(data, position));
+ position += 4;
+ }
+ if (position != fieldLimit) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ return position;
+ }
+
+ /** Decodes a packed double field. Returns the position after all read values. */
+ static int decodePackedDoubleList(
+ byte[] data, int position, ProtobufList<?> list, Registers registers) throws IOException {
+ final DoubleArrayList output = (DoubleArrayList) list;
+ position = decodeVarint32(data, position, registers);
+ final int fieldLimit = position + registers.int1;
+ while (position < fieldLimit) {
+ output.addDouble(decodeDouble(data, position));
+ position += 8;
+ }
+ if (position != fieldLimit) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ return position;
+ }
+
+ /** Decodes a packed boolean field. Returns the position after all read values. */
+ static int decodePackedBoolList(
+ byte[] data, int position, ProtobufList<?> list, Registers registers) throws IOException {
+ final BooleanArrayList output = (BooleanArrayList) list;
+ position = decodeVarint32(data, position, registers);
+ final int fieldLimit = position + registers.int1;
+ while (position < fieldLimit) {
+ position = decodeVarint64(data, position, registers);
+ output.addBoolean(registers.long1 != 0);
+ }
+ if (position != fieldLimit) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ return position;
+ }
+
+ /** Decodes a packed sint32 field. Returns the position after all read values. */
+ static int decodePackedSInt32List(
+ byte[] data, int position, ProtobufList<?> list, Registers registers) throws IOException {
+ final IntArrayList output = (IntArrayList) list;
+ position = decodeVarint32(data, position, registers);
+ final int fieldLimit = position + registers.int1;
+ while (position < fieldLimit) {
+ position = decodeVarint32(data, position, registers);
+ output.addInt(CodedInputStream.decodeZigZag32(registers.int1));
+ }
+ if (position != fieldLimit) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ return position;
+ }
+
+ /** Decodes a packed sint64 field. Returns the position after all read values. */
+ @SuppressWarnings("unchecked")
+ static int decodePackedSInt64List(
+ byte[] data, int position, ProtobufList<?> list, Registers registers) throws IOException {
+ final LongArrayList output = (LongArrayList) list;
+ position = decodeVarint32(data, position, registers);
+ final int fieldLimit = position + registers.int1;
+ while (position < fieldLimit) {
+ position = decodeVarint64(data, position, registers);
+ output.addLong(CodedInputStream.decodeZigZag64(registers.long1));
+ }
+ if (position != fieldLimit) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ return position;
+ }
+
+ /** Decodes a repeated string field. Returns the position after all read values. */
+ @SuppressWarnings("unchecked")
+ static int decodeStringList(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers)
+ throws InvalidProtocolBufferException {
+ final ProtobufList<String> output = (ProtobufList<String>) list;
+ position = decodeVarint32(data, position, registers);
+ final int length = registers.int1;
+ if (length < 0) {
+ throw InvalidProtocolBufferException.negativeSize();
+ } else if (length == 0) {
+ output.add("");
+ } else {
+ String value = new String(data, position, length, Internal.UTF_8);
+ output.add(value);
+ position += length;
+ }
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ position = decodeVarint32(data, nextPosition, registers);
+ final int nextLength = registers.int1;
+ if (nextLength < 0) {
+ throw InvalidProtocolBufferException.negativeSize();
+ } else if (nextLength == 0) {
+ output.add("");
+ } else {
+ String value = new String(data, position, nextLength, Internal.UTF_8);
+ output.add(value);
+ position += nextLength;
+ }
+ }
+ return position;
+ }
+
+ /**
+ * Decodes a repeated string field with utf8 check. Returns the position after all read values.
+ */
+ @SuppressWarnings("unchecked")
+ static int decodeStringListRequireUtf8(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers)
+ throws InvalidProtocolBufferException {
+ final ProtobufList<String> output = (ProtobufList<String>) list;
+ position = decodeVarint32(data, position, registers);
+ final int length = registers.int1;
+ if (length < 0) {
+ throw InvalidProtocolBufferException.negativeSize();
+ } else if (length == 0) {
+ output.add("");
+ } else {
+ if (!Utf8.isValidUtf8(data, position, position + length)) {
+ throw InvalidProtocolBufferException.invalidUtf8();
+ }
+ String value = new String(data, position, length, Internal.UTF_8);
+ output.add(value);
+ position += length;
+ }
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ position = decodeVarint32(data, nextPosition, registers);
+ final int nextLength = registers.int1;
+ if (nextLength < 0) {
+ throw InvalidProtocolBufferException.negativeSize();
+ } else if (nextLength == 0) {
+ output.add("");
+ } else {
+ if (!Utf8.isValidUtf8(data, position, position + nextLength)) {
+ throw InvalidProtocolBufferException.invalidUtf8();
+ }
+ String value = new String(data, position, nextLength, Internal.UTF_8);
+ output.add(value);
+ position += nextLength;
+ }
+ }
+ return position;
+ }
+
+ /** Decodes a repeated bytes field. Returns the position after all read values. */
+ @SuppressWarnings("unchecked")
+ static int decodeBytesList(
+ int tag, byte[] data, int position, int limit, ProtobufList<?> list, Registers registers)
+ throws InvalidProtocolBufferException {
+ final ProtobufList<ByteString> output = (ProtobufList<ByteString>) list;
+ position = decodeVarint32(data, position, registers);
+ final int length = registers.int1;
+ if (length < 0) {
+ throw InvalidProtocolBufferException.negativeSize();
+ } else if (length > data.length - position) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ } else if (length == 0) {
+ output.add(ByteString.EMPTY);
+ } else {
+ output.add(ByteString.copyFrom(data, position, length));
+ position += length;
+ }
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ position = decodeVarint32(data, nextPosition, registers);
+ final int nextLength = registers.int1;
+ if (nextLength < 0) {
+ throw InvalidProtocolBufferException.negativeSize();
+ } else if (nextLength > data.length - position) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ } else if (nextLength == 0) {
+ output.add(ByteString.EMPTY);
+ } else {
+ output.add(ByteString.copyFrom(data, position, nextLength));
+ position += nextLength;
+ }
+ }
+ return position;
+ }
+
+ /**
+ * Decodes a repeated message field
+ *
+ * @return The position of after read all messages
+ */
+ @SuppressWarnings({"unchecked"})
+ static int decodeMessageList(
+ Schema<?> schema,
+ int tag,
+ byte[] data,
+ int position,
+ int limit,
+ ProtobufList<?> list,
+ Registers registers)
+ throws IOException {
+ final ProtobufList<Object> output = (ProtobufList<Object>) list;
+ position = decodeMessageField(schema, data, position, limit, registers);
+ output.add(registers.object1);
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ position = decodeMessageField(schema, data, nextPosition, limit, registers);
+ output.add(registers.object1);
+ }
+ return position;
+ }
+
+ /**
+ * Decodes a repeated group field
+ *
+ * @return The position of after read all groups
+ */
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ static int decodeGroupList(
+ Schema schema,
+ int tag,
+ byte[] data,
+ int position,
+ int limit,
+ ProtobufList<?> list,
+ Registers registers)
+ throws IOException {
+ final ProtobufList<Object> output = (ProtobufList<Object>) list;
+ final int endgroup = (tag & ~0x7) | WireFormat.WIRETYPE_END_GROUP;
+ position = decodeGroupField(schema, data, position, limit, endgroup, registers);
+ output.add(registers.object1);
+ while (position < limit) {
+ int nextPosition = decodeVarint32(data, position, registers);
+ if (tag != registers.int1) {
+ break;
+ }
+ position = decodeGroupField(schema, data, nextPosition, limit, endgroup, registers);
+ output.add(registers.object1);
+ }
+ return position;
+ }
+
+ static int decodeExtensionOrUnknownField(
+ int tag, byte[] data, int position, int limit,
+ Object message,
+ MessageLite defaultInstance,
+ UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite> unknownFieldSchema,
+ Registers registers)
+ throws IOException {
+ final int number = tag >>> 3;
+ GeneratedMessageLite.GeneratedExtension extension =
+ registers.extensionRegistry.findLiteExtensionByNumber(defaultInstance, number);
+ if (extension == null) {
+ return decodeUnknownField(
+ tag, data, position, limit, getMutableUnknownFields(message), registers);
+ } else {
+ ((GeneratedMessageLite.ExtendableMessage<?, ?>) message).ensureExtensionsAreMutable();
+ return decodeExtension(
+ tag, data, position, limit, (GeneratedMessageLite.ExtendableMessage) message,
+ extension, unknownFieldSchema, registers);
+ }
+ }
+
+ static int decodeExtension(
+ int tag,
+ byte[] data,
+ int position,
+ int limit,
+ GeneratedMessageLite.ExtendableMessage<?, ?> message,
+ GeneratedMessageLite.GeneratedExtension<?, ?> extension,
+ UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite> unknownFieldSchema,
+ Registers registers)
+ throws IOException {
+ final FieldSet<GeneratedMessageLite.ExtensionDescriptor> extensions = message.extensions;
+ final int fieldNumber = tag >>> 3;
+ if (extension.descriptor.isRepeated() && extension.descriptor.isPacked()) {
+ switch (extension.getLiteType()) {
+ case DOUBLE:
+ {
+ DoubleArrayList list = new DoubleArrayList();
+ position = decodePackedDoubleList(data, position, list, registers);
+ extensions.setField(extension.descriptor, list);
+ break;
+ }
+ case FLOAT:
+ {
+ FloatArrayList list = new FloatArrayList();
+ position = decodePackedFloatList(data, position, list, registers);
+ extensions.setField(extension.descriptor, list);
+ break;
+ }
+ case INT64:
+ case UINT64:
+ {
+ LongArrayList list = new LongArrayList();
+ position = decodePackedVarint64List(data, position, list, registers);
+ extensions.setField(extension.descriptor, list);
+ break;
+ }
+ case INT32:
+ case UINT32:
+ {
+ IntArrayList list = new IntArrayList();
+ position = decodePackedVarint32List(data, position, list, registers);
+ extensions.setField(extension.descriptor, list);
+ break;
+ }
+ case FIXED64:
+ case SFIXED64:
+ {
+ LongArrayList list = new LongArrayList();
+ position = decodePackedFixed64List(data, position, list, registers);
+ extensions.setField(extension.descriptor, list);
+ break;
+ }
+ case FIXED32:
+ case SFIXED32:
+ {
+ IntArrayList list = new IntArrayList();
+ position = decodePackedFixed32List(data, position, list, registers);
+ extensions.setField(extension.descriptor, list);
+ break;
+ }
+ case BOOL:
+ {
+ BooleanArrayList list = new BooleanArrayList();
+ position = decodePackedBoolList(data, position, list, registers);
+ extensions.setField(extension.descriptor, list);
+ break;
+ }
+ case SINT32:
+ {
+ IntArrayList list = new IntArrayList();
+ position = decodePackedSInt32List(data, position, list, registers);
+ extensions.setField(extension.descriptor, list);
+ break;
+ }
+ case SINT64:
+ {
+ LongArrayList list = new LongArrayList();
+ position = decodePackedSInt64List(data, position, list, registers);
+ extensions.setField(extension.descriptor, list);
+ break;
+ }
+ case ENUM:
+ {
+ IntArrayList list = new IntArrayList();
+ position = decodePackedVarint32List(data, position, list, registers);
+ UnknownFieldSetLite unknownFields = message.unknownFields;
+ if (unknownFields == UnknownFieldSetLite.getDefaultInstance()) {
+ unknownFields = null;
+ }
+ unknownFields =
+ SchemaUtil.filterUnknownEnumList(
+ fieldNumber,
+ list,
+ extension.descriptor.getEnumType(),
+ unknownFields,
+ unknownFieldSchema);
+ if (unknownFields != null) {
+ message.unknownFields = unknownFields;
+ }
+ extensions.setField(extension.descriptor, list);
+ break;
+ }
+ default:
+ throw new IllegalStateException(
+ "Type cannot be packed: " + extension.descriptor.getLiteType());
+ }
+ } else {
+ Object value = null;
+ // Enum is a special case becasue unknown enum values will be put into UnknownFieldSetLite.
+ if (extension.getLiteType() == WireFormat.FieldType.ENUM) {
+ position = decodeVarint32(data, position, registers);
+ Object enumValue = extension.descriptor.getEnumType().findValueByNumber(registers.int1);
+ if (enumValue == null) {
+ UnknownFieldSetLite unknownFields = ((GeneratedMessageLite) message).unknownFields;
+ if (unknownFields == UnknownFieldSetLite.getDefaultInstance()) {
+ unknownFields = UnknownFieldSetLite.newInstance();
+ ((GeneratedMessageLite) message).unknownFields = unknownFields;
+ }
+ SchemaUtil.storeUnknownEnum(
+ fieldNumber, registers.int1, unknownFields, unknownFieldSchema);
+ return position;
+ }
+ // Note, we store the integer value instead of the actual enum object in FieldSet.
+ // This is also different from full-runtime where we store EnumValueDescriptor.
+ value = registers.int1;
+ } else {
+ switch (extension.getLiteType()) {
+ case DOUBLE:
+ value = decodeDouble(data, position);
+ position += 8;
+ break;
+ case FLOAT:
+ value = decodeFloat(data, position);
+ position += 4;
+ break;
+ case INT64:
+ case UINT64:
+ position = decodeVarint64(data, position, registers);
+ value = registers.long1;
+ break;
+ case INT32:
+ case UINT32:
+ position = decodeVarint32(data, position, registers);
+ value = registers.int1;
+ break;
+ case FIXED64:
+ case SFIXED64:
+ value = decodeFixed64(data, position);
+ position += 8;
+ break;
+ case FIXED32:
+ case SFIXED32:
+ value = decodeFixed32(data, position);
+ position += 4;
+ break;
+ case BOOL:
+ position = decodeVarint64(data, position, registers);
+ value = (registers.long1 != 0);
+ break;
+ case BYTES:
+ position = decodeBytes(data, position, registers);
+ value = registers.object1;
+ break;
+ case SINT32:
+ position = decodeVarint32(data, position, registers);
+ value = CodedInputStream.decodeZigZag32(registers.int1);
+ break;
+ case SINT64:
+ position = decodeVarint64(data, position, registers);
+ value = CodedInputStream.decodeZigZag64(registers.long1);
+ break;
+ case STRING:
+ position = decodeString(data, position, registers);
+ value = registers.object1;
+ break;
+ case GROUP:
+ final int endTag = (fieldNumber << 3) | WireFormat.WIRETYPE_END_GROUP;
+ position = decodeGroupField(
+ Protobuf.getInstance().schemaFor(extension.getMessageDefaultInstance().getClass()),
+ data, position, limit, endTag, registers);
+ value = registers.object1;
+ break;
+
+ case MESSAGE:
+ position = decodeMessageField(
+ Protobuf.getInstance().schemaFor(extension.getMessageDefaultInstance().getClass()),
+ data, position, limit, registers);
+ value = registers.object1;
+ break;
+
+ case ENUM:
+ throw new IllegalStateException("Shouldn't reach here.");
+ }
+ }
+ if (extension.isRepeated()) {
+ extensions.addRepeatedField(extension.descriptor, value);
+ } else {
+ switch (extension.getLiteType()) {
+ case MESSAGE:
+ case GROUP:
+ Object oldValue = extensions.getField(extension.descriptor);
+ if (oldValue != null) {
+ value = Internal.mergeMessage(oldValue, value);
+ }
+ break;
+ default:
+ break;
+ }
+ extensions.setField(extension.descriptor, value);
+ }
+ }
+ return position;
+ }
+
+ /** Decodes an unknown field. */
+ static int decodeUnknownField(
+ int tag,
+ byte[] data,
+ int position,
+ int limit,
+ UnknownFieldSetLite unknownFields,
+ Registers registers)
+ throws InvalidProtocolBufferException {
+ if (WireFormat.getTagFieldNumber(tag) == 0) {
+ throw InvalidProtocolBufferException.invalidTag();
+ }
+ switch (WireFormat.getTagWireType(tag)) {
+ case WireFormat.WIRETYPE_VARINT:
+ position = decodeVarint64(data, position, registers);
+ unknownFields.storeField(tag, registers.long1);
+ return position;
+ case WireFormat.WIRETYPE_FIXED32:
+ unknownFields.storeField(tag, decodeFixed32(data, position));
+ return position + 4;
+ case WireFormat.WIRETYPE_FIXED64:
+ unknownFields.storeField(tag, decodeFixed64(data, position));
+ return position + 8;
+ case WireFormat.WIRETYPE_LENGTH_DELIMITED:
+ position = decodeVarint32(data, position, registers);
+ final int length = registers.int1;
+ if (length < 0) {
+ throw InvalidProtocolBufferException.negativeSize();
+ } else if (length > data.length - position) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ } else if (length == 0) {
+ unknownFields.storeField(tag, ByteString.EMPTY);
+ } else {
+ unknownFields.storeField(tag, ByteString.copyFrom(data, position, length));
+ }
+ return position + length;
+ case WireFormat.WIRETYPE_START_GROUP:
+ final UnknownFieldSetLite child = UnknownFieldSetLite.newInstance();
+ final int endGroup = (tag & ~0x7) | WireFormat.WIRETYPE_END_GROUP;
+ int lastTag = 0;
+ while (position < limit) {
+ position = decodeVarint32(data, position, registers);
+ lastTag = registers.int1;
+ if (lastTag == endGroup) {
+ break;
+ }
+ position = decodeUnknownField(lastTag, data, position, limit, child, registers);
+ }
+ if (position > limit || lastTag != endGroup) {
+ throw InvalidProtocolBufferException.parseFailure();
+ }
+ unknownFields.storeField(tag, child);
+ return position;
+ default:
+ throw InvalidProtocolBufferException.invalidTag();
+ }
+ }
+
+ /** Skips an unknown field. */
+ static int skipField(int tag, byte[] data, int position, int limit, Registers registers)
+ throws InvalidProtocolBufferException {
+ if (WireFormat.getTagFieldNumber(tag) == 0) {
+ throw InvalidProtocolBufferException.invalidTag();
+ }
+ switch (WireFormat.getTagWireType(tag)) {
+ case WireFormat.WIRETYPE_VARINT:
+ position = decodeVarint64(data, position, registers);
+ return position;
+ case WireFormat.WIRETYPE_FIXED32:
+ return position + 4;
+ case WireFormat.WIRETYPE_FIXED64:
+ return position + 8;
+ case WireFormat.WIRETYPE_LENGTH_DELIMITED:
+ position = decodeVarint32(data, position, registers);
+ return position + registers.int1;
+ case WireFormat.WIRETYPE_START_GROUP:
+ final int endGroup = (tag & ~0x7) | WireFormat.WIRETYPE_END_GROUP;
+ int lastTag = 0;
+ while (position < limit) {
+ position = decodeVarint32(data, position, registers);
+ lastTag = registers.int1;
+ if (lastTag == endGroup) {
+ break;
+ }
+ position = skipField(lastTag, data, position, limit, registers);
+ }
+ if (position > limit || lastTag != endGroup) {
+ throw InvalidProtocolBufferException.parseFailure();
+ }
+ return position;
+ default:
+ throw InvalidProtocolBufferException.invalidTag();
+ }
+ }
+}
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 100755
index 0000000..d64574c
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/BinaryReader.java
@@ -0,0 +1,1729 @@
+// 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.WireFormat.FIXED32_SIZE;
+import static com.google.protobuf.WireFormat.FIXED64_SIZE;
+import static com.google.protobuf.WireFormat.WIRETYPE_END_GROUP;
+import static com.google.protobuf.WireFormat.WIRETYPE_FIXED32;
+import static com.google.protobuf.WireFormat.WIRETYPE_FIXED64;
+import static com.google.protobuf.WireFormat.WIRETYPE_LENGTH_DELIMITED;
+import static com.google.protobuf.WireFormat.WIRETYPE_START_GROUP;
+import static com.google.protobuf.WireFormat.WIRETYPE_VARINT;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A {@link Reader} that reads from a buffer containing a message serialized with the binary
+ * protocol.
+ */
+@ExperimentalApi
+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();
+
+ @Override
+ public boolean shouldDiscardUnknownFields() {
+ return false;
+ }
+
+ /**
+ * 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 WireFormat.getTagFieldNumber(tag);
+ }
+
+ @Override
+ public int getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean skipField() throws IOException {
+ if (isAtEnd() || tag == endGroupTag) {
+ return false;
+ }
+
+ switch (WireFormat.getTagWireType(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;
+ case WIRETYPE_START_GROUP:
+ skipGroup();
+ 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 {
+ return readStringInternal(false);
+ }
+
+ @Override
+ public String readStringRequireUtf8() throws IOException {
+ return readStringInternal(true);
+ }
+
+ public String readStringInternal(boolean requireUtf8) throws IOException {
+ requireWireType(WIRETYPE_LENGTH_DELIMITED);
+ final int size = readVarint32();
+ if (size == 0) {
+ return "";
+ }
+
+ requireBytes(size);
+ if (requireUtf8 && !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> T readMessage(Class<T> clazz, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ requireWireType(WIRETYPE_LENGTH_DELIMITED);
+ return readMessage(Protobuf.getInstance().schemaFor(clazz), extensionRegistry);
+ }
+
+ @Override
+ public <T> T readMessageBySchemaWithCheck(
+ Schema<T> schema, ExtensionRegistryLite extensionRegistry) throws IOException {
+ requireWireType(WIRETYPE_LENGTH_DELIMITED);
+ return readMessage(schema, extensionRegistry);
+ }
+
+ private <T> T readMessage(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ 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, extensionRegistry);
+ schema.makeImmutable(message);
+
+ if (pos != newLimit) {
+ throw InvalidProtocolBufferException.parseFailure();
+ }
+ return message;
+ } finally {
+ // Restore the limit.
+ limit = prevLimit;
+ }
+ }
+
+ @Override
+ public <T> T readGroup(Class<T> clazz, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ requireWireType(WIRETYPE_START_GROUP);
+ return readGroup(Protobuf.getInstance().schemaFor(clazz), extensionRegistry);
+ }
+
+ @Override
+ public <T> T readGroupBySchemaWithCheck(
+ Schema<T> schema, ExtensionRegistryLite extensionRegistry) throws IOException {
+ requireWireType(WIRETYPE_START_GROUP);
+ return readGroup(schema, extensionRegistry);
+ }
+
+ private <T> T readGroup(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ int prevEndGroupTag = endGroupTag;
+ endGroupTag = WireFormat.makeTag(WireFormat.getTagFieldNumber(tag), WIRETYPE_END_GROUP);
+
+ try {
+ // Allocate and read the message.
+ T message = schema.newInstance();
+ schema.mergeFrom(message, this, extensionRegistry);
+ schema.makeImmutable(message);
+
+ 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 CodedInputStream.decodeZigZag32(readVarint32());
+ }
+
+ @Override
+ public long readSInt64() throws IOException {
+ requireWireType(WIRETYPE_VARINT);
+ return CodedInputStream.decodeZigZag64(readVarint64());
+ }
+
+ @Override
+ public void readDoubleList(List<Double> target) throws IOException {
+ if (target instanceof DoubleArrayList) {
+ DoubleArrayList plist = (DoubleArrayList) target;
+ switch (WireFormat.getTagWireType(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 (WireFormat.getTagWireType(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<Float> target) throws IOException {
+ if (target instanceof FloatArrayList) {
+ FloatArrayList plist = (FloatArrayList) target;
+ switch (WireFormat.getTagWireType(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 (WireFormat.getTagWireType(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<Long> target) throws IOException {
+ if (target instanceof LongArrayList) {
+ LongArrayList plist = (LongArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ plist.addLong(readVarint64());
+ }
+ requirePosition(fieldEndPos);
+ 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 (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ target.add(readVarint64());
+ }
+ requirePosition(fieldEndPos);
+ 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<Long> target) throws IOException {
+ if (target instanceof LongArrayList) {
+ LongArrayList plist = (LongArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ plist.addLong(readVarint64());
+ }
+ requirePosition(fieldEndPos);
+ 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 (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ target.add(readVarint64());
+ }
+ requirePosition(fieldEndPos);
+ 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<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ plist.addInt(readVarint32());
+ }
+ requirePosition(fieldEndPos);
+ 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 (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ target.add(readVarint32());
+ }
+ requirePosition(fieldEndPos);
+ 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<Long> target) throws IOException {
+ if (target instanceof LongArrayList) {
+ LongArrayList plist = (LongArrayList) target;
+ switch (WireFormat.getTagWireType(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 (WireFormat.getTagWireType(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<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(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 (WireFormat.getTagWireType(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<Boolean> target) throws IOException {
+ if (target instanceof BooleanArrayList) {
+ BooleanArrayList plist = (BooleanArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ plist.addBoolean(readVarint32() != 0);
+ }
+ requirePosition(fieldEndPos);
+ 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 (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ target.add(readVarint32() != 0);
+ }
+ requirePosition(fieldEndPos);
+ 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<String> target) throws IOException {
+ readStringListInternal(target, false);
+ }
+
+ @Override
+ public void readStringListRequireUtf8(List<String> target) throws IOException {
+ readStringListInternal(target, true);
+ }
+
+ public void readStringListInternal(List<String> target, boolean requireUtf8)
+ throws IOException {
+ if (WireFormat.getTagWireType(tag) != WIRETYPE_LENGTH_DELIMITED) {
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+
+ if (target instanceof LazyStringList && !requireUtf8) {
+ LazyStringList lazyList = (LazyStringList) target;
+ while (true) {
+ lazyList.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;
+ }
+ }
+ } else {
+ while (true) {
+ target.add(readStringInternal(requireUtf8));
+
+ 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 <T> void readMessageList(
+ List<T> target, Class<T> targetType, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ final Schema<T> schema = Protobuf.getInstance().schemaFor(targetType);
+ readMessageList(target, schema, extensionRegistry);
+ }
+
+ @Override
+ public <T> void readMessageList(
+ List<T> target, Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ if (WireFormat.getTagWireType(tag) != WIRETYPE_LENGTH_DELIMITED) {
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ final int listTag = tag;
+ while (true) {
+ target.add(readMessage(schema, extensionRegistry));
+
+ 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 <T> void readGroupList(
+ List<T> target, Class<T> targetType, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ final Schema<T> schema = Protobuf.getInstance().schemaFor(targetType);
+ readGroupList(target, schema, extensionRegistry);
+ }
+
+ @Override
+ public <T> void readGroupList(
+ List<T> target, Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ if (WireFormat.getTagWireType(tag) != WIRETYPE_START_GROUP) {
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ final int listTag = tag;
+ while (true) {
+ target.add(readGroup(schema, extensionRegistry));
+
+ 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<ByteString> target) throws IOException {
+ if (WireFormat.getTagWireType(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<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(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 (WireFormat.getTagWireType(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<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(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 (WireFormat.getTagWireType(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<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(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 (WireFormat.getTagWireType(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<Long> target) throws IOException {
+ if (target instanceof LongArrayList) {
+ LongArrayList plist = (LongArrayList) target;
+ switch (WireFormat.getTagWireType(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 (WireFormat.getTagWireType(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<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ plist.addInt(CodedInputStream.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 (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ target.add(CodedInputStream.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<Long> target) throws IOException {
+ if (target instanceof LongArrayList) {
+ LongArrayList plist = (LongArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ plist.addLong(CodedInputStream.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 (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = readVarint32();
+ final int fieldEndPos = pos + bytes;
+ while (pos < fieldEndPos) {
+ target.add(CodedInputStream.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();
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public <K, V> void readMap(
+ Map<K, V> target,
+ MapEntryLite.Metadata<K, V> metadata,
+ ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ requireWireType(WIRETYPE_LENGTH_DELIMITED);
+ int size = readVarint32();
+ requireBytes(size);
+
+ // Update the limit.
+ int prevLimit = limit;
+ int newLimit = pos + size;
+ limit = newLimit;
+
+ try {
+ K key = metadata.defaultKey;
+ V value = metadata.defaultValue;
+ while (true) {
+ int number = getFieldNumber();
+ if (number == READ_DONE) {
+ break;
+ }
+ try {
+ switch (number) {
+ case 1:
+ key = (K) readField(metadata.keyType, null, null);
+ break;
+ case 2:
+ value =
+ (V)
+ readField(
+ metadata.valueType,
+ metadata.defaultValue.getClass(),
+ extensionRegistry);
+ break;
+ default:
+ if (!skipField()) {
+ throw new InvalidProtocolBufferException("Unable to parse map entry.");
+ }
+ break;
+ }
+ } catch (InvalidProtocolBufferException.InvalidWireTypeException ignore) {
+ // the type doesn't match, skip the field.
+ if (!skipField()) {
+ throw new InvalidProtocolBufferException("Unable to parse map entry.");
+ }
+ }
+ }
+ target.put(key, value);
+ } finally {
+ // Restore the limit.
+ limit = prevLimit;
+ }
+ }
+
+ private Object readField(
+ WireFormat.FieldType fieldType,
+ Class<?> messageType,
+ ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ switch (fieldType) {
+ case BOOL:
+ return readBool();
+ case BYTES:
+ return readBytes();
+ case DOUBLE:
+ return readDouble();
+ case ENUM:
+ return readEnum();
+ case FIXED32:
+ return readFixed32();
+ case FIXED64:
+ return readFixed64();
+ case FLOAT:
+ return readFloat();
+ case INT32:
+ return readInt32();
+ case INT64:
+ return readInt64();
+ case MESSAGE:
+ return readMessage(messageType, extensionRegistry);
+ case SFIXED32:
+ return readSFixed32();
+ case SFIXED64:
+ return readSFixed64();
+ case SINT32:
+ return readSInt32();
+ case SINT64:
+ return readSInt64();
+ case STRING:
+ return readStringRequireUtf8();
+ case UINT32:
+ return readUInt32();
+ case UINT64:
+ return readUInt64();
+ default:
+ throw new RuntimeException("unsupported field type.");
+ }
+ }
+
+ /** 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 skipGroup() throws IOException {
+ int prevEndGroupTag = endGroupTag;
+ endGroupTag = WireFormat.makeTag(WireFormat.getTagFieldNumber(tag), WIRETYPE_END_GROUP);
+ while (true) {
+ if (getFieldNumber() == READ_DONE || !skipField()) {
+ break;
+ }
+ }
+ if (tag != endGroupTag) {
+ throw InvalidProtocolBufferException.parseFailure();
+ }
+ endGroupTag = prevEndGroupTag;
+ }
+
+ private void requireBytes(int size) throws IOException {
+ if (size < 0 || size > (limit - pos)) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ }
+
+ private void requireWireType(int requiredWireType) throws IOException {
+ if (WireFormat.getTagWireType(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();
+ }
+ }
+
+ private void requirePosition(int expectedPosition) throws IOException {
+ if (pos != expectedPosition) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ }
+ }
+}
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 100755
index 0000000..94259ec
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/BinaryWriter.java
@@ -0,0 +1,3071 @@
+// 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 static com.google.protobuf.WireFormat.FIXED32_SIZE;
+import static com.google.protobuf.WireFormat.FIXED64_SIZE;
+import static com.google.protobuf.WireFormat.MAX_VARINT32_SIZE;
+import static com.google.protobuf.WireFormat.MAX_VARINT64_SIZE;
+import static com.google.protobuf.WireFormat.MESSAGE_SET_ITEM;
+import static com.google.protobuf.WireFormat.MESSAGE_SET_MESSAGE;
+import static com.google.protobuf.WireFormat.MESSAGE_SET_TYPE_ID;
+import static com.google.protobuf.WireFormat.WIRETYPE_END_GROUP;
+import static com.google.protobuf.WireFormat.WIRETYPE_FIXED32;
+import static com.google.protobuf.WireFormat.WIRETYPE_FIXED64;
+import static com.google.protobuf.WireFormat.WIRETYPE_LENGTH_DELIMITED;
+import static com.google.protobuf.WireFormat.WIRETYPE_START_GROUP;
+import static com.google.protobuf.WireFormat.WIRETYPE_VARINT;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.ArrayDeque;
+import java.util.List;
+import java.util.Map;
+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()}.
+ *
+ * <p>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
+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<AllocatedBuffer> buffers = new ArrayDeque<AllocatedBuffer>(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;
+ }
+
+ @Override
+ public final FieldOrder fieldOrder() {
+ return FieldOrder.DESCENDING;
+ }
+
+ /**
+ * Completes the write operation and returns a queue of {@link AllocatedBuffer} objects in
+ * forward-writing order. This method should only be called once.
+ *
+ * <p>After calling this method, the writer can not be reused. Create a new writer for future
+ * writes.
+ */
+ public final Queue<AllocatedBuffer> complete() {
+ finishCurrentBuffer();
+ return buffers;
+ }
+
+ @Override
+ public final void writeSFixed32(int fieldNumber, int value) throws IOException {
+ writeFixed32(fieldNumber, value);
+ }
+
+ @Override
+ public final void writeInt64(int fieldNumber, long value) throws IOException {
+ writeUInt64(fieldNumber, value);
+ }
+
+ @Override
+ public final void writeSFixed64(int fieldNumber, long value) throws IOException {
+ writeFixed64(fieldNumber, value);
+ }
+
+ @Override
+ public final void writeFloat(int fieldNumber, float value) throws IOException {
+ writeFixed32(fieldNumber, Float.floatToRawIntBits(value));
+ }
+
+ @Override
+ public final void writeDouble(int fieldNumber, double value) throws IOException {
+ writeFixed64(fieldNumber, Double.doubleToRawLongBits(value));
+ }
+
+ @Override
+ public final void writeEnum(int fieldNumber, int value) throws IOException {
+ writeInt32(fieldNumber, value);
+ }
+
+ @Override
+ public final void writeInt32List(int fieldNumber, List<Integer> list, boolean packed)
+ throws IOException {
+ if (list instanceof IntArrayList) {
+ writeInt32List_Internal(fieldNumber, (IntArrayList) list, packed);
+ } else {
+ writeInt32List_Internal(fieldNumber, list, packed);
+ }
+ }
+
+ private final void writeInt32List_Internal(int fieldNumber, List<Integer> list, boolean packed)
+ throws IOException {
+ 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)
+ throws IOException {
+ 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<Integer> list, boolean packed)
+ throws IOException {
+ if (list instanceof IntArrayList) {
+ writeFixed32List_Internal(fieldNumber, (IntArrayList) list, packed);
+ } else {
+ writeFixed32List_Internal(fieldNumber, list, packed);
+ }
+ }
+
+ private final void writeFixed32List_Internal(int fieldNumber, List<Integer> list, boolean packed)
+ throws IOException {
+ 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)
+ throws IOException {
+ 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<Long> list, boolean packed)
+ throws IOException {
+ writeUInt64List(fieldNumber, list, packed);
+ }
+
+ @Override
+ public final void writeUInt64List(int fieldNumber, List<Long> list, boolean packed)
+ throws IOException {
+ if (list instanceof LongArrayList) {
+ writeUInt64List_Internal(fieldNumber, (LongArrayList) list, packed);
+ } else {
+ writeUInt64List_Internal(fieldNumber, list, packed);
+ }
+ }
+
+ private final void writeUInt64List_Internal(int fieldNumber, List<Long> list, boolean packed)
+ throws IOException {
+ 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)
+ throws IOException {
+ 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<Long> list, boolean packed)
+ throws IOException {
+ if (list instanceof LongArrayList) {
+ writeFixed64List_Internal(fieldNumber, (LongArrayList) list, packed);
+ } else {
+ writeFixed64List_Internal(fieldNumber, list, packed);
+ }
+ }
+
+ private final void writeFixed64List_Internal(int fieldNumber, List<Long> list, boolean packed)
+ throws IOException {
+ 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)
+ throws IOException {
+ 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<Float> list, boolean packed)
+ throws IOException {
+ if (list instanceof FloatArrayList) {
+ writeFloatList_Internal(fieldNumber, (FloatArrayList) list, packed);
+ } else {
+ writeFloatList_Internal(fieldNumber, list, packed);
+ }
+ }
+
+ private final void writeFloatList_Internal(int fieldNumber, List<Float> list, boolean packed)
+ throws IOException {
+ 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)
+ throws IOException {
+ 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<Double> list, boolean packed)
+ throws IOException {
+ if (list instanceof DoubleArrayList) {
+ writeDoubleList_Internal(fieldNumber, (DoubleArrayList) list, packed);
+ } else {
+ writeDoubleList_Internal(fieldNumber, list, packed);
+ }
+ }
+
+ private final void writeDoubleList_Internal(int fieldNumber, List<Double> list, boolean packed)
+ throws IOException {
+ 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)
+ throws IOException {
+ 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<Integer> list, boolean packed)
+ throws IOException {
+ writeInt32List(fieldNumber, list, packed);
+ }
+
+ @Override
+ public final void writeBoolList(int fieldNumber, List<Boolean> list, boolean packed)
+ throws IOException {
+ if (list instanceof BooleanArrayList) {
+ writeBoolList_Internal(fieldNumber, (BooleanArrayList) list, packed);
+ } else {
+ writeBoolList_Internal(fieldNumber, list, packed);
+ }
+ }
+
+ private final void writeBoolList_Internal(int fieldNumber, List<Boolean> list, boolean packed)
+ throws IOException {
+ 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)
+ throws IOException {
+ 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<String> list) throws IOException {
+ if (list instanceof LazyStringList) {
+ final LazyStringList lazyList = (LazyStringList) list;
+ for (int i = list.size() - 1; i >= 0; i--) {
+ writeLazyString(fieldNumber, lazyList.getRaw(i));
+ }
+ } else {
+ for (int i = list.size() - 1; i >= 0; i--) {
+ writeString(fieldNumber, list.get(i));
+ }
+ }
+ }
+
+ private void writeLazyString(int fieldNumber, Object value) throws IOException {
+ if (value instanceof String) {
+ writeString(fieldNumber, (String) value);
+ } else {
+ writeBytes(fieldNumber, (ByteString) value);
+ }
+ }
+
+ @Override
+ public final void writeBytesList(int fieldNumber, List<ByteString> list) throws IOException {
+ for (int i = list.size() - 1; i >= 0; i--) {
+ writeBytes(fieldNumber, list.get(i));
+ }
+ }
+
+ @Override
+ public final void writeUInt32List(int fieldNumber, List<Integer> list, boolean packed)
+ throws IOException {
+ if (list instanceof IntArrayList) {
+ writeUInt32List_Internal(fieldNumber, (IntArrayList) list, packed);
+ } else {
+ writeUInt32List_Internal(fieldNumber, list, packed);
+ }
+ }
+
+ private final void writeUInt32List_Internal(int fieldNumber, List<Integer> list, boolean packed)
+ throws IOException {
+ 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)
+ throws IOException {
+ 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<Integer> list, boolean packed)
+ throws IOException {
+ writeFixed32List(fieldNumber, list, packed);
+ }
+
+ @Override
+ public final void writeSFixed64List(int fieldNumber, List<Long> list, boolean packed)
+ throws IOException {
+ writeFixed64List(fieldNumber, list, packed);
+ }
+
+ @Override
+ public final void writeSInt32List(int fieldNumber, List<Integer> list, boolean packed)
+ throws IOException {
+ if (list instanceof IntArrayList) {
+ writeSInt32List_Internal(fieldNumber, (IntArrayList) list, packed);
+ } else {
+ writeSInt32List_Internal(fieldNumber, list, packed);
+ }
+ }
+
+ private final void writeSInt32List_Internal(int fieldNumber, List<Integer> list, boolean packed)
+ throws IOException {
+ 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)
+ throws IOException {
+ 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<Long> list, boolean packed)
+ throws IOException {
+ if (list instanceof LongArrayList) {
+ writeSInt64List_Internal(fieldNumber, (LongArrayList) list, packed);
+ } else {
+ writeSInt64List_Internal(fieldNumber, list, packed);
+ }
+ }
+
+ private static final int MAP_KEY_NUMBER = 1;
+ private static final int MAP_VALUE_NUMBER = 2;
+
+ @Override
+ public <K, V> void writeMap(int fieldNumber, MapEntryLite.Metadata<K, V> metadata, Map<K, V> map)
+ throws IOException {
+ // TODO(liujisi): Reverse write those entries.
+ for (Map.Entry<K, V> entry : map.entrySet()) {
+ int prevBytes = getTotalBytesWritten();
+ writeMapEntryField(this, MAP_VALUE_NUMBER, metadata.valueType, entry.getValue());
+ writeMapEntryField(this, MAP_KEY_NUMBER, metadata.keyType, entry.getKey());
+ int length = getTotalBytesWritten() - prevBytes;
+ writeVarint32(length);
+ writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+ }
+ }
+
+ static final void writeMapEntryField(
+ Writer writer, int fieldNumber, WireFormat.FieldType fieldType, Object object)
+ throws IOException {
+ switch (fieldType) {
+ case BOOL:
+ writer.writeBool(fieldNumber, (Boolean) object);
+ break;
+ case FIXED32:
+ writer.writeFixed32(fieldNumber, (Integer) object);
+ break;
+ case FIXED64:
+ writer.writeFixed64(fieldNumber, (Long) object);
+ break;
+ case INT32:
+ writer.writeInt32(fieldNumber, (Integer) object);
+ break;
+ case INT64:
+ writer.writeInt64(fieldNumber, (Long) object);
+ break;
+ case SFIXED32:
+ writer.writeSFixed32(fieldNumber, (Integer) object);
+ break;
+ case SFIXED64:
+ writer.writeSFixed64(fieldNumber, (Long) object);
+ break;
+ case SINT32:
+ writer.writeSInt32(fieldNumber, (Integer) object);
+ break;
+ case SINT64:
+ writer.writeSInt64(fieldNumber, (Long) object);
+ break;
+ case STRING:
+ writer.writeString(fieldNumber, (String) object);
+ break;
+ case UINT32:
+ writer.writeUInt32(fieldNumber, (Integer) object);
+ break;
+ case UINT64:
+ writer.writeUInt64(fieldNumber, (Long) object);
+ break;
+ case FLOAT:
+ writer.writeFloat(fieldNumber, (Float) object);
+ break;
+ case DOUBLE:
+ writer.writeDouble(fieldNumber, (Double) object);
+ break;
+ case MESSAGE:
+ writer.writeMessage(fieldNumber, object);
+ break;
+ case BYTES:
+ writer.writeBytes(fieldNumber, (ByteString) object);
+ break;
+ case ENUM:
+ if (object instanceof Internal.EnumLite) {
+ writer.writeEnum(fieldNumber, ((Internal.EnumLite) object).getNumber());
+ } else if (object instanceof Integer) {
+ writer.writeEnum(fieldNumber, (Integer) object);
+ } else {
+ throw new IllegalArgumentException("Unexpected type for enum in map.");
+ }
+ break;
+ default:
+ throw new IllegalArgumentException("Unsupported map value type for: " + fieldType);
+ }
+ }
+
+ private final void writeSInt64List_Internal(int fieldNumber, List<Long> list, boolean packed)
+ throws IOException {
+ 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)
+ throws IOException {
+ 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) throws IOException {
+ for (int i = list.size() - 1; i >= 0; i--) {
+ writeMessage(fieldNumber, list.get(i));
+ }
+ }
+
+ @Override
+ public final void writeMessageList(int fieldNumber, List<?> list, Schema schema)
+ throws IOException {
+ for (int i = list.size() - 1; i >= 0; i--) {
+ writeMessage(fieldNumber, list.get(i), schema);
+ }
+ }
+
+ @Override
+ public final void writeGroupList(int fieldNumber, List<?> list) throws IOException {
+ for (int i = list.size() - 1; i >= 0; i--) {
+ writeGroup(fieldNumber, list.get(i));
+ }
+ }
+
+ @Override
+ public final void writeGroupList(int fieldNumber, List<?> list, Schema schema)
+ throws IOException {
+ for (int i = list.size() - 1; i >= 0; i--) {
+ writeGroup(fieldNumber, list.get(i), schema);
+ }
+ }
+
+ @Override
+ public final void writeMessageSetItem(int fieldNumber, Object value) throws IOException {
+ writeTag(MESSAGE_SET_ITEM, WIRETYPE_END_GROUP);
+ if (value instanceof ByteString) {
+ writeBytes(MESSAGE_SET_MESSAGE, (ByteString) value);
+ } else {
+ writeMessage(MESSAGE_SET_MESSAGE, value);
+ }
+ writeUInt32(MESSAGE_SET_TYPE_ID, fieldNumber);
+ writeTag(MESSAGE_SET_ITEM, WIRETYPE_START_GROUP);
+ }
+
+ 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, int 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) throws IOException {
+ requireSpace(MAX_VARINT32_SIZE * 2);
+ writeVarint32(value);
+ writeTag(fieldNumber, WIRETYPE_VARINT);
+ }
+
+ @Override
+ public void writeInt32(int fieldNumber, int value) throws IOException {
+ requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE);
+ writeInt32(value);
+ writeTag(fieldNumber, WIRETYPE_VARINT);
+ }
+
+ @Override
+ public void writeSInt32(int fieldNumber, int value) throws IOException {
+ requireSpace(MAX_VARINT32_SIZE * 2);
+ writeSInt32(value);
+ writeTag(fieldNumber, WIRETYPE_VARINT);
+ }
+
+ @Override
+ public void writeFixed32(int fieldNumber, int value) throws IOException {
+ requireSpace(MAX_VARINT32_SIZE + FIXED32_SIZE);
+ writeFixed32(value);
+ writeTag(fieldNumber, WIRETYPE_FIXED32);
+ }
+
+ @Override
+ public void writeUInt64(int fieldNumber, long value) throws IOException {
+ requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE);
+ writeVarint64(value);
+ writeTag(fieldNumber, WIRETYPE_VARINT);
+ }
+
+ @Override
+ public void writeSInt64(int fieldNumber, long value) throws IOException {
+ requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE);
+ writeSInt64(value);
+ writeTag(fieldNumber, WIRETYPE_VARINT);
+ }
+
+ @Override
+ public void writeFixed64(int fieldNumber, long value) throws IOException {
+ requireSpace(MAX_VARINT32_SIZE + FIXED64_SIZE);
+ writeFixed64(value);
+ writeTag(fieldNumber, WIRETYPE_FIXED64);
+ }
+
+ @Override
+ public void writeBool(int fieldNumber, boolean value) throws IOException {
+ requireSpace(MAX_VARINT32_SIZE + 1);
+ write((byte) (value ? 1 : 0));
+ writeTag(fieldNumber, WIRETYPE_VARINT);
+ }
+
+ @Override
+ public void writeString(int fieldNumber, String value) throws IOException {
+ 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) throws IOException {
+ 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) throws IOException {
+ 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 writeMessage(int fieldNumber, Object value, Schema schema) throws IOException {
+ int prevBytes = getTotalBytesWritten();
+ schema.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) throws IOException {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ Protobuf.getInstance().writeTo(value, this);
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeGroup(int fieldNumber, Object value, Schema schema) throws IOException {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ schema.writeTo(value, this);
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeStartGroup(int fieldNumber) {
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeEndGroup(int fieldNumber) {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ }
+
+ @Override
+ void writeInt32(int value) {
+ if (value >= 0) {
+ writeVarint32(value);
+ } else {
+ writeVarint64(value);
+ }
+ }
+
+ @Override
+ void writeSInt32(int value) {
+ writeVarint32(CodedOutputStream.encodeZigZag32(value));
+ }
+
+ @Override
+ void writeSInt64(long value) {
+ writeVarint64(CodedOutputStream.encodeZigZag64(value));
+ }
+
+ @Override
+ void writeBool(boolean value) {
+ write((byte) (value ? 1 : 0));
+ }
+
+ @Override
+ void writeTag(int fieldNumber, int wireType) {
+ writeVarint32(WireFormat.makeTag(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://wiki.openjdk.java.net/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;
+ }
+
+ 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 (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) throws IOException {
+ 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 writeMessage(int fieldNumber, Object value, Schema schema) throws IOException {
+ int prevBytes = getTotalBytesWritten();
+ schema.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) throws IOException {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ Protobuf.getInstance().writeTo(value, this);
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeGroup(int fieldNumber, Object value, Schema schema) throws IOException {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ schema.writeTo(value, this);
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeStartGroup(int fieldNumber) {
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeEndGroup(int fieldNumber) {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ }
+
+ @Override
+ void writeInt32(int value) {
+ if (value >= 0) {
+ writeVarint32(value);
+ } else {
+ writeVarint64(value);
+ }
+ }
+
+ @Override
+ void writeSInt32(int value) {
+ writeVarint32(CodedOutputStream.encodeZigZag32(value));
+ }
+
+ @Override
+ void writeSInt64(long value) {
+ writeVarint64(CodedOutputStream.encodeZigZag64(value));
+ }
+
+ @Override
+ void writeBool(boolean value) {
+ write((byte) (value ? 1 : 0));
+ }
+
+ @Override
+ void writeTag(int fieldNumber, int wireType) {
+ writeVarint32(WireFormat.makeTag(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://wiki.openjdk.java.net/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) throws IOException {
+ 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 writeMessage(int fieldNumber, Object value, Schema schema) throws IOException {
+ int prevBytes = getTotalBytesWritten();
+ schema.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) throws IOException {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ Protobuf.getInstance().writeTo(value, this);
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeGroup(int fieldNumber, Object value, Schema schema) throws IOException {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ schema.writeTo(value, this);
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeStartGroup(int fieldNumber) {
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeEndGroup(int fieldNumber) {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ }
+
+ @Override
+ void writeInt32(int value) {
+ if (value >= 0) {
+ writeVarint32(value);
+ } else {
+ writeVarint64(value);
+ }
+ }
+
+ @Override
+ void writeSInt32(int value) {
+ writeVarint32(CodedOutputStream.encodeZigZag32(value));
+ }
+
+ @Override
+ void writeSInt64(long value) {
+ writeVarint64(CodedOutputStream.encodeZigZag64(value));
+ }
+
+ @Override
+ void writeBool(boolean value) {
+ write((byte) (value ? 1 : 0));
+ }
+
+ @Override
+ void writeTag(int fieldNumber, int wireType) {
+ writeVarint32(WireFormat.makeTag(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://wiki.openjdk.java.net/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) throws IOException {
+ 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 writeMessage(int fieldNumber, Object value, Schema schema) throws IOException {
+ int prevBytes = getTotalBytesWritten();
+ schema.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) throws IOException {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ Protobuf.getInstance().writeTo(value, this);
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeGroup(int fieldNumber, Object value, Schema schema) throws IOException {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ schema.writeTo(value, this);
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeStartGroup(int fieldNumber) {
+ writeTag(fieldNumber, WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeEndGroup(int fieldNumber) {
+ writeTag(fieldNumber, WIRETYPE_END_GROUP);
+ }
+
+ @Override
+ void writeInt32(int value) {
+ if (value >= 0) {
+ writeVarint32(value);
+ } else {
+ writeVarint64(value);
+ }
+ }
+
+ @Override
+ void writeSInt32(int value) {
+ writeVarint32(CodedOutputStream.encodeZigZag32(value));
+ }
+
+ @Override
+ void writeSInt64(long value) {
+ writeVarint64(CodedOutputStream.encodeZigZag64(value));
+ }
+
+ @Override
+ void writeBool(boolean value) {
+ write((byte) (value ? 1 : 0));
+ }
+
+ @Override
+ void writeTag(int fieldNumber, int wireType) {
+ writeVarint32(WireFormat.makeTag(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://wiki.openjdk.java.net/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;
+ buffer.position(bufferPos() + 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(bufferPos() + 1);
+ buffer.put(value);
+ }
+
+ @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 100755
index 0000000..bfd9c72
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/BufferAllocator.java
@@ -0,0 +1,64 @@
+// 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
+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 648991d..e5454a6 100644
--- a/java/core/src/main/java/com/google/protobuf/ByteString.java
+++ b/java/core/src/main/java/com/google/protobuf/ByteString.java
@@ -732,6 +732,16 @@
*/
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 is equal to the contents of
@@ -862,6 +872,10 @@
return true;
}
+ @Override
+ void writeToReverse(ByteOutput byteOutput) throws IOException {
+ writeTo(byteOutput);
+ }
/**
* Check equality of the substring of given length of this object starting at zero with another
@@ -1438,14 +1452,16 @@
LiteralByteString lbsOther = (LiteralByteString) other;
byte[] thisBytes = bytes;
byte[] otherBytes = lbsOther.bytes;
-
- return UnsafeUtil.mismatch(
- thisBytes,
- getOffsetIntoBytes(),
- otherBytes,
- lbsOther.getOffsetIntoBytes() + offset,
- length)
- == -1;
+ int thisLimit = getOffsetIntoBytes() + length;
+ for (int thisIndex = getOffsetIntoBytes(),
+ otherIndex = lbsOther.getOffsetIntoBytes() + offset;
+ (thisIndex < thisLimit);
+ ++thisIndex, ++otherIndex) {
+ if (thisBytes[thisIndex] != otherBytes[otherIndex]) {
+ return false;
+ }
+ }
+ return true;
}
return other.substring(offset, offset + length).equals(substring(0, length));
diff --git a/java/core/src/main/java/com/google/protobuf/CodedInputStream.java b/java/core/src/main/java/com/google/protobuf/CodedInputStream.java
index 6cece05..87c6837 100644
--- a/java/core/src/main/java/com/google/protobuf/CodedInputStream.java
+++ b/java/core/src/main/java/com/google/protobuf/CodedInputStream.java
@@ -72,6 +72,9 @@
/** Visible for subclasses. See setSizeLimit() */
int sizeLimit = DEFAULT_SIZE_LIMIT;
+ /** Used to adapt to the experimental {@link Reader} interface. */
+ CodedInputStreamReader wrapper;
+
/** Create a new CodedInputStream wrapping the given InputStream. */
public static CodedInputStream newInstance(final InputStream input) {
return newInstance(input, DEFAULT_BUFFER_SIZE);
@@ -2263,7 +2266,7 @@
return result;
}
// Slow path: Build a byte array first then copy it.
- return new String(readRawBytesSlowPath(size), UTF_8);
+ return new String(readRawBytesSlowPath(size, /* ensureNoLeakedReferences= */ false), UTF_8);
}
@Override
@@ -2287,7 +2290,7 @@
pos = tempPos + size;
} else {
// Slow path: Build a byte array first then copy it.
- bytes = readRawBytesSlowPath(size);
+ bytes = readRawBytesSlowPath(size, /* ensureNoLeakedReferences= */ false);
tempPos = 0;
}
return Utf8.decodeUtf8(bytes, tempPos, size);
@@ -2392,7 +2395,8 @@
return result;
} else {
// Slow path: Build a byte array first then copy it.
- return readRawBytesSlowPath(size);
+ // TODO(dweis): Do we want to protect from malicious input streams here?
+ return readRawBytesSlowPath(size, /* ensureNoLeakedReferences= */ false);
}
}
@@ -2409,7 +2413,10 @@
return Internal.EMPTY_BYTE_BUFFER;
}
// Slow path: Build a byte array first then copy it.
- return ByteBuffer.wrap(readRawBytesSlowPath(size));
+
+ // We must copy as the byte array was handed off to the InputStream and a malicious
+ // implementation could retain a reference.
+ return ByteBuffer.wrap(readRawBytesSlowPath(size, /* ensureNoLeakedReferences= */ true));
}
@Override
@@ -2812,19 +2819,24 @@
pos = tempPos + size;
return Arrays.copyOfRange(buffer, tempPos, tempPos + size);
} else {
- return readRawBytesSlowPath(size);
+ // TODO(dweis): Do we want to protect from malicious input streams here?
+ return readRawBytesSlowPath(size, /* ensureNoLeakedReferences= */ false);
}
}
/**
* Exactly like readRawBytes, but caller must have already checked the fast path: (size <=
* (bufferSize - pos) && size > 0)
+ *
+ * If ensureNoLeakedReferences is true, the value is guaranteed to have not escaped to
+ * untrusted code.
*/
- private byte[] readRawBytesSlowPath(final int size) throws IOException {
+ private byte[] readRawBytesSlowPath(
+ final int size, boolean ensureNoLeakedReferences) throws IOException {
// Attempt to read the data in one byte array when it's safe to do.
byte[] result = readRawBytesSlowPathOneChunk(size);
if (result != null) {
- return result;
+ return ensureNoLeakedReferences ? result.clone() : result;
}
final int originalBufferPos = pos;
@@ -2862,6 +2874,8 @@
/**
* Attempts to read the data in one byte array when it's safe to do. Returns null if the size to
* read is too large and needs to be allocated in smaller chunks for security reasons.
+ *
+ * Returns a byte[] that may have escaped to user code via InputStream APIs.
*/
private byte[] readRawBytesSlowPathOneChunk(final int size) throws IOException {
if (size == 0) {
@@ -2916,7 +2930,11 @@
return null;
}
- /** Reads the remaining data in small chunks from the input stream. */
+ /**
+ * Reads the remaining data in small chunks from the input stream.
+ *
+ * Returns a byte[] that may have escaped to user code via InputStream APIs.
+ */
private List<byte[]> readRawBytesSlowPathRemainingChunks(int sizeLeft) throws IOException {
// The size is very large. For security reasons, we can't allocate the
// entire byte array yet. The size comes directly from the input, so a
@@ -2953,7 +2971,9 @@
private ByteString readBytesSlowPath(final int size) throws IOException {
final byte[] result = readRawBytesSlowPathOneChunk(size);
if (result != null) {
- return ByteString.wrap(result);
+ // We must copy as the byte array was handed off to the InputStream and a malicious
+ // implementation could retain a reference.
+ return ByteString.copyFrom(result);
}
final int originalBufferPos = pos;
@@ -2971,13 +2991,20 @@
// chunks.
List<byte[]> chunks = readRawBytesSlowPathRemainingChunks(sizeLeft);
- // Wrap the byte arrays into a single ByteString.
- List<ByteString> byteStrings = new ArrayList<ByteString>(1 + chunks.size());
- byteStrings.add(ByteString.copyFrom(buffer, originalBufferPos, bufferedBytes));
- for (byte[] chunk : chunks) {
- byteStrings.add(ByteString.wrap(chunk));
+ // OK, got everything. Now concatenate it all into one buffer.
+ final byte[] bytes = new byte[size];
+
+ // Start by copying the leftover bytes from this.buffer.
+ System.arraycopy(buffer, originalBufferPos, bytes, 0, bufferedBytes);
+
+ // And now all the chunks.
+ int tempPos = bufferedBytes;
+ for (final byte[] chunk : chunks) {
+ System.arraycopy(chunk, 0, bytes, tempPos, chunk.length);
+ tempPos += chunk.length;
}
- return ByteString.copyFrom(byteStrings);
+
+ return ByteString.wrap(bytes);
}
@Override
diff --git a/java/core/src/main/java/com/google/protobuf/CodedInputStreamReader.java b/java/core/src/main/java/com/google/protobuf/CodedInputStreamReader.java
new file mode 100755
index 0000000..7658f62
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/CodedInputStreamReader.java
@@ -0,0 +1,1333 @@
+// 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.WireFormat.FIXED32_SIZE;
+import static com.google.protobuf.WireFormat.FIXED64_SIZE;
+import static com.google.protobuf.WireFormat.WIRETYPE_END_GROUP;
+import static com.google.protobuf.WireFormat.WIRETYPE_FIXED32;
+import static com.google.protobuf.WireFormat.WIRETYPE_FIXED64;
+import static com.google.protobuf.WireFormat.WIRETYPE_LENGTH_DELIMITED;
+import static com.google.protobuf.WireFormat.WIRETYPE_START_GROUP;
+import static com.google.protobuf.WireFormat.WIRETYPE_VARINT;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+/** An adapter between the {@link Reader} interface and {@link CodedInputStream}. */
+@ExperimentalApi
+final class CodedInputStreamReader implements Reader {
+ private static final int FIXED32_MULTIPLE_MASK = FIXED32_SIZE - 1;
+ private static final int FIXED64_MULTIPLE_MASK = FIXED64_SIZE - 1;
+ private static final int NEXT_TAG_UNSET = 0;
+
+ private final CodedInputStream input;
+ private int tag;
+ private int endGroupTag;
+ private int nextTag = NEXT_TAG_UNSET;
+
+ public static CodedInputStreamReader forCodedInput(CodedInputStream input) {
+ if (input.wrapper != null) {
+ return input.wrapper;
+ }
+ return new CodedInputStreamReader(input);
+ }
+
+ private CodedInputStreamReader(CodedInputStream input) {
+ this.input = Internal.checkNotNull(input, "input");
+ this.input.wrapper = this;
+ }
+
+ @Override
+ public boolean shouldDiscardUnknownFields() {
+ return input.shouldDiscardUnknownFields();
+ }
+
+ @Override
+ public int getFieldNumber() throws IOException {
+ if (nextTag != NEXT_TAG_UNSET) {
+ tag = nextTag;
+ nextTag = NEXT_TAG_UNSET;
+ } else {
+ tag = input.readTag();
+ }
+ if (tag == 0 || tag == endGroupTag) {
+ return Reader.READ_DONE;
+ }
+ return WireFormat.getTagFieldNumber(tag);
+ }
+
+ @Override
+ public int getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean skipField() throws IOException {
+ if (input.isAtEnd() || tag == endGroupTag) {
+ return false;
+ }
+ return input.skipField(tag);
+ }
+
+ private void requireWireType(int requiredWireType) throws IOException {
+ if (WireFormat.getTagWireType(tag) != requiredWireType) {
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+
+ @Override
+ public double readDouble() throws IOException {
+ requireWireType(WIRETYPE_FIXED64);
+ return input.readDouble();
+ }
+
+ @Override
+ public float readFloat() throws IOException {
+ requireWireType(WIRETYPE_FIXED32);
+ return input.readFloat();
+ }
+
+ @Override
+ public long readUInt64() throws IOException {
+ requireWireType(WIRETYPE_VARINT);
+ return input.readUInt64();
+ }
+
+ @Override
+ public long readInt64() throws IOException {
+ requireWireType(WIRETYPE_VARINT);
+ return input.readInt64();
+ }
+
+ @Override
+ public int readInt32() throws IOException {
+ requireWireType(WIRETYPE_VARINT);
+ return input.readInt32();
+ }
+
+ @Override
+ public long readFixed64() throws IOException {
+ requireWireType(WIRETYPE_FIXED64);
+ return input.readFixed64();
+ }
+
+ @Override
+ public int readFixed32() throws IOException {
+ requireWireType(WIRETYPE_FIXED32);
+ return input.readFixed32();
+ }
+
+ @Override
+ public boolean readBool() throws IOException {
+ requireWireType(WIRETYPE_VARINT);
+ return input.readBool();
+ }
+
+ @Override
+ public String readString() throws IOException {
+ requireWireType(WIRETYPE_LENGTH_DELIMITED);
+ return input.readString();
+ }
+
+ @Override
+ public String readStringRequireUtf8() throws IOException {
+ requireWireType(WIRETYPE_LENGTH_DELIMITED);
+ return input.readStringRequireUtf8();
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public <T> T readMessage(Class<T> clazz, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ requireWireType(WIRETYPE_LENGTH_DELIMITED);
+ return readMessage(Protobuf.getInstance().schemaFor(clazz), extensionRegistry);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public <T> T readMessageBySchemaWithCheck(
+ Schema<T> schema, ExtensionRegistryLite extensionRegistry) throws IOException {
+ requireWireType(WIRETYPE_LENGTH_DELIMITED);
+ return readMessage(schema, extensionRegistry);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public <T> T readGroup(Class<T> clazz, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ requireWireType(WIRETYPE_START_GROUP);
+ return readGroup(Protobuf.getInstance().schemaFor(clazz), extensionRegistry);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public <T> T readGroupBySchemaWithCheck(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ requireWireType(WIRETYPE_START_GROUP);
+ return readGroup(schema, extensionRegistry);
+ }
+
+ // Should have the same semantics of CodedInputStream#readMessage()
+ private <T> T readMessage(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ int size = input.readUInt32();
+ if (input.recursionDepth >= input.recursionLimit) {
+ throw InvalidProtocolBufferException.recursionLimitExceeded();
+ }
+
+ // Push the new limit.
+ final int prevLimit = input.pushLimit(size);
+ // Allocate and read the message.
+ T message = schema.newInstance();
+ ++input.recursionDepth;
+ schema.mergeFrom(message, this, extensionRegistry);
+ schema.makeImmutable(message);
+ input.checkLastTagWas(0);
+ --input.recursionDepth;
+ // Restore the previous limit.
+ input.popLimit(prevLimit);
+ return message;
+ }
+
+ private <T> T readGroup(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ int prevEndGroupTag = endGroupTag;
+ endGroupTag = WireFormat.makeTag(WireFormat.getTagFieldNumber(tag), WIRETYPE_END_GROUP);
+
+ try {
+ // Allocate and read the message.
+ T message = schema.newInstance();
+ schema.mergeFrom(message, this, extensionRegistry);
+ schema.makeImmutable(message);
+
+ 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);
+ return input.readBytes();
+ }
+
+ @Override
+ public int readUInt32() throws IOException {
+ requireWireType(WIRETYPE_VARINT);
+ return input.readUInt32();
+ }
+
+ @Override
+ public int readEnum() throws IOException {
+ requireWireType(WIRETYPE_VARINT);
+ return input.readEnum();
+ }
+
+ @Override
+ public int readSFixed32() throws IOException {
+ requireWireType(WIRETYPE_FIXED32);
+ return input.readSFixed32();
+ }
+
+ @Override
+ public long readSFixed64() throws IOException {
+ requireWireType(WIRETYPE_FIXED64);
+ return input.readSFixed64();
+ }
+
+ @Override
+ public int readSInt32() throws IOException {
+ requireWireType(WIRETYPE_VARINT);
+ return input.readSInt32();
+ }
+
+ @Override
+ public long readSInt64() throws IOException {
+ requireWireType(WIRETYPE_VARINT);
+ return input.readSInt64();
+ }
+
+ @Override
+ public void readDoubleList(List<Double> target) throws IOException {
+ if (target instanceof DoubleArrayList) {
+ DoubleArrayList plist = (DoubleArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed64Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addDouble(input.readDouble());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED64:
+ while (true) {
+ plist.addDouble(input.readDouble());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed64Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readDouble());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED64:
+ while (true) {
+ target.add(input.readDouble());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readFloatList(List<Float> target) throws IOException {
+ if (target instanceof FloatArrayList) {
+ FloatArrayList plist = (FloatArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed32Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addFloat(input.readFloat());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED32:
+ while (true) {
+ plist.addFloat(input.readFloat());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed32Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readFloat());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED32:
+ while (true) {
+ target.add(input.readFloat());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readUInt64List(List<Long> target) throws IOException {
+ if (target instanceof LongArrayList) {
+ LongArrayList plist = (LongArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addLong(input.readUInt64());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ plist.addLong(input.readUInt64());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readUInt64());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ target.add(input.readUInt64());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readInt64List(List<Long> target) throws IOException {
+ if (target instanceof LongArrayList) {
+ LongArrayList plist = (LongArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addLong(input.readInt64());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ plist.addLong(input.readInt64());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readInt64());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ target.add(input.readInt64());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readInt32List(List<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addInt(input.readInt32());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ plist.addInt(input.readInt32());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readInt32());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ target.add(input.readInt32());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readFixed64List(List<Long> target) throws IOException {
+ if (target instanceof LongArrayList) {
+ LongArrayList plist = (LongArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed64Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addLong(input.readFixed64());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED64:
+ while (true) {
+ plist.addLong(input.readFixed64());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed64Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readFixed64());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED64:
+ while (true) {
+ target.add(input.readFixed64());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readFixed32List(List<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed32Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addInt(input.readFixed32());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED32:
+ while (true) {
+ plist.addInt(input.readFixed32());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed32Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readFixed32());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED32:
+ while (true) {
+ target.add(input.readFixed32());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readBoolList(List<Boolean> target) throws IOException {
+ if (target instanceof BooleanArrayList) {
+ BooleanArrayList plist = (BooleanArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addBoolean(input.readBool());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ plist.addBoolean(input.readBool());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readBool());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ target.add(input.readBool());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readStringList(List<String> target) throws IOException {
+ readStringListInternal(target, false);
+ }
+
+ @Override
+ public void readStringListRequireUtf8(List<String> target) throws IOException {
+ readStringListInternal(target, true);
+ }
+
+ public void readStringListInternal(List<String> target, boolean requireUtf8) throws IOException {
+ if (WireFormat.getTagWireType(tag) != WIRETYPE_LENGTH_DELIMITED) {
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+
+ if (target instanceof LazyStringList && !requireUtf8) {
+ LazyStringList lazyList = (LazyStringList) target;
+ while (true) {
+ lazyList.add(readBytes());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ } else {
+ while (true) {
+ target.add(requireUtf8 ? readStringRequireUtf8() : readString());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ }
+ }
+
+ @Override
+ public <T> void readMessageList(
+ List<T> target, Class<T> targetType, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ final Schema<T> schema = Protobuf.getInstance().schemaFor(targetType);
+ readMessageList(target, schema, extensionRegistry);
+ }
+
+ @Override
+ public <T> void readMessageList(
+ List<T> target, Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ if (WireFormat.getTagWireType(tag) != WIRETYPE_LENGTH_DELIMITED) {
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ final int listTag = tag;
+ while (true) {
+ target.add(readMessage(schema, extensionRegistry));
+ if (input.isAtEnd() || nextTag != NEXT_TAG_UNSET) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != listTag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ }
+
+ @Override
+ public <T> void readGroupList(
+ List<T> target, Class<T> targetType, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ final Schema<T> schema = Protobuf.getInstance().schemaFor(targetType);
+ readGroupList(target, schema, extensionRegistry);
+ }
+
+ @Override
+ public <T> void readGroupList(
+ List<T> target, Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ if (WireFormat.getTagWireType(tag) != WIRETYPE_START_GROUP) {
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ final int listTag = tag;
+ while (true) {
+ target.add(readGroup(schema, extensionRegistry));
+ if (input.isAtEnd() || nextTag != NEXT_TAG_UNSET) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != listTag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ }
+
+ @Override
+ public void readBytesList(List<ByteString> target) throws IOException {
+ if (WireFormat.getTagWireType(tag) != WIRETYPE_LENGTH_DELIMITED) {
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+
+ while (true) {
+ target.add(readBytes());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ }
+
+ @Override
+ public void readUInt32List(List<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addInt(input.readUInt32());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ plist.addInt(input.readUInt32());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readUInt32());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ target.add(input.readUInt32());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readEnumList(List<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addInt(input.readEnum());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ plist.addInt(input.readEnum());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readEnum());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ target.add(input.readEnum());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readSFixed32List(List<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed32Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addInt(input.readSFixed32());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED32:
+ while (true) {
+ plist.addInt(input.readSFixed32());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed32Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readSFixed32());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED32:
+ while (true) {
+ target.add(input.readSFixed32());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readSFixed64List(List<Long> target) throws IOException {
+ if (target instanceof LongArrayList) {
+ LongArrayList plist = (LongArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed64Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addLong(input.readSFixed64());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED64:
+ while (true) {
+ plist.addLong(input.readSFixed64());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ verifyPackedFixed64Length(bytes);
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readSFixed64());
+ } while (input.getTotalBytesRead() < endPos);
+ break;
+ case WIRETYPE_FIXED64:
+ while (true) {
+ target.add(input.readSFixed64());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readSInt32List(List<Integer> target) throws IOException {
+ if (target instanceof IntArrayList) {
+ IntArrayList plist = (IntArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addInt(input.readSInt32());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ plist.addInt(input.readSInt32());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readSInt32());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ target.add(input.readSInt32());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ @Override
+ public void readSInt64List(List<Long> target) throws IOException {
+ if (target instanceof LongArrayList) {
+ LongArrayList plist = (LongArrayList) target;
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ plist.addLong(input.readSInt64());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ plist.addLong(input.readSInt64());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ } else {
+ switch (WireFormat.getTagWireType(tag)) {
+ case WIRETYPE_LENGTH_DELIMITED:
+ final int bytes = input.readUInt32();
+ int endPos = input.getTotalBytesRead() + bytes;
+ do {
+ target.add(input.readSInt64());
+ } while (input.getTotalBytesRead() < endPos);
+ requirePosition(endPos);
+ break;
+ case WIRETYPE_VARINT:
+ while (true) {
+ target.add(input.readSInt64());
+ if (input.isAtEnd()) {
+ return;
+ }
+ int nextTag = input.readTag();
+ if (nextTag != tag) {
+ // We've reached the end of the repeated field. Save the next tag value.
+ this.nextTag = nextTag;
+ return;
+ }
+ }
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+ }
+
+ private void verifyPackedFixed64Length(int bytes) throws IOException {
+ if ((bytes & FIXED64_MULTIPLE_MASK) != 0) {
+ // Require that the number of bytes be a multiple of 8.
+ throw InvalidProtocolBufferException.parseFailure();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public <K, V> void readMap(
+ Map<K, V> target,
+ MapEntryLite.Metadata<K, V> metadata,
+ ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ requireWireType(WIRETYPE_LENGTH_DELIMITED);
+ int size = input.readUInt32();
+ final int prevLimit = input.pushLimit(size);
+ K key = metadata.defaultKey;
+ V value = metadata.defaultValue;
+ try {
+ while (true) {
+ int number = getFieldNumber();
+ if (number == READ_DONE || input.isAtEnd()) {
+ break;
+ }
+ try {
+ switch (number) {
+ case 1:
+ key = (K) readField(metadata.keyType, null, null);
+ break;
+ case 2:
+ value =
+ (V)
+ readField(
+ metadata.valueType, metadata.defaultValue.getClass(), extensionRegistry);
+ break;
+ default:
+ if (!skipField()) {
+ throw new InvalidProtocolBufferException("Unable to parse map entry.");
+ }
+ break;
+ }
+ } catch (InvalidProtocolBufferException.InvalidWireTypeException ignore) {
+ // the type doesn't match, skip the field.
+ if (!skipField()) {
+ throw new InvalidProtocolBufferException("Unable to parse map entry.");
+ }
+ }
+ }
+ target.put(key, value);
+ } finally {
+ // Restore the previous limit.
+ input.popLimit(prevLimit);
+ }
+ }
+
+ private Object readField(
+ WireFormat.FieldType fieldType, Class<?> messageType, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ switch (fieldType) {
+ case BOOL:
+ return readBool();
+ case BYTES:
+ return readBytes();
+ case DOUBLE:
+ return readDouble();
+ case ENUM:
+ return readEnum();
+ case FIXED32:
+ return readFixed32();
+ case FIXED64:
+ return readFixed64();
+ case FLOAT:
+ return readFloat();
+ case INT32:
+ return readInt32();
+ case INT64:
+ return readInt64();
+ case MESSAGE:
+ return readMessage(messageType, extensionRegistry);
+ case SFIXED32:
+ return readSFixed32();
+ case SFIXED64:
+ return readSFixed64();
+ case SINT32:
+ return readSInt32();
+ case SINT64:
+ return readSInt64();
+ case STRING:
+ return readStringRequireUtf8();
+ case UINT32:
+ return readUInt32();
+ case UINT64:
+ return readUInt64();
+ default:
+ throw new RuntimeException("unsupported field type.");
+ }
+ }
+
+ private void verifyPackedFixed32Length(int bytes) throws IOException {
+ if ((bytes & FIXED32_MULTIPLE_MASK) != 0) {
+ // Require that the number of bytes be a multiple of 4.
+ throw InvalidProtocolBufferException.parseFailure();
+ }
+ }
+
+ private void requirePosition(int expectedPosition) throws IOException {
+ if (input.getTotalBytesRead() != expectedPosition) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/CodedOutputStream.java b/java/core/src/main/java/com/google/protobuf/CodedOutputStream.java
index 3823f81..a9192d3 100644
--- a/java/core/src/main/java/com/google/protobuf/CodedOutputStream.java
+++ b/java/core/src/main/java/com/google/protobuf/CodedOutputStream.java
@@ -60,6 +60,9 @@
private static final Logger logger = Logger.getLogger(CodedOutputStream.class.getName());
private static final boolean HAS_UNSAFE_ARRAY_OPERATIONS = UnsafeUtil.hasUnsafeArrayOperations();
+ /** Used to adapt to the experimental {@link Writer} interface. */
+ CodedOutputStreamWriter wrapper;
+
/** @deprecated Use {@link #computeFixed32SizeNoTag(int)} instead. */
@Deprecated public static final int LITTLE_ENDIAN_32_SIZE = FIXED32_SIZE;
@@ -361,6 +364,10 @@
public abstract void writeMessage(final int fieldNumber, final MessageLite value)
throws IOException;
+ /** Write an embedded message field, including tag, to the stream. */
+ // Abstract to avoid overhead of additional virtual method calls.
+ abstract void writeMessage(final int fieldNumber, final MessageLite value, Schema schema)
+ throws IOException;
/**
* Write a MessageSet extension field to the stream. For historical reasons, the wire format
@@ -466,6 +473,9 @@
// Abstract to avoid overhead of additional virtual method calls.
public abstract void writeMessageNoTag(final MessageLite value) throws IOException;
+ /** Write an embedded message field to the stream. */
+ // Abstract to avoid overhead of additional virtual method calls.
+ abstract void writeMessageNoTag(final MessageLite value, Schema schema) throws IOException;
// =================================================================
@@ -651,6 +661,14 @@
return computeTagSize(fieldNumber) + computeMessageSizeNoTag(value);
}
+ /**
+ * Compute the number of bytes that would be needed to encode an embedded message field, including
+ * tag.
+ */
+ static int computeMessageSize(
+ final int fieldNumber, final MessageLite value, final Schema schema) {
+ return computeTagSize(fieldNumber) + computeMessageSizeNoTag(value, schema);
+ }
/**
* Compute the number of bytes that would be needed to encode a MessageSet extension to the
@@ -859,6 +877,10 @@
return computeLengthDelimitedFieldSize(value.getSerializedSize());
}
+ /** Compute the number of bytes that would be needed to encode an embedded message field. */
+ static int computeMessageSizeNoTag(final MessageLite value, final Schema schema) {
+ return computeLengthDelimitedFieldSize(((AbstractMessageLite) value).getSerializedSize(schema));
+ }
static int computeLengthDelimitedFieldSize(int fieldLength) {
return computeUInt32SizeNoTag(fieldLength) + fieldLength;
@@ -993,6 +1015,18 @@
writeTag(fieldNumber, WireFormat.WIRETYPE_END_GROUP);
}
+ /**
+ * Write a {@code group} field, including tag, to the stream.
+ *
+ * @deprecated groups are deprecated.
+ */
+ @Deprecated
+ final void writeGroup(final int fieldNumber, final MessageLite value, Schema schema)
+ throws IOException {
+ writeTag(fieldNumber, WireFormat.WIRETYPE_START_GROUP);
+ writeGroupNoTag(value, schema);
+ writeTag(fieldNumber, WireFormat.WIRETYPE_END_GROUP);
+ }
/**
* Write a {@code group} field to the stream.
@@ -1004,6 +1038,15 @@
value.writeTo(this);
}
+ /**
+ * Write a {@code group} field to the stream.
+ *
+ * @deprecated groups are deprecated.
+ */
+ @Deprecated
+ final void writeGroupNoTag(final MessageLite value, Schema schema) throws IOException {
+ schema.writeTo(value, wrapper);
+ }
/**
* Compute the number of bytes that would be needed to encode a {@code group} field, including
@@ -1016,6 +1059,16 @@
return computeTagSize(fieldNumber) * 2 + computeGroupSizeNoTag(value);
}
+ /**
+ * Compute the number of bytes that would be needed to encode a {@code group} field, including
+ * tag.
+ *
+ * @deprecated groups are deprecated.
+ */
+ @Deprecated
+ static int computeGroupSize(final int fieldNumber, final MessageLite value, Schema schema) {
+ return computeTagSize(fieldNumber) * 2 + computeGroupSizeNoTag(value, schema);
+ }
/** Compute the number of bytes that would be needed to encode a {@code group} field. */
@Deprecated
@@ -1023,6 +1076,11 @@
return value.getSerializedSize();
}
+ /** Compute the number of bytes that would be needed to encode a {@code group} field. */
+ @Deprecated
+ static int computeGroupSizeNoTag(final MessageLite value, Schema schema) {
+ return ((AbstractMessageLite) value).getSerializedSize(schema);
+ }
/**
* Encode and write a varint. {@code value} is treated as unsigned, so it won't be sign-extended
@@ -1216,6 +1274,13 @@
writeMessageNoTag(value);
}
+ @Override
+ final void writeMessage(final int fieldNumber, final MessageLite value, Schema schema)
+ throws IOException {
+ writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
+ writeUInt32NoTag(((AbstractMessageLite) value).getSerializedSize(schema));
+ schema.writeTo(value, wrapper);
+ }
@Override
public final void writeMessageSetExtension(final int fieldNumber, final MessageLite value)
@@ -1241,6 +1306,11 @@
value.writeTo(this);
}
+ @Override
+ final void writeMessageNoTag(final MessageLite value, Schema schema) throws IOException {
+ writeUInt32NoTag(((AbstractMessageLite) value).getSerializedSize(schema));
+ schema.writeTo(value, wrapper);
+ }
@Override
public final void write(byte value) throws IOException {
@@ -1571,6 +1641,12 @@
writeMessageNoTag(value);
}
+ @Override
+ void writeMessage(final int fieldNumber, final MessageLite value, Schema schema)
+ throws IOException {
+ writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
+ writeMessageNoTag(value, schema);
+ }
@Override
public void writeMessageSetExtension(final int fieldNumber, final MessageLite value)
@@ -1596,6 +1672,11 @@
value.writeTo(this);
}
+ @Override
+ void writeMessageNoTag(final MessageLite value, Schema schema) throws IOException {
+ writeUInt32NoTag(((AbstractMessageLite) value).getSerializedSize(schema));
+ schema.writeTo(value, wrapper);
+ }
@Override
public void write(byte value) throws IOException {
@@ -1893,6 +1974,11 @@
writeMessageNoTag(value);
}
+ @Override
+ void writeMessage(int fieldNumber, MessageLite value, Schema schema) throws IOException {
+ writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
+ writeMessageNoTag(value, schema);
+ }
@Override
public void writeMessageSetExtension(int fieldNumber, MessageLite value) throws IOException {
@@ -1916,6 +2002,11 @@
value.writeTo(this);
}
+ @Override
+ void writeMessageNoTag(MessageLite value, Schema schema) throws IOException {
+ writeUInt32NoTag(((AbstractMessageLite) value).getSerializedSize(schema));
+ schema.writeTo(value, wrapper);
+ }
@Override
public void write(byte value) throws IOException {
@@ -2419,6 +2510,12 @@
writeMessageNoTag(value);
}
+ @Override
+ void writeMessage(final int fieldNumber, final MessageLite value, Schema schema)
+ throws IOException {
+ writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
+ writeMessageNoTag(value, schema);
+ }
@Override
public void writeMessageSetExtension(final int fieldNumber, final MessageLite value)
@@ -2444,6 +2541,11 @@
value.writeTo(this);
}
+ @Override
+ void writeMessageNoTag(final MessageLite value, Schema schema) throws IOException {
+ writeUInt32NoTag(((AbstractMessageLite) value).getSerializedSize(schema));
+ schema.writeTo(value, wrapper);
+ }
@Override
public void write(byte value) throws IOException {
@@ -2722,6 +2824,12 @@
writeMessageNoTag(value);
}
+ @Override
+ void writeMessage(final int fieldNumber, final MessageLite value, Schema schema)
+ throws IOException {
+ writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
+ writeMessageNoTag(value, schema);
+ }
@Override
public void writeMessageSetExtension(final int fieldNumber, final MessageLite value)
@@ -2747,6 +2855,11 @@
value.writeTo(this);
}
+ @Override
+ void writeMessageNoTag(final MessageLite value, Schema schema) throws IOException {
+ writeUInt32NoTag(((AbstractMessageLite) value).getSerializedSize(schema));
+ schema.writeTo(value, wrapper);
+ }
@Override
public void write(byte value) throws IOException {
diff --git a/java/core/src/main/java/com/google/protobuf/CodedOutputStreamWriter.java b/java/core/src/main/java/com/google/protobuf/CodedOutputStreamWriter.java
new file mode 100755
index 0000000..0d1983c
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/CodedOutputStreamWriter.java
@@ -0,0 +1,691 @@
+// 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 static com.google.protobuf.WireFormat.WIRETYPE_LENGTH_DELIMITED;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+/** An adapter between the {@link Writer} interface and {@link CodedOutputStream}. */
+@ExperimentalApi
+final class CodedOutputStreamWriter implements Writer {
+ private final CodedOutputStream output;
+
+ public static CodedOutputStreamWriter forCodedOutput(CodedOutputStream output) {
+ if (output.wrapper != null) {
+ return output.wrapper;
+ }
+ return new CodedOutputStreamWriter(output);
+ }
+
+ private CodedOutputStreamWriter(CodedOutputStream output) {
+ this.output = checkNotNull(output, "output");
+ this.output.wrapper = this;
+ }
+
+ @Override
+ public FieldOrder fieldOrder() {
+ return FieldOrder.ASCENDING;
+ }
+
+ public int getTotalBytesWritten() {
+ return output.getTotalBytesWritten();
+ }
+
+ @Override
+ public void writeSFixed32(int fieldNumber, int value) throws IOException {
+ output.writeSFixed32(fieldNumber, value);
+ }
+
+ @Override
+ public void writeInt64(int fieldNumber, long value) throws IOException {
+ output.writeInt64(fieldNumber, value);
+ }
+
+ @Override
+ public void writeSFixed64(int fieldNumber, long value) throws IOException {
+ output.writeSFixed64(fieldNumber, value);
+ }
+
+ @Override
+ public void writeFloat(int fieldNumber, float value) throws IOException {
+ output.writeFloat(fieldNumber, value);
+ }
+
+ @Override
+ public void writeDouble(int fieldNumber, double value) throws IOException {
+ output.writeDouble(fieldNumber, value);
+ }
+
+ @Override
+ public void writeEnum(int fieldNumber, int value) throws IOException {
+ output.writeEnum(fieldNumber, value);
+ }
+
+ @Override
+ public void writeUInt64(int fieldNumber, long value) throws IOException {
+ output.writeUInt64(fieldNumber, value);
+ }
+
+ @Override
+ public void writeInt32(int fieldNumber, int value) throws IOException {
+ output.writeInt32(fieldNumber, value);
+ }
+
+ @Override
+ public void writeFixed64(int fieldNumber, long value) throws IOException {
+ output.writeFixed64(fieldNumber, value);
+ }
+
+ @Override
+ public void writeFixed32(int fieldNumber, int value) throws IOException {
+ output.writeFixed32(fieldNumber, value);
+ }
+
+ @Override
+ public void writeBool(int fieldNumber, boolean value) throws IOException {
+ output.writeBool(fieldNumber, value);
+ }
+
+ @Override
+ public void writeString(int fieldNumber, String value) throws IOException {
+ output.writeString(fieldNumber, value);
+ }
+
+ @Override
+ public void writeBytes(int fieldNumber, ByteString value) throws IOException {
+ output.writeBytes(fieldNumber, value);
+ }
+
+ @Override
+ public void writeUInt32(int fieldNumber, int value) throws IOException {
+ output.writeUInt32(fieldNumber, value);
+ }
+
+ @Override
+ public void writeSInt32(int fieldNumber, int value) throws IOException {
+ output.writeSInt32(fieldNumber, value);
+ }
+
+ @Override
+ public void writeSInt64(int fieldNumber, long value) throws IOException {
+ output.writeSInt64(fieldNumber, value);
+ }
+
+ @Override
+ public void writeMessage(int fieldNumber, Object value) throws IOException {
+ output.writeMessage(fieldNumber, (MessageLite) value);
+ }
+
+ @Override
+ public void writeMessage(int fieldNumber, Object value, Schema schema) throws IOException {
+ output.writeMessage(fieldNumber, (MessageLite) value, schema);
+ }
+
+ @Override
+ public void writeGroup(int fieldNumber, Object value) throws IOException {
+ output.writeGroup(fieldNumber, (MessageLite) value);
+ }
+
+ @Override
+ public void writeGroup(int fieldNumber, Object value, Schema schema) throws IOException {
+ output.writeGroup(fieldNumber, (MessageLite) value, schema);
+ }
+
+ @Override
+ public void writeStartGroup(int fieldNumber) throws IOException {
+ output.writeTag(fieldNumber, WireFormat.WIRETYPE_START_GROUP);
+ }
+
+ @Override
+ public void writeEndGroup(int fieldNumber) throws IOException {
+ output.writeTag(fieldNumber, WireFormat.WIRETYPE_END_GROUP);
+ }
+
+ @Override
+ public final void writeMessageSetItem(int fieldNumber, Object value) throws IOException {
+ if (value instanceof ByteString) {
+ output.writeRawMessageSetExtension(fieldNumber, (ByteString) value);
+ } else {
+ output.writeMessageSetExtension(fieldNumber, (MessageLite) value);
+ }
+ }
+
+ @Override
+ public void writeInt32List(int fieldNumber, List<Integer> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeInt32SizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeInt32NoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeInt32(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeFixed32List(int fieldNumber, List<Integer> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeFixed32SizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeFixed32NoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeFixed32(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeInt64List(int fieldNumber, List<Long> value, boolean packed) throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeInt64SizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeInt64NoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeInt64(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeUInt64List(int fieldNumber, List<Long> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeUInt64SizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeUInt64NoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeUInt64(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeFixed64List(int fieldNumber, List<Long> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeFixed64SizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeFixed64NoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeFixed64(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeFloatList(int fieldNumber, List<Float> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeFloatSizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeFloatNoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeFloat(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeDoubleList(int fieldNumber, List<Double> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeDoubleSizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeDoubleNoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeDouble(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeEnumList(int fieldNumber, List<Integer> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeEnumSizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeEnumNoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeEnum(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeBoolList(int fieldNumber, List<Boolean> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeBoolSizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeBoolNoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeBool(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeStringList(int fieldNumber, List<String> value) throws IOException {
+ if (value instanceof LazyStringList) {
+ final LazyStringList lazyList = (LazyStringList) value;
+ for (int i = 0; i < value.size(); ++i) {
+ writeLazyString(fieldNumber, lazyList.getRaw(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeString(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ private void writeLazyString(int fieldNumber, Object value) throws IOException {
+ if (value instanceof String) {
+ output.writeString(fieldNumber, (String) value);
+ } else {
+ output.writeBytes(fieldNumber, (ByteString) value);
+ }
+ }
+
+ @Override
+ public void writeBytesList(int fieldNumber, List<ByteString> value) throws IOException {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeBytes(fieldNumber, value.get(i));
+ }
+ }
+
+ @Override
+ public void writeUInt32List(int fieldNumber, List<Integer> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeUInt32SizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeUInt32NoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeUInt32(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeSFixed32List(int fieldNumber, List<Integer> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeSFixed32SizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeSFixed32NoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeSFixed32(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeSFixed64List(int fieldNumber, List<Long> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeSFixed64SizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeSFixed64NoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeSFixed64(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeSInt32List(int fieldNumber, List<Integer> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeSInt32SizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeSInt32NoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeSInt32(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeSInt64List(int fieldNumber, List<Long> value, boolean packed)
+ throws IOException {
+ if (packed) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+
+ // Compute and write the length of the data.
+ int dataSize = 0;
+ for (int i = 0; i < value.size(); ++i) {
+ dataSize += CodedOutputStream.computeSInt64SizeNoTag(value.get(i));
+ }
+ output.writeUInt32NoTag(dataSize);
+
+ // Write the data itself, without any tags.
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeSInt64NoTag(value.get(i));
+ }
+ } else {
+ for (int i = 0; i < value.size(); ++i) {
+ output.writeSInt64(fieldNumber, value.get(i));
+ }
+ }
+ }
+
+ @Override
+ public void writeMessageList(int fieldNumber, List<?> value) throws IOException {
+ for (int i = 0; i < value.size(); ++i) {
+ writeMessage(fieldNumber, value.get(i));
+ }
+ }
+
+ @Override
+ public void writeMessageList(int fieldNumber, List<?> value, Schema schema) throws IOException {
+ for (int i = 0; i < value.size(); ++i) {
+ writeMessage(fieldNumber, value.get(i), schema);
+ }
+ }
+
+ @Override
+ public void writeGroupList(int fieldNumber, List<?> value) throws IOException {
+ for (int i = 0; i < value.size(); ++i) {
+ writeGroup(fieldNumber, value.get(i));
+ }
+ }
+
+ @Override
+ public void writeGroupList(int fieldNumber, List<?> value, Schema schema) throws IOException {
+ for (int i = 0; i < value.size(); ++i) {
+ writeGroup(fieldNumber, value.get(i), schema);
+ }
+ }
+
+ @Override
+ public <K, V> void writeMap(int fieldNumber, MapEntryLite.Metadata<K, V> metadata, Map<K, V> map)
+ throws IOException {
+ if (output.isSerializationDeterministic()) {
+ writeDeterministicMap(fieldNumber, metadata, map);
+ return;
+ }
+ for (Map.Entry<K, V> entry : map.entrySet()) {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+ output.writeUInt32NoTag(
+ MapEntryLite.computeSerializedSize(metadata, entry.getKey(), entry.getValue()));
+ MapEntryLite.writeTo(output, metadata, entry.getKey(), entry.getValue());
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private <K, V> void writeDeterministicMap(
+ int fieldNumber, MapEntryLite.Metadata<K, V> metadata, Map<K, V> map) throws IOException {
+ switch (metadata.keyType) {
+ case BOOL:
+ V value;
+ if ((value = map.get(Boolean.FALSE)) != null) {
+ writeDeterministicBooleanMapEntry(
+ fieldNumber, /* key= */ false, value, (MapEntryLite.Metadata<Boolean, V>) metadata);
+ }
+ if ((value = map.get(Boolean.TRUE)) != null) {
+ writeDeterministicBooleanMapEntry(
+ fieldNumber, /* key= */ true, value, (MapEntryLite.Metadata<Boolean, V>) metadata);
+ }
+ break;
+ case FIXED32:
+ case INT32:
+ case SFIXED32:
+ case SINT32:
+ case UINT32:
+ writeDeterministicIntegerMap(
+ fieldNumber, (MapEntryLite.Metadata<Integer, V>) metadata, (Map<Integer, V>) map);
+ break;
+ case FIXED64:
+ case INT64:
+ case SFIXED64:
+ case SINT64:
+ case UINT64:
+ writeDeterministicLongMap(
+ fieldNumber, (MapEntryLite.Metadata<Long, V>) metadata, (Map<Long, V>) map);
+ break;
+ case STRING:
+ writeDeterministicStringMap(
+ fieldNumber, (MapEntryLite.Metadata<String, V>) metadata, (Map<String, V>) map);
+ break;
+ default:
+ throw new IllegalArgumentException("does not support key type: " + metadata.keyType);
+ }
+ }
+
+ private <V> void writeDeterministicBooleanMapEntry(
+ int fieldNumber, boolean key, V value, MapEntryLite.Metadata<Boolean, V> metadata)
+ throws IOException {
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+ output.writeUInt32NoTag(MapEntryLite.computeSerializedSize(metadata, key, value));
+ MapEntryLite.writeTo(output, metadata, key, value);
+ }
+
+ private <V> void writeDeterministicIntegerMap(
+ int fieldNumber, MapEntryLite.Metadata<Integer, V> metadata, Map<Integer, V> map)
+ throws IOException {
+ int[] keys = new int[map.size()];
+ int index = 0;
+ for (int k : map.keySet()) {
+ keys[index++] = k;
+ }
+ Arrays.sort(keys);
+ for (int key : keys) {
+ V value = map.get(key);
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+ output.writeUInt32NoTag(MapEntryLite.computeSerializedSize(metadata, key, value));
+ MapEntryLite.writeTo(output, metadata, key, value);
+ }
+ }
+
+ private <V> void writeDeterministicLongMap(
+ int fieldNumber, MapEntryLite.Metadata<Long, V> metadata, Map<Long, V> map)
+ throws IOException {
+ long[] keys = new long[map.size()];
+ int index = 0;
+ for (long k : map.keySet()) {
+ keys[index++] = k;
+ }
+ Arrays.sort(keys);
+ for (long key : keys) {
+ V value = map.get(key);
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+ output.writeUInt32NoTag(MapEntryLite.computeSerializedSize(metadata, key, value));
+ MapEntryLite.writeTo(output, metadata, key, value);
+ }
+ }
+
+ private <V> void writeDeterministicStringMap(
+ int fieldNumber, MapEntryLite.Metadata<String, V> metadata, Map<String, V> map)
+ throws IOException {
+ String[] keys = new String[map.size()];
+ int index = 0;
+ for (String k : map.keySet()) {
+ keys[index++] = k;
+ }
+ Arrays.sort(keys);
+ for (String key : keys) {
+ V value = map.get(key);
+ output.writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED);
+ output.writeUInt32NoTag(MapEntryLite.computeSerializedSize(metadata, key, value));
+ MapEntryLite.writeTo(output, metadata, key, value);
+ }
+ }
+}
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 100755
index 0000000..7975136
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/DescriptorMessageInfoFactory.java
@@ -0,0 +1,690 @@
+// 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.forFieldWithEnumVerifier;
+import static com.google.protobuf.FieldInfo.forMapField;
+import static com.google.protobuf.FieldInfo.forOneofMemberField;
+import static com.google.protobuf.FieldInfo.forPackedField;
+import static com.google.protobuf.FieldInfo.forPackedFieldWithEnumVerifier;
+import static com.google.protobuf.FieldInfo.forProto2OptionalField;
+import static com.google.protobuf.FieldInfo.forProto2RequiredField;
+import static com.google.protobuf.FieldInfo.forRepeatedMessageField;
+
+import com.google.protobuf.Descriptors.Descriptor;
+import com.google.protobuf.Descriptors.FieldDescriptor;
+import com.google.protobuf.Descriptors.FieldDescriptor.Type;
+import com.google.protobuf.Descriptors.OneofDescriptor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Stack;
+import java.util.concurrent.ConcurrentHashMap;
+
+/** A factory for message info based on protobuf descriptors for a {@link GeneratedMessageV3}. */
+@ExperimentalApi
+final class DescriptorMessageInfoFactory implements MessageInfoFactory {
+ private static final String GET_DEFAULT_INSTANCE_METHOD_NAME = "getDefaultInstance";
+ private static final DescriptorMessageInfoFactory instance = new DescriptorMessageInfoFactory();
+ private static final Set<String> specialFieldNames =
+ new HashSet<>(Arrays.asList("cached_size", "serialized_size", "class"));
+
+ // Disallow construction - it's a singleton.
+ private DescriptorMessageInfoFactory() {}
+
+ public static DescriptorMessageInfoFactory getInstance() {
+ return instance;
+ }
+
+ @Override
+ public boolean isSupported(Class<?> messageType) {
+ return GeneratedMessageV3.class.isAssignableFrom(messageType);
+ }
+
+ @Override
+ public MessageInfo messageInfoFor(Class<?> messageType) {
+ if (!GeneratedMessageV3.class.isAssignableFrom(messageType)) {
+ throw new IllegalArgumentException("Unsupported message type: " + messageType.getName());
+ }
+
+ return convert(messageType, descriptorForType(messageType));
+ }
+
+ private static Message getDefaultInstance(Class<?> messageType) {
+ try {
+ Method method = messageType.getDeclaredMethod(GET_DEFAULT_INSTANCE_METHOD_NAME);
+ return (Message) method.invoke(null);
+ } catch (Exception e) {
+ throw new IllegalArgumentException(
+ "Unable to get default instance for message class " + messageType.getName(), e);
+ }
+ }
+
+ private static Descriptor descriptorForType(Class<?> messageType) {
+ return getDefaultInstance(messageType).getDescriptorForType();
+ }
+
+ private static MessageInfo convert(Class<?> messageType, Descriptor messageDescriptor) {
+ switch (messageDescriptor.getFile().getSyntax()) {
+ case PROTO2:
+ return convertProto2(messageType, messageDescriptor);
+ case PROTO3:
+ return convertProto3(messageType, messageDescriptor);
+ default:
+ throw new IllegalArgumentException(
+ "Unsupported syntax: " + messageDescriptor.getFile().getSyntax());
+ }
+ }
+
+ /**
+ * A helper class to determine whether a message type needs to implement {@code isInitialized()}.
+ *
+ * <p>If a message type doesn't have any required fields or extensions (directly and
+ * transitively), it doesn't need to implement isInitialized() and can always return true there.
+ * It's a bit tricky to determine whether a type has transitive required fields because protobuf
+ * allows cycle references within the same .proto file (e.g., message Foo has a Bar field, and
+ * message Bar has a Foo field). For that we use Tarjan's strongly connected components algorithm
+ * to classify messages into strongly connected groups. Messages in the same group are
+ * transitively including each other, so they should either all have transitive required fields
+ * (or extensions), or none have.
+ *
+ * <p>This class is thread-safe.
+ */
+ static class IsInitializedCheckAnalyzer {
+
+ private final Map<Descriptor, Boolean> resultCache =
+ new ConcurrentHashMap<Descriptor, Boolean>();
+
+ // The following data members are part of Tarjan's SCC algorithm. See:
+ // https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+ private int index = 0;
+ private final Stack<Node> stack = new Stack<Node>();
+ private final Map<Descriptor, Node> nodeCache = new HashMap<Descriptor, Node>();
+
+ public boolean needsIsInitializedCheck(Descriptor descriptor) {
+ Boolean cachedValue = resultCache.get(descriptor);
+ if (cachedValue != null) {
+ return cachedValue;
+ }
+ synchronized (this) {
+ // Double-check the cache because some other thread may have updated it while we
+ // were acquiring the lock.
+ cachedValue = resultCache.get(descriptor);
+ if (cachedValue != null) {
+ return cachedValue;
+ }
+ return dfs(descriptor).component.needsIsInitializedCheck;
+ }
+ }
+
+ private static class Node {
+ final Descriptor descriptor;
+ final int index;
+ int lowLink;
+ StronglyConnectedComponent component; // null if the node is still on stack.
+
+ Node(Descriptor descriptor, int index) {
+ this.descriptor = descriptor;
+ this.index = index;
+ this.lowLink = index;
+ this.component = null;
+ }
+ }
+
+ private static class StronglyConnectedComponent {
+ final List<Descriptor> messages = new ArrayList<Descriptor>();
+ boolean needsIsInitializedCheck = false;
+ }
+
+ private Node dfs(Descriptor descriptor) {
+ Node result = new Node(descriptor, index++);
+ stack.push(result);
+ nodeCache.put(descriptor, result);
+
+ // Recurse the fields / nodes in graph
+ for (FieldDescriptor field : descriptor.getFields()) {
+ if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
+ Node child = nodeCache.get(field.getMessageType());
+ if (child == null) {
+ // Unexplored node
+ child = dfs(field.getMessageType());
+ result.lowLink = Math.min(result.lowLink, child.lowLink);
+ } else {
+ if (child.component == null) {
+ // Still in the stack so we found a back edge.
+ result.lowLink = Math.min(result.lowLink, child.lowLink);
+ }
+ }
+ }
+ }
+
+ if (result.index == result.lowLink) {
+ // This is the root of a strongly connected component.
+ StronglyConnectedComponent component = new StronglyConnectedComponent();
+ while (true) {
+ Node node = stack.pop();
+ node.component = component;
+ component.messages.add(node.descriptor);
+ if (node == result) {
+ break;
+ }
+ }
+
+ analyze(component);
+ }
+
+ return result;
+ }
+
+ // Determine whether messages in this SCC needs isInitialized check.
+ private void analyze(StronglyConnectedComponent component) {
+ boolean needsIsInitializedCheck = false;
+ loop:
+ for (Descriptor descriptor : component.messages) {
+ if (descriptor.isExtendable()) {
+ needsIsInitializedCheck = true;
+ break;
+ }
+
+ for (FieldDescriptor field : descriptor.getFields()) {
+ if (field.isRequired()) {
+ needsIsInitializedCheck = true;
+ break loop;
+ }
+
+ if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
+ // Since we are analyzing the graph bottom-up, all referenced fields should either be
+ // in this same component or in a different already-analyzed component.
+ Node node = nodeCache.get(field.getMessageType());
+ if (node.component != component) {
+ if (node.component.needsIsInitializedCheck) {
+ needsIsInitializedCheck = true;
+ break loop;
+ }
+ }
+ }
+ }
+ }
+
+ component.needsIsInitializedCheck = needsIsInitializedCheck;
+
+ for (Descriptor descriptor : component.messages) {
+ resultCache.put(descriptor, component.needsIsInitializedCheck);
+ }
+ }
+ }
+
+ private static IsInitializedCheckAnalyzer isInitializedCheckAnalyzer =
+ new IsInitializedCheckAnalyzer();
+
+ private static boolean needsIsInitializedCheck(Descriptor descriptor) {
+ return isInitializedCheckAnalyzer.needsIsInitializedCheck(descriptor);
+ }
+
+ private static StructuralMessageInfo convertProto2(
+ Class<?> messageType, Descriptor messageDescriptor) {
+ List<FieldDescriptor> fieldDescriptors = messageDescriptor.getFields();
+ StructuralMessageInfo.Builder builder =
+ StructuralMessageInfo.newBuilder(fieldDescriptors.size());
+ builder.withDefaultInstance(getDefaultInstance(messageType));
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ builder.withMessageSetWireFormat(messageDescriptor.getOptions().getMessageSetWireFormat());
+
+ OneofState oneofState = new OneofState();
+ int bitFieldIndex = 0;
+ int presenceMask = 1;
+ Field bitField = null;
+
+ // 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) {
+ final FieldDescriptor fd = fieldDescriptors.get(i);
+ boolean enforceUtf8 = fd.getFile().getOptions().getJavaStringCheckUtf8();
+ Internal.EnumVerifier enumVerifier = null;
+ if (fd.getJavaType() == Descriptors.FieldDescriptor.JavaType.ENUM) {
+ enumVerifier =
+ new Internal.EnumVerifier() {
+ @Override
+ public boolean isInRange(int number) {
+ return fd.getEnumType().findValueByNumber(number) != null;
+ }
+ };
+ }
+ if (fd.getContainingOneof() != null) {
+ // Build a oneof member field.
+ builder.withField(buildOneofMember(messageType, fd, oneofState, enforceUtf8, enumVerifier));
+ } else {
+ Field field = field(messageType, fd);
+ int number = fd.getNumber();
+ FieldType type = getFieldType(fd);
+
+ if (fd.isMapField()) {
+ // Map field points to an auto-generated message entry type with the definition:
+ // message MapEntry {
+ // K key = 1;
+ // V value = 2;
+ // }
+ final FieldDescriptor valueField = fd.getMessageType().findFieldByNumber(2);
+ if (valueField.getJavaType() == Descriptors.FieldDescriptor.JavaType.ENUM) {
+ enumVerifier =
+ new Internal.EnumVerifier() {
+ @Override
+ public boolean isInRange(int number) {
+ return valueField.getEnumType().findValueByNumber(number) != null;
+ }
+ };
+ }
+ builder.withField(
+ forMapField(
+ field,
+ number,
+ SchemaUtil.getMapDefaultEntry(messageType, fd.getName()),
+ enumVerifier));
+ continue;
+ }
+
+ if (fd.isRepeated()) {
+ // Repeated fields are not presence-checked.
+ if (enumVerifier != null) {
+ if (fd.isPacked()) {
+ builder.withField(
+ forPackedFieldWithEnumVerifier(
+ field, number, type, enumVerifier, cachedSizeField(messageType, fd)));
+ } else {
+ builder.withField(forFieldWithEnumVerifier(field, number, type, enumVerifier));
+ }
+ } else if (fd.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
+ builder.withField(
+ forRepeatedMessageField(
+ field, number, type, getTypeForRepeatedMessageField(messageType, fd)));
+ } else {
+ if (fd.isPacked()) {
+ builder.withField(
+ forPackedField(field, number, type, cachedSizeField(messageType, fd)));
+ } else {
+ builder.withField(forField(field, number, type, enforceUtf8));
+ }
+ }
+ continue;
+ }
+
+ if (bitField == null) {
+ // Lazy-create the next bitfield since we know it must exist.
+ bitField = bitField(messageType, bitFieldIndex);
+ }
+
+ // It's a presence-checked field.
+ if (fd.isRequired()) {
+ builder.withField(
+ forProto2RequiredField(
+ field, number, type, bitField, presenceMask, enforceUtf8, enumVerifier));
+ } else {
+ builder.withField(
+ forProto2OptionalField(
+ field, number, type, bitField, presenceMask, enforceUtf8, enumVerifier));
+ }
+ }
+
+ // Update the presence mask for the next iteration. If the shift clears out the mask, we will
+ // go to the next bitField.
+ presenceMask <<= 1;
+ if (presenceMask == 0) {
+ bitField = null;
+ presenceMask = 1;
+ bitFieldIndex++;
+ }
+ }
+
+ List<Integer> fieldsToCheckIsInitialized = new ArrayList<Integer>();
+ for (int i = 0; i < fieldDescriptors.size(); ++i) {
+ FieldDescriptor fd = fieldDescriptors.get(i);
+ if (fd.isRequired()
+ || (fd.getJavaType() == FieldDescriptor.JavaType.MESSAGE
+ && needsIsInitializedCheck(fd.getMessageType()))) {
+ fieldsToCheckIsInitialized.add(fd.getNumber());
+ }
+ }
+ int[] numbers = new int[fieldsToCheckIsInitialized.size()];
+ for (int i = 0; i < fieldsToCheckIsInitialized.size(); i++) {
+ numbers[i] = fieldsToCheckIsInitialized.get(i);
+ }
+ builder.withCheckInitialized(numbers);
+
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo convertProto3(
+ Class<?> messageType, Descriptor messageDescriptor) {
+ List<FieldDescriptor> fieldDescriptors = messageDescriptor.getFields();
+ StructuralMessageInfo.Builder builder =
+ StructuralMessageInfo.newBuilder(fieldDescriptors.size());
+ builder.withDefaultInstance(getDefaultInstance(messageType));
+ builder.withSyntax(ProtoSyntax.PROTO3);
+
+ OneofState oneofState = new OneofState();
+ boolean enforceUtf8 = true;
+ for (int i = 0; i < fieldDescriptors.size(); ++i) {
+ FieldDescriptor fd = fieldDescriptors.get(i);
+ if (fd.getContainingOneof() != null) {
+ // Build a oneof member field.
+ builder.withField(buildOneofMember(messageType, fd, oneofState, enforceUtf8, null));
+ continue;
+ }
+ if (fd.isMapField()) {
+ builder.withField(
+ forMapField(
+ field(messageType, fd),
+ fd.getNumber(),
+ SchemaUtil.getMapDefaultEntry(messageType, fd.getName()),
+ null));
+ continue;
+ }
+ if (fd.isRepeated() && fd.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
+ builder.withField(
+ forRepeatedMessageField(
+ field(messageType, fd),
+ fd.getNumber(),
+ getFieldType(fd),
+ getTypeForRepeatedMessageField(messageType, fd)));
+ continue;
+ }
+ if (fd.isPacked()) {
+ builder.withField(
+ forPackedField(
+ field(messageType, fd),
+ fd.getNumber(),
+ getFieldType(fd),
+ cachedSizeField(messageType, fd)));
+ } else {
+ builder.withField(
+ forField(field(messageType, fd), fd.getNumber(), getFieldType(fd), enforceUtf8));
+ }
+ }
+
+ return builder.build();
+ }
+
+ /** Builds info for a oneof member field. */
+ private static FieldInfo buildOneofMember(
+ Class<?> messageType,
+ FieldDescriptor fd,
+ OneofState oneofState,
+ boolean enforceUtf8,
+ Internal.EnumVerifier enumVerifier) {
+ OneofInfo oneof = oneofState.getOneof(messageType, fd.getContainingOneof());
+ FieldType type = getFieldType(fd);
+ Class<?> oneofStoredType = getOneofStoredType(messageType, fd, type);
+ return forOneofMemberField(
+ fd.getNumber(), type, oneof, oneofStoredType, enforceUtf8, enumVerifier);
+ }
+
+ private static Class<?> getOneofStoredType(
+ Class<?> messageType, FieldDescriptor fd, FieldType type) {
+ switch (type.getJavaType()) {
+ case BOOLEAN:
+ return Boolean.class;
+ case BYTE_STRING:
+ return ByteString.class;
+ case DOUBLE:
+ return Double.class;
+ case FLOAT:
+ return Float.class;
+ case ENUM:
+ case INT:
+ return Integer.class;
+ case LONG:
+ return Long.class;
+ case STRING:
+ return String.class;
+ case MESSAGE:
+ return getOneofStoredTypeForMessage(messageType, fd);
+ default:
+ throw new IllegalArgumentException("Invalid type for oneof: " + type);
+ }
+ }
+
+ 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:
+ if (fd.isMapField()) {
+ return FieldType.MAP;
+ }
+ 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 cachedSizeField(Class<?> messageType, FieldDescriptor fd) {
+ return field(messageType, getCachedSizeFieldName(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());
+ }
+ }
+
+ static String getFieldName(FieldDescriptor fd) {
+ String name = (fd.getType() == FieldDescriptor.Type.GROUP)
+ ? fd.getMessageType().getName()
+ : fd.getName();
+ String suffix = specialFieldNames.contains(name) ? "__" : "_";
+ return snakeCaseToCamelCase(name) + suffix;
+ }
+
+ private static String getCachedSizeFieldName(FieldDescriptor fd) {
+ return snakeCaseToCamelCase(fd.getName()) + "MemoizedSerializedSize";
+ }
+
+ /**
+ * 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 snakeCaseToCamelCase(String snakeCase) {
+ 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 (Character.isDigit(next)) {
+ sb.append(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);
+ }
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Inspects the message to identify the stored type for a message field that is part of a oneof.
+ */
+ private static Class<?> getOneofStoredTypeForMessage(Class<?> messageType, FieldDescriptor fd) {
+ try {
+ String name = fd.getType() == Type.GROUP ? fd.getMessageType().getName() : fd.getName();
+ Method getter = messageType.getDeclaredMethod(getterForField(name));
+ return getter.getReturnType();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /** Inspects the message to identify the message type of a repeated message field. */
+ private static Class<?> getTypeForRepeatedMessageField(Class<?> messageType, FieldDescriptor fd) {
+ try {
+ String name = fd.getType() == Type.GROUP ? fd.getMessageType().getName() : fd.getName();
+ Method getter = messageType.getDeclaredMethod(getterForField(name), int.class);
+ return getter.getReturnType();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /** Constructs the name of the get method for the given field in the proto. */
+ private static String getterForField(String snakeCase) {
+ String camelCase = snakeCaseToCamelCase(snakeCase);
+ StringBuilder builder = new StringBuilder("get");
+ // Capitalize the first character in the field name.
+ builder.append(Character.toUpperCase(camelCase.charAt(0)));
+ builder.append(camelCase.substring(1, camelCase.length()));
+ return builder.toString();
+ }
+
+ private static final class OneofState {
+ private OneofInfo[] oneofs = new OneofInfo[2];
+
+ OneofInfo getOneof(Class<?> messageType, OneofDescriptor desc) {
+ int index = desc.getIndex();
+ if (index >= oneofs.length) {
+ // Grow the array.
+ oneofs = Arrays.copyOf(oneofs, index * 2);
+ }
+ OneofInfo info = oneofs[index];
+ if (info == null) {
+ info = newInfo(messageType, desc);
+ oneofs[index] = info;
+ }
+ return info;
+ }
+
+ private static OneofInfo newInfo(Class<?> messageType, OneofDescriptor desc) {
+ String camelCase = snakeCaseToCamelCase(desc.getName());
+ String valueFieldName = camelCase + "_";
+ String caseFieldName = camelCase + "Case_";
+
+ return new OneofInfo(
+ desc.getIndex(), field(messageType, caseFieldName), field(messageType, valueFieldName));
+ }
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/ExtensionRegistryLite.java b/java/core/src/main/java/com/google/protobuf/ExtensionRegistryLite.java
index 0ce5f54..11843b6 100644
--- a/java/core/src/main/java/com/google/protobuf/ExtensionRegistryLite.java
+++ b/java/core/src/main/java/com/google/protobuf/ExtensionRegistryLite.java
@@ -110,12 +110,23 @@
return ExtensionRegistryFactory.create();
}
+ private static volatile ExtensionRegistryLite emptyRegistry;
+
/**
* Get the unmodifiable singleton empty instance of either ExtensionRegistryLite or {@code
* ExtensionRegistry} (if the full (non-Lite) proto libraries are available).
*/
public static ExtensionRegistryLite getEmptyRegistry() {
- return ExtensionRegistryFactory.createEmpty();
+ ExtensionRegistryLite result = emptyRegistry;
+ if (result == null) {
+ synchronized (ExtensionRegistryLite.class) {
+ result = emptyRegistry;
+ if (result == null) {
+ result = emptyRegistry = ExtensionRegistryFactory.createEmpty();
+ }
+ }
+ }
+ return result;
}
diff --git a/java/core/src/main/java/com/google/protobuf/ExtensionSchema.java b/java/core/src/main/java/com/google/protobuf/ExtensionSchema.java
new file mode 100755
index 0000000..2eae22d
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/ExtensionSchema.java
@@ -0,0 +1,98 @@
+// 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.Map;
+
+abstract class ExtensionSchema<T extends FieldSet.FieldDescriptorLite<T>> {
+
+ /** Returns true for messages that support extensions. */
+ abstract boolean hasExtensions(MessageLite prototype);
+
+ /** Returns the extension {@link FieldSet} for the message instance. */
+ abstract FieldSet<T> getExtensions(Object message);
+
+ /** Replaces the extension {@link FieldSet} for the message instance. */
+ abstract void setExtensions(Object message, FieldSet<T> extensions);
+
+ /** Returns the extension {@link FieldSet} and ensures it's mutable. */
+ abstract FieldSet<T> getMutableExtensions(Object message);
+
+ /** Marks the extension {@link FieldSet} as immutable. */
+ abstract void makeImmutable(Object message);
+
+ /**
+ * Parses an extension. Returns the passed-in unknownFields parameter if no unknown enum value is
+ * found or a modified unknownFields (a new instance if the passed-in unknownFields is null)
+ * containing unknown enum values found while parsing.
+ *
+ * @param <UT> The type used to store unknown fields. It's either UnknownFieldSet in full runtime
+ * or UnknownFieldSetLite in lite runtime.
+ */
+ abstract <UT, UB> UB parseExtension(
+ Reader reader,
+ Object extension,
+ ExtensionRegistryLite extensionRegistry,
+ FieldSet<T> extensions,
+ UB unknownFields,
+ UnknownFieldSchema<UT, UB> unknownFieldSchema)
+ throws IOException;
+
+ /** Gets the field number of an extension entry. */
+ abstract int extensionNumber(Map.Entry<?, ?> extension);
+
+ /** Serializes one extension entry. */
+ abstract void serializeExtension(Writer writer, Map.Entry<?, ?> extension) throws IOException;
+
+ /** Finds an extension by field number. */
+ abstract Object findExtensionByNumber(
+ ExtensionRegistryLite extensionRegistry, MessageLite defaultInstance, int number);
+
+ /** Parses a length-prefixed MessageSet item from the reader. */
+ abstract void parseLengthPrefixedMessageSetItem(
+ Reader reader,
+ Object extension,
+ ExtensionRegistryLite extensionRegistry,
+ FieldSet<T> extensions)
+ throws IOException;
+
+ /**
+ * Parses the entire content of a {@link ByteString} as one MessageSet item. Unlike {@link
+ * #parseLengthPrefixedMessageSetItem}, there isn't a length-prefix.
+ */
+ abstract void parseMessageSetItem(
+ ByteString data,
+ Object extension,
+ ExtensionRegistryLite extensionRegistry,
+ FieldSet<T> extensions)
+ throws IOException;
+}
diff --git a/java/core/src/main/java/com/google/protobuf/ExtensionSchemaFull.java b/java/core/src/main/java/com/google/protobuf/ExtensionSchemaFull.java
new file mode 100755
index 0000000..9055851
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/ExtensionSchemaFull.java
@@ -0,0 +1,547 @@
+// 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.Descriptors.EnumValueDescriptor;
+import com.google.protobuf.Descriptors.FieldDescriptor;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@SuppressWarnings("unchecked")
+final class ExtensionSchemaFull extends ExtensionSchema<FieldDescriptor> {
+
+ private static final long EXTENSION_FIELD_OFFSET = getExtensionsFieldOffset();
+
+ private static <T> long getExtensionsFieldOffset() {
+ try {
+ Field field = GeneratedMessageV3.ExtendableMessage.class.getDeclaredField("extensions");
+ return UnsafeUtil.objectFieldOffset(field);
+ } catch (Throwable e) {
+ throw new IllegalStateException("Unable to lookup extension field offset");
+ }
+ }
+
+ @Override
+ boolean hasExtensions(MessageLite prototype) {
+ return prototype instanceof GeneratedMessageV3.ExtendableMessage;
+ }
+
+ @Override
+ public FieldSet<FieldDescriptor> getExtensions(Object message) {
+ return (FieldSet<FieldDescriptor>) UnsafeUtil.getObject(message, EXTENSION_FIELD_OFFSET);
+ }
+
+ @Override
+ void setExtensions(Object message, FieldSet<FieldDescriptor> extensions) {
+ UnsafeUtil.putObject(message, EXTENSION_FIELD_OFFSET, extensions);
+ }
+
+ @Override
+ FieldSet<FieldDescriptor> getMutableExtensions(Object message) {
+ FieldSet<FieldDescriptor> extensions = getExtensions(message);
+ if (extensions.isImmutable()) {
+ extensions = extensions.clone();
+ setExtensions(message, extensions);
+ }
+ return extensions;
+ }
+
+ @Override
+ void makeImmutable(Object message) {
+ getExtensions(message).makeImmutable();
+ }
+
+ @Override
+ <UT, UB> UB parseExtension(
+ Reader reader,
+ Object extensionObject,
+ ExtensionRegistryLite extensionRegistry,
+ FieldSet<FieldDescriptor> extensions,
+ UB unknownFields,
+ UnknownFieldSchema<UT, UB> unknownFieldSchema)
+ throws IOException {
+ ExtensionRegistry.ExtensionInfo extension = (ExtensionRegistry.ExtensionInfo) extensionObject;
+ int fieldNumber = extension.descriptor.getNumber();
+
+ if (extension.descriptor.isRepeated() && extension.descriptor.isPacked()) {
+ Object value = null;
+ switch (extension.descriptor.getLiteType()) {
+ case DOUBLE:
+ {
+ List<Double> list = new ArrayList<Double>();
+ reader.readDoubleList(list);
+ value = list;
+ break;
+ }
+ case FLOAT:
+ {
+ List<Float> list = new ArrayList<Float>();
+ reader.readFloatList(list);
+ value = list;
+ break;
+ }
+ case INT64:
+ {
+ List<Long> list = new ArrayList<Long>();
+ reader.readInt64List(list);
+ value = list;
+ break;
+ }
+ case UINT64:
+ {
+ List<Long> list = new ArrayList<Long>();
+ reader.readUInt64List(list);
+ value = list;
+ break;
+ }
+ case INT32:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readInt32List(list);
+ value = list;
+ break;
+ }
+ case FIXED64:
+ {
+ List<Long> list = new ArrayList<Long>();
+ reader.readFixed64List(list);
+ value = list;
+ break;
+ }
+ case FIXED32:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readFixed32List(list);
+ value = list;
+ break;
+ }
+ case BOOL:
+ {
+ List<Boolean> list = new ArrayList<Boolean>();
+ reader.readBoolList(list);
+ value = list;
+ break;
+ }
+ case UINT32:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readUInt32List(list);
+ value = list;
+ break;
+ }
+ case SFIXED32:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readSFixed32List(list);
+ value = list;
+ break;
+ }
+ case SFIXED64:
+ {
+ List<Long> list = new ArrayList<Long>();
+ reader.readSFixed64List(list);
+ value = list;
+ break;
+ }
+ case SINT32:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readSInt32List(list);
+ value = list;
+ break;
+ }
+ case SINT64:
+ {
+ List<Long> list = new ArrayList<Long>();
+ reader.readSInt64List(list);
+ value = list;
+ break;
+ }
+ case ENUM:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readEnumList(list);
+ List<EnumValueDescriptor> enumList = new ArrayList<EnumValueDescriptor>();
+ for (int number : list) {
+ EnumValueDescriptor enumDescriptor =
+ extension.descriptor.getEnumType().findValueByNumber(number);
+ if (enumDescriptor != null) {
+ enumList.add(enumDescriptor);
+ } else {
+ unknownFields =
+ SchemaUtil.storeUnknownEnum(
+ fieldNumber, number, unknownFields, unknownFieldSchema);
+ }
+ }
+ value = enumList;
+ break;
+ }
+ default:
+ throw new IllegalStateException(
+ "Type cannot be packed: " + extension.descriptor.getLiteType());
+ }
+ extensions.setField(extension.descriptor, value);
+ } else {
+ Object value = null;
+ // Enum is a special case because unknown enum values will be put into UnknownFieldSetLite.
+ if (extension.descriptor.getLiteType() == WireFormat.FieldType.ENUM) {
+ int number = reader.readInt32();
+ Object enumValue = extension.descriptor.getEnumType().findValueByNumber(number);
+ if (enumValue == null) {
+ return SchemaUtil.storeUnknownEnum(
+ fieldNumber, number, unknownFields, unknownFieldSchema);
+ }
+ value = enumValue;
+ } else {
+ switch (extension.descriptor.getLiteType()) {
+ case DOUBLE:
+ value = reader.readDouble();
+ break;
+ case FLOAT:
+ value = reader.readFloat();
+ break;
+ case INT64:
+ value = reader.readInt64();
+ break;
+ case UINT64:
+ value = reader.readUInt64();
+ break;
+ case INT32:
+ value = reader.readInt32();
+ break;
+ case FIXED64:
+ value = reader.readFixed64();
+ break;
+ case FIXED32:
+ value = reader.readFixed32();
+ break;
+ case BOOL:
+ value = reader.readBool();
+ break;
+ case BYTES:
+ value = reader.readBytes();
+ break;
+ case UINT32:
+ value = reader.readUInt32();
+ break;
+ case SFIXED32:
+ value = reader.readSFixed32();
+ break;
+ case SFIXED64:
+ value = reader.readSFixed64();
+ break;
+ case SINT32:
+ value = reader.readSInt32();
+ break;
+ case SINT64:
+ value = reader.readSInt64();
+ break;
+
+ case STRING:
+ value = reader.readString();
+ break;
+ case GROUP:
+ value = reader.readGroup(extension.defaultInstance.getClass(), extensionRegistry);
+ break;
+
+ case MESSAGE:
+ value = reader.readMessage(extension.defaultInstance.getClass(), extensionRegistry);
+ break;
+
+ case ENUM:
+ throw new IllegalStateException("Shouldn't reach here.");
+ }
+ }
+ if (extension.descriptor.isRepeated()) {
+ extensions.addRepeatedField(extension.descriptor, value);
+ } else {
+ switch (extension.descriptor.getLiteType()) {
+ case MESSAGE:
+ case GROUP:
+ Object oldValue = extensions.getField(extension.descriptor);
+ if (oldValue != null) {
+ value = Internal.mergeMessage(oldValue, value);
+ }
+ break;
+ default:
+ break;
+ }
+ extensions.setField(extension.descriptor, value);
+ }
+ }
+ return unknownFields;
+ }
+
+ @Override
+ int extensionNumber(Map.Entry<?, ?> extension) {
+ FieldDescriptor descriptor = (FieldDescriptor) extension.getKey();
+ return descriptor.getNumber();
+ }
+
+ @Override
+ void serializeExtension(Writer writer, Map.Entry<?, ?> extension) throws IOException {
+ FieldDescriptor descriptor = (FieldDescriptor) extension.getKey();
+ if (descriptor.isRepeated()) {
+ switch (descriptor.getLiteType()) {
+ case DOUBLE:
+ SchemaUtil.writeDoubleList(
+ descriptor.getNumber(),
+ (List<Double>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case FLOAT:
+ SchemaUtil.writeFloatList(
+ descriptor.getNumber(),
+ (List<Float>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case INT64:
+ SchemaUtil.writeInt64List(
+ descriptor.getNumber(),
+ (List<Long>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case UINT64:
+ SchemaUtil.writeUInt64List(
+ descriptor.getNumber(),
+ (List<Long>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case INT32:
+ SchemaUtil.writeInt32List(
+ descriptor.getNumber(),
+ (List<Integer>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case FIXED64:
+ SchemaUtil.writeFixed64List(
+ descriptor.getNumber(),
+ (List<Long>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case FIXED32:
+ SchemaUtil.writeFixed32List(
+ descriptor.getNumber(),
+ (List<Integer>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case BOOL:
+ SchemaUtil.writeBoolList(
+ descriptor.getNumber(),
+ (List<Boolean>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case BYTES:
+ SchemaUtil.writeBytesList(
+ descriptor.getNumber(), (List<ByteString>) extension.getValue(), writer);
+ break;
+ case UINT32:
+ SchemaUtil.writeUInt32List(
+ descriptor.getNumber(),
+ (List<Integer>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case SFIXED32:
+ SchemaUtil.writeSFixed32List(
+ descriptor.getNumber(),
+ (List<Integer>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case SFIXED64:
+ SchemaUtil.writeSFixed64List(
+ descriptor.getNumber(),
+ (List<Long>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case SINT32:
+ SchemaUtil.writeSInt32List(
+ descriptor.getNumber(),
+ (List<Integer>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case SINT64:
+ SchemaUtil.writeSInt64List(
+ descriptor.getNumber(),
+ (List<Long>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case ENUM:
+ {
+ List<EnumValueDescriptor> enumList = (List<EnumValueDescriptor>) extension.getValue();
+ List<Integer> list = new ArrayList<Integer>();
+ for (EnumValueDescriptor d : enumList) {
+ list.add(d.getNumber());
+ }
+ SchemaUtil.writeInt32List(descriptor.getNumber(), list, writer, descriptor.isPacked());
+ break;
+ }
+ case STRING:
+ SchemaUtil.writeStringList(
+ descriptor.getNumber(), (List<String>) extension.getValue(), writer);
+ break;
+ case GROUP:
+ SchemaUtil.writeGroupList(descriptor.getNumber(), (List<?>) extension.getValue(), writer);
+ break;
+ case MESSAGE:
+ SchemaUtil.writeMessageList(
+ descriptor.getNumber(), (List<?>) extension.getValue(), writer);
+ break;
+ }
+ } else {
+ switch (descriptor.getLiteType()) {
+ case DOUBLE:
+ writer.writeDouble(descriptor.getNumber(), (Double) extension.getValue());
+ break;
+ case FLOAT:
+ writer.writeFloat(descriptor.getNumber(), (Float) extension.getValue());
+ break;
+ case INT64:
+ writer.writeInt64(descriptor.getNumber(), (Long) extension.getValue());
+ break;
+ case UINT64:
+ writer.writeUInt64(descriptor.getNumber(), (Long) extension.getValue());
+ break;
+ case INT32:
+ writer.writeInt32(descriptor.getNumber(), (Integer) extension.getValue());
+ break;
+ case FIXED64:
+ writer.writeFixed64(descriptor.getNumber(), (Long) extension.getValue());
+ break;
+ case FIXED32:
+ writer.writeFixed32(descriptor.getNumber(), (Integer) extension.getValue());
+ break;
+ case BOOL:
+ writer.writeBool(descriptor.getNumber(), (Boolean) extension.getValue());
+ break;
+ case BYTES:
+ writer.writeBytes(descriptor.getNumber(), (ByteString) extension.getValue());
+ break;
+ case UINT32:
+ writer.writeUInt32(descriptor.getNumber(), (Integer) extension.getValue());
+ break;
+ case SFIXED32:
+ writer.writeSFixed32(descriptor.getNumber(), (Integer) extension.getValue());
+ break;
+ case SFIXED64:
+ writer.writeSFixed64(descriptor.getNumber(), (Long) extension.getValue());
+ break;
+ case SINT32:
+ writer.writeSInt32(descriptor.getNumber(), (Integer) extension.getValue());
+ break;
+ case SINT64:
+ writer.writeSInt64(descriptor.getNumber(), (Long) extension.getValue());
+ break;
+ case ENUM:
+ writer.writeInt32(
+ descriptor.getNumber(), ((EnumValueDescriptor) extension.getValue()).getNumber());
+ break;
+ case STRING:
+ writer.writeString(descriptor.getNumber(), (String) extension.getValue());
+ break;
+ case GROUP:
+ writer.writeGroup(descriptor.getNumber(), extension.getValue());
+ break;
+ case MESSAGE:
+ writer.writeMessage(descriptor.getNumber(), extension.getValue());
+ break;
+ }
+ }
+ }
+
+ @Override
+ Object findExtensionByNumber(
+ ExtensionRegistryLite extensionRegistry, MessageLite defaultInstance, int number) {
+ return ((ExtensionRegistry) extensionRegistry)
+ .findExtensionByNumber(((Message) defaultInstance).getDescriptorForType(), number);
+ }
+
+ @Override
+ void parseLengthPrefixedMessageSetItem(
+ Reader reader,
+ Object extension,
+ ExtensionRegistryLite extensionRegistry,
+ FieldSet<FieldDescriptor> extensions)
+ throws IOException {
+ ExtensionRegistry.ExtensionInfo extensionInfo = (ExtensionRegistry.ExtensionInfo) extension;
+
+ if (ExtensionRegistryLite.isEagerlyParseMessageSets()) {
+ Object value =
+ reader.readMessage(extensionInfo.defaultInstance.getClass(), extensionRegistry);
+ extensions.setField(extensionInfo.descriptor, value);
+ } else {
+ extensions.setField(
+ extensionInfo.descriptor,
+ new LazyField(extensionInfo.defaultInstance, extensionRegistry, reader.readBytes()));
+ }
+ }
+
+ @Override
+ void parseMessageSetItem(
+ ByteString data,
+ Object extension,
+ ExtensionRegistryLite extensionRegistry,
+ FieldSet<FieldDescriptor> extensions)
+ throws IOException {
+ ExtensionRegistry.ExtensionInfo extensionInfo = (ExtensionRegistry.ExtensionInfo) extension;
+ Object value = extensionInfo.defaultInstance.newBuilderForType().buildPartial();
+
+ if (ExtensionRegistryLite.isEagerlyParseMessageSets()) {
+ Reader reader = BinaryReader.newInstance(ByteBuffer.wrap(data.toByteArray()), true);
+ Protobuf.getInstance().mergeFrom(value, reader, extensionRegistry);
+ extensions.setField(extensionInfo.descriptor, value);
+
+ if (reader.getFieldNumber() != Reader.READ_DONE) {
+ throw InvalidProtocolBufferException.invalidEndTag();
+ }
+ } else {
+ extensions.setField(
+ extensionInfo.descriptor,
+ new LazyField(extensionInfo.defaultInstance, extensionRegistry, data));
+ }
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/ExtensionSchemaLite.java b/java/core/src/main/java/com/google/protobuf/ExtensionSchemaLite.java
new file mode 100755
index 0000000..7f6846e
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/ExtensionSchemaLite.java
@@ -0,0 +1,541 @@
+// 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.GeneratedMessageLite.ExtensionDescriptor;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@SuppressWarnings("unchecked")
+final class ExtensionSchemaLite extends ExtensionSchema<ExtensionDescriptor> {
+
+ @Override
+ boolean hasExtensions(MessageLite prototype) {
+ return prototype instanceof GeneratedMessageLite.ExtendableMessage;
+ }
+
+ @Override
+ FieldSet<ExtensionDescriptor> getExtensions(Object message) {
+ return ((GeneratedMessageLite.ExtendableMessage<?, ?>) message).extensions;
+ }
+
+ @Override
+ void setExtensions(Object message, FieldSet<ExtensionDescriptor> extensions) {
+ ((GeneratedMessageLite.ExtendableMessage<?, ?>) message).extensions = extensions;
+ }
+
+ @Override
+ FieldSet<ExtensionDescriptor> getMutableExtensions(Object message) {
+ return ((GeneratedMessageLite.ExtendableMessage<?, ?>) message).ensureExtensionsAreMutable();
+ }
+
+ @Override
+ void makeImmutable(Object message) {
+ getExtensions(message).makeImmutable();
+ }
+
+ @Override
+ <UT, UB> UB parseExtension(
+ Reader reader,
+ Object extensionObject,
+ ExtensionRegistryLite extensionRegistry,
+ FieldSet<ExtensionDescriptor> extensions,
+ UB unknownFields,
+ UnknownFieldSchema<UT, UB> unknownFieldSchema)
+ throws IOException {
+ GeneratedMessageLite.GeneratedExtension<?, ?> extension =
+ (GeneratedMessageLite.GeneratedExtension<?, ?>) extensionObject;
+ int fieldNumber = extension.getNumber();
+
+ if (extension.descriptor.isRepeated() && extension.descriptor.isPacked()) {
+ Object value = null;
+ switch (extension.getLiteType()) {
+ case DOUBLE:
+ {
+ List<Double> list = new ArrayList<Double>();
+ reader.readDoubleList(list);
+ value = list;
+ break;
+ }
+ case FLOAT:
+ {
+ List<Float> list = new ArrayList<Float>();
+ reader.readFloatList(list);
+ value = list;
+ break;
+ }
+ case INT64:
+ {
+ List<Long> list = new ArrayList<Long>();
+ reader.readInt64List(list);
+ value = list;
+ break;
+ }
+ case UINT64:
+ {
+ List<Long> list = new ArrayList<Long>();
+ reader.readUInt64List(list);
+ value = list;
+ break;
+ }
+ case INT32:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readInt32List(list);
+ value = list;
+ break;
+ }
+ case FIXED64:
+ {
+ List<Long> list = new ArrayList<Long>();
+ reader.readFixed64List(list);
+ value = list;
+ break;
+ }
+ case FIXED32:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readFixed32List(list);
+ value = list;
+ break;
+ }
+ case BOOL:
+ {
+ List<Boolean> list = new ArrayList<Boolean>();
+ reader.readBoolList(list);
+ value = list;
+ break;
+ }
+ case UINT32:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readUInt32List(list);
+ value = list;
+ break;
+ }
+ case SFIXED32:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readSFixed32List(list);
+ value = list;
+ break;
+ }
+ case SFIXED64:
+ {
+ List<Long> list = new ArrayList<Long>();
+ reader.readSFixed64List(list);
+ value = list;
+ break;
+ }
+ case SINT32:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readSInt32List(list);
+ value = list;
+ break;
+ }
+ case SINT64:
+ {
+ List<Long> list = new ArrayList<Long>();
+ reader.readSInt64List(list);
+ value = list;
+ break;
+ }
+ case ENUM:
+ {
+ List<Integer> list = new ArrayList<Integer>();
+ reader.readEnumList(list);
+ unknownFields =
+ SchemaUtil.filterUnknownEnumList(
+ fieldNumber,
+ list,
+ extension.descriptor.getEnumType(),
+ unknownFields,
+ unknownFieldSchema);
+ value = list;
+ break;
+ }
+ default:
+ throw new IllegalStateException(
+ "Type cannot be packed: " + extension.descriptor.getLiteType());
+ }
+ extensions.setField(extension.descriptor, value);
+ } else {
+ Object value = null;
+ // Enum is a special case becasue unknown enum values will be put into UnknownFieldSetLite.
+ if (extension.getLiteType() == WireFormat.FieldType.ENUM) {
+ int number = reader.readInt32();
+ Object enumValue = extension.descriptor.getEnumType().findValueByNumber(number);
+ if (enumValue == null) {
+ return SchemaUtil.storeUnknownEnum(
+ fieldNumber, number, unknownFields, unknownFieldSchema);
+ }
+ // Note, we store the integer value instead of the actual enum object in FieldSet.
+ // This is also different from full-runtime where we store EnumValueDescriptor.
+ value = number;
+ } else {
+ switch (extension.getLiteType()) {
+ case DOUBLE:
+ value = reader.readDouble();
+ break;
+ case FLOAT:
+ value = reader.readFloat();
+ break;
+ case INT64:
+ value = reader.readInt64();
+ break;
+ case UINT64:
+ value = reader.readUInt64();
+ break;
+ case INT32:
+ value = reader.readInt32();
+ break;
+ case FIXED64:
+ value = reader.readFixed64();
+ break;
+ case FIXED32:
+ value = reader.readFixed32();
+ break;
+ case BOOL:
+ value = reader.readBool();
+ break;
+ case BYTES:
+ value = reader.readBytes();
+ break;
+ case UINT32:
+ value = reader.readUInt32();
+ break;
+ case SFIXED32:
+ value = reader.readSFixed32();
+ break;
+ case SFIXED64:
+ value = reader.readSFixed64();
+ break;
+ case SINT32:
+ value = reader.readSInt32();
+ break;
+ case SINT64:
+ value = reader.readSInt64();
+ break;
+
+ case STRING:
+ value = reader.readString();
+ break;
+ case GROUP:
+ value =
+ reader.readGroup(
+ extension.getMessageDefaultInstance().getClass(), extensionRegistry);
+ break;
+
+ case MESSAGE:
+ value =
+ reader.readMessage(
+ extension.getMessageDefaultInstance().getClass(), extensionRegistry);
+ break;
+
+ case ENUM:
+ throw new IllegalStateException("Shouldn't reach here.");
+ }
+ }
+ if (extension.isRepeated()) {
+ extensions.addRepeatedField(extension.descriptor, value);
+ } else {
+ switch (extension.getLiteType()) {
+ case MESSAGE:
+ case GROUP:
+ Object oldValue = extensions.getField(extension.descriptor);
+ if (oldValue != null) {
+ value = Internal.mergeMessage(oldValue, value);
+ }
+ break;
+ default:
+ break;
+ }
+ extensions.setField(extension.descriptor, value);
+ }
+ }
+ return unknownFields;
+ }
+
+ @Override
+ int extensionNumber(Map.Entry<?, ?> extension) {
+ GeneratedMessageLite.ExtensionDescriptor descriptor =
+ (GeneratedMessageLite.ExtensionDescriptor) extension.getKey();
+ return descriptor.getNumber();
+ }
+
+ @Override
+ void serializeExtension(Writer writer, Map.Entry<?, ?> extension) throws IOException {
+ GeneratedMessageLite.ExtensionDescriptor descriptor =
+ (GeneratedMessageLite.ExtensionDescriptor) extension.getKey();
+ if (descriptor.isRepeated()) {
+ switch (descriptor.getLiteType()) {
+ case DOUBLE:
+ SchemaUtil.writeDoubleList(
+ descriptor.getNumber(),
+ (List<Double>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case FLOAT:
+ SchemaUtil.writeFloatList(
+ descriptor.getNumber(),
+ (List<Float>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case INT64:
+ SchemaUtil.writeInt64List(
+ descriptor.getNumber(),
+ (List<Long>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case UINT64:
+ SchemaUtil.writeUInt64List(
+ descriptor.getNumber(),
+ (List<Long>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case INT32:
+ SchemaUtil.writeInt32List(
+ descriptor.getNumber(),
+ (List<Integer>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case FIXED64:
+ SchemaUtil.writeFixed64List(
+ descriptor.getNumber(),
+ (List<Long>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case FIXED32:
+ SchemaUtil.writeFixed32List(
+ descriptor.getNumber(),
+ (List<Integer>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case BOOL:
+ SchemaUtil.writeBoolList(
+ descriptor.getNumber(),
+ (List<Boolean>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case BYTES:
+ SchemaUtil.writeBytesList(
+ descriptor.getNumber(), (List<ByteString>) extension.getValue(), writer);
+ break;
+ case UINT32:
+ SchemaUtil.writeUInt32List(
+ descriptor.getNumber(),
+ (List<Integer>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case SFIXED32:
+ SchemaUtil.writeSFixed32List(
+ descriptor.getNumber(),
+ (List<Integer>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case SFIXED64:
+ SchemaUtil.writeSFixed64List(
+ descriptor.getNumber(),
+ (List<Long>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case SINT32:
+ SchemaUtil.writeSInt32List(
+ descriptor.getNumber(),
+ (List<Integer>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case SINT64:
+ SchemaUtil.writeSInt64List(
+ descriptor.getNumber(),
+ (List<Long>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case ENUM:
+ SchemaUtil.writeInt32List(
+ descriptor.getNumber(),
+ (List<Integer>) extension.getValue(),
+ writer,
+ descriptor.isPacked());
+ break;
+ case STRING:
+ SchemaUtil.writeStringList(
+ descriptor.getNumber(), (List<String>) extension.getValue(), writer);
+ break;
+ case GROUP:
+ {
+ List<?> data = (List<?>) extension.getValue();
+ if (data != null && !data.isEmpty()) {
+ SchemaUtil.writeGroupList(
+ descriptor.getNumber(),
+ (List<?>) extension.getValue(),
+ writer,
+ Protobuf.getInstance().schemaFor(data.get(0).getClass()));
+ }
+ }
+ break;
+ case MESSAGE:
+ {
+ List<?> data = (List<?>) extension.getValue();
+ if (data != null && !data.isEmpty()) {
+ SchemaUtil.writeMessageList(
+ descriptor.getNumber(),
+ (List<?>) extension.getValue(),
+ writer,
+ Protobuf.getInstance().schemaFor(data.get(0).getClass()));
+ }
+ }
+ break;
+ }
+ } else {
+ switch (descriptor.getLiteType()) {
+ case DOUBLE:
+ writer.writeDouble(descriptor.getNumber(), (Double) extension.getValue());
+ break;
+ case FLOAT:
+ writer.writeFloat(descriptor.getNumber(), (Float) extension.getValue());
+ break;
+ case INT64:
+ writer.writeInt64(descriptor.getNumber(), (Long) extension.getValue());
+ break;
+ case UINT64:
+ writer.writeUInt64(descriptor.getNumber(), (Long) extension.getValue());
+ break;
+ case INT32:
+ writer.writeInt32(descriptor.getNumber(), (Integer) extension.getValue());
+ break;
+ case FIXED64:
+ writer.writeFixed64(descriptor.getNumber(), (Long) extension.getValue());
+ break;
+ case FIXED32:
+ writer.writeFixed32(descriptor.getNumber(), (Integer) extension.getValue());
+ break;
+ case BOOL:
+ writer.writeBool(descriptor.getNumber(), (Boolean) extension.getValue());
+ break;
+ case BYTES:
+ writer.writeBytes(descriptor.getNumber(), (ByteString) extension.getValue());
+ break;
+ case UINT32:
+ writer.writeUInt32(descriptor.getNumber(), (Integer) extension.getValue());
+ break;
+ case SFIXED32:
+ writer.writeSFixed32(descriptor.getNumber(), (Integer) extension.getValue());
+ break;
+ case SFIXED64:
+ writer.writeSFixed64(descriptor.getNumber(), (Long) extension.getValue());
+ break;
+ case SINT32:
+ writer.writeSInt32(descriptor.getNumber(), (Integer) extension.getValue());
+ break;
+ case SINT64:
+ writer.writeSInt64(descriptor.getNumber(), (Long) extension.getValue());
+ break;
+ case ENUM:
+ writer.writeInt32(descriptor.getNumber(), (Integer) extension.getValue());
+ break;
+ case STRING:
+ writer.writeString(descriptor.getNumber(), (String) extension.getValue());
+ break;
+ case GROUP:
+ writer.writeGroup(
+ descriptor.getNumber(),
+ extension.getValue(),
+ Protobuf.getInstance().schemaFor(extension.getValue().getClass()));
+ break;
+ case MESSAGE:
+ writer.writeMessage(
+ descriptor.getNumber(),
+ extension.getValue(),
+ Protobuf.getInstance().schemaFor(extension.getValue().getClass()));
+ break;
+ }
+ }
+ }
+
+ @Override
+ Object findExtensionByNumber(
+ ExtensionRegistryLite extensionRegistry, MessageLite defaultInstance, int number) {
+ return extensionRegistry.findLiteExtensionByNumber(defaultInstance, number);
+ }
+
+ @Override
+ void parseLengthPrefixedMessageSetItem(
+ Reader reader,
+ Object extensionObject,
+ ExtensionRegistryLite extensionRegistry,
+ FieldSet<ExtensionDescriptor> extensions)
+ throws IOException {
+ GeneratedMessageLite.GeneratedExtension<?, ?> extension =
+ (GeneratedMessageLite.GeneratedExtension<?, ?>) extensionObject;
+ Object value =
+ reader.readMessage(extension.getMessageDefaultInstance().getClass(), extensionRegistry);
+ extensions.setField(extension.descriptor, value);
+ }
+
+ @Override
+ void parseMessageSetItem(
+ ByteString data,
+ Object extensionObject,
+ ExtensionRegistryLite extensionRegistry,
+ FieldSet<ExtensionDescriptor> extensions)
+ throws IOException {
+ GeneratedMessageLite.GeneratedExtension<?, ?> extension =
+ (GeneratedMessageLite.GeneratedExtension<?, ?>) extensionObject;
+ Object value = extension.getMessageDefaultInstance().newBuilderForType().buildPartial();
+
+ Reader reader = BinaryReader.newInstance(ByteBuffer.wrap(data.toByteArray()), true);
+
+ Protobuf.getInstance().mergeFrom(value, reader, extensionRegistry);
+ extensions.setField(extension.descriptor, value);
+
+ if (reader.getFieldNumber() != Reader.READ_DONE) {
+ throw InvalidProtocolBufferException.invalidEndTag();
+ }
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/ExtensionSchemas.java b/java/core/src/main/java/com/google/protobuf/ExtensionSchemas.java
new file mode 100755
index 0000000..46ce327
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/ExtensionSchemas.java
@@ -0,0 +1,56 @@
+// 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;
+
+final class ExtensionSchemas {
+ private static final ExtensionSchema<?> LITE_SCHEMA = new ExtensionSchemaLite();
+ private static final ExtensionSchema<?> FULL_SCHEMA = loadSchemaForFullRuntime();
+
+ private static ExtensionSchema<?> loadSchemaForFullRuntime() {
+ try {
+ Class<?> clazz = Class.forName("com.google.protobuf.ExtensionSchemaFull");
+ return (ExtensionSchema) clazz.getDeclaredConstructor().newInstance();
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+ static ExtensionSchema<?> lite() {
+ return LITE_SCHEMA;
+ }
+
+ static ExtensionSchema<?> full() {
+ if (FULL_SCHEMA == null) {
+ throw new IllegalStateException("Protobuf runtime is not correctly loaded.");
+ }
+ return FULL_SCHEMA;
+ }
+}
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 100755
index 0000000..71a307a
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/FieldInfo.java
@@ -0,0 +1,577 @@
+// 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 com.google.protobuf.Internal.EnumVerifier;
+import java.lang.reflect.Field;
+
+/** Information for a single field in a protobuf message class. */
+@ExperimentalApi
+final class FieldInfo implements Comparable<FieldInfo> {
+ private final Field field;
+ private final FieldType type;
+ private final Class<?> messageClass; // The message type for repeated message fields.
+ private final int fieldNumber;
+ private final Field presenceField;
+ private final int presenceMask;
+ private final boolean required;
+ private final boolean enforceUtf8;
+ private final OneofInfo oneof;
+ private final Field cachedSizeField;
+ /**
+ * The actual type stored in the oneof value for this field. Since the oneof value is an {@link
+ * Object}, primitives will store their boxed type. Only valid in conjunction with {@link #oneof}
+ * (both must be either null or non-null.
+ */
+ private final Class<?> oneofStoredType;
+
+ // TODO(liujisi): make map default entry lazy?
+ private final Object mapDefaultEntry;
+
+ private final EnumVerifier enumVerifier;
+
+ /** Constructs a new descriptor for a field. */
+ public static FieldInfo forField(
+ Field field, int fieldNumber, FieldType fieldType, boolean enforceUtf8) {
+ checkFieldNumber(fieldNumber);
+ checkNotNull(field, "field");
+ checkNotNull(fieldType, "fieldType");
+ if (fieldType == FieldType.MESSAGE_LIST || fieldType == FieldType.GROUP_LIST) {
+ throw new IllegalStateException("Shouldn't be called for repeated message fields.");
+ }
+ return new FieldInfo(
+ field,
+ fieldNumber,
+ fieldType,
+ /* messageClass= */ null,
+ /* presenceField= */ null,
+ /* presenceMask= */ 0,
+ /* required= */ false,
+ enforceUtf8,
+ /* oneof= */ null,
+ /* oneofStoredType= */ null,
+ /* mapDefaultEntry= */ null,
+ /* enumVerifier= */ null,
+ /* cachedSizeField= */ null);
+ }
+
+ /** Constructs a new descriptor for a packed field. */
+ public static FieldInfo forPackedField(
+ Field field, int fieldNumber, FieldType fieldType, Field cachedSizeField) {
+ checkFieldNumber(fieldNumber);
+ checkNotNull(field, "field");
+ checkNotNull(fieldType, "fieldType");
+ if (fieldType == FieldType.MESSAGE_LIST || fieldType == FieldType.GROUP_LIST) {
+ throw new IllegalStateException("Shouldn't be called for repeated message fields.");
+ }
+ return new FieldInfo(
+ field,
+ fieldNumber,
+ fieldType,
+ /* messageClass= */ null,
+ /* presenceField= */ null,
+ /* presenceMask= */ 0,
+ /* required= */ false,
+ /* enforceUtf8= */ false,
+ /* oneof= */ null,
+ /* oneofStoredType= */ null,
+ /* mapDefaultEntry= */ null,
+ /* enumVerifier= */ null,
+ cachedSizeField);
+ }
+
+ /** Constructs a new descriptor for a repeated message field. */
+ public static FieldInfo forRepeatedMessageField(
+ Field field, int fieldNumber, FieldType fieldType, Class<?> messageClass) {
+ checkFieldNumber(fieldNumber);
+ checkNotNull(field, "field");
+ checkNotNull(fieldType, "fieldType");
+ checkNotNull(messageClass, "messageClass");
+ return new FieldInfo(
+ field,
+ fieldNumber,
+ fieldType,
+ messageClass,
+ /* presenceField= */ null,
+ /* presenceMask= */ 0,
+ /* required= */ false,
+ /* enforceUtf8= */ false,
+ /* oneof= */ null,
+ /* oneofStoredType= */ null,
+ /* mapDefaultEntry= */ null,
+ /* enumVerifier= */ null,
+ /* cachedSizeField= */ null);
+ }
+
+ public static FieldInfo forFieldWithEnumVerifier(
+ Field field, int fieldNumber, FieldType fieldType, EnumVerifier enumVerifier) {
+ checkFieldNumber(fieldNumber);
+ checkNotNull(field, "field");
+ return new FieldInfo(
+ field,
+ fieldNumber,
+ fieldType,
+ /* messageClass= */ null,
+ /* presenceField= */ null,
+ /* presenceMask= */ 0,
+ /* required= */ false,
+ /* enforceUtf8= */ false,
+ /* oneof= */ null,
+ /* oneofStoredType= */ null,
+ /* mapDefaultEntry= */ null,
+ enumVerifier,
+ /* cachedSizeField= */ null);
+ }
+
+ public static FieldInfo forPackedFieldWithEnumVerifier(
+ Field field,
+ int fieldNumber,
+ FieldType fieldType,
+ EnumVerifier enumVerifier,
+ Field cachedSizeField) {
+ checkFieldNumber(fieldNumber);
+ checkNotNull(field, "field");
+ return new FieldInfo(
+ field,
+ fieldNumber,
+ fieldType,
+ /* messageClass= */ null,
+ /* presenceField= */ null,
+ /* presenceMask= */ 0,
+ /* required= */ false,
+ /* enforceUtf8= */ false,
+ /* oneof= */ null,
+ /* oneofStoredType= */ null,
+ /* mapDefaultEntry= */ null,
+ enumVerifier,
+ cachedSizeField);
+ }
+
+ /** Constructor for a proto2 optional field. */
+ public static FieldInfo forProto2OptionalField(
+ Field field,
+ int fieldNumber,
+ FieldType fieldType,
+ Field presenceField,
+ int presenceMask,
+ boolean enforceUtf8,
+ EnumVerifier enumVerifier) {
+ checkFieldNumber(fieldNumber);
+ checkNotNull(field, "field");
+ checkNotNull(fieldType, "fieldType");
+ checkNotNull(presenceField, "presenceField");
+ if (presenceField != null && !isExactlyOneBitSet(presenceMask)) {
+ throw new IllegalArgumentException(
+ "presenceMask must have exactly one bit set: " + presenceMask);
+ }
+ return new FieldInfo(
+ field,
+ fieldNumber,
+ fieldType,
+ /* messageClass= */ null,
+ presenceField,
+ presenceMask,
+ /* required= */ false,
+ enforceUtf8,
+ /* oneof= */ null,
+ /* oneofStoredType= */ null,
+ /* mapDefaultEntry= */ null,
+ enumVerifier,
+ /* cachedSizeField= */ null);
+ }
+
+ /**
+ * Constructor for a field that is part of a oneof.
+ *
+ * @param fieldNumber the unique field number for this field within the message.
+ * @param fieldType the type of the field (must be non-null).
+ * @param oneof the oneof for which this field is associated (must be non-null).
+ * @param oneofStoredType the actual type stored in the oneof value for this field. Since the
+ * oneof value is an {@link Object}, primitives will store their boxed type. Must be non-null.
+ * @param enforceUtf8 Only used for string fields. If {@code true}, will enforce UTF-8 on a string
+ * field.
+ * @return the {@link FieldInfo} describing this field.
+ */
+ public static FieldInfo forOneofMemberField(
+ int fieldNumber,
+ FieldType fieldType,
+ OneofInfo oneof,
+ Class<?> oneofStoredType,
+ boolean enforceUtf8,
+ EnumVerifier enumVerifier) {
+ checkFieldNumber(fieldNumber);
+ checkNotNull(fieldType, "fieldType");
+ checkNotNull(oneof, "oneof");
+ checkNotNull(oneofStoredType, "oneofStoredType");
+ if (!fieldType.isScalar()) {
+ throw new IllegalArgumentException(
+ "Oneof is only supported for scalar fields. Field "
+ + fieldNumber
+ + " is of type "
+ + fieldType);
+ }
+ return new FieldInfo(
+ /* field= */ null,
+ fieldNumber,
+ fieldType,
+ /* messageClass= */ null,
+ /* presenceField= */ null,
+ /* presenceMask= */ 0,
+ /* required= */ false,
+ enforceUtf8,
+ oneof,
+ oneofStoredType,
+ /* mapDefaultEntry= */ null,
+ enumVerifier,
+ /* cachedSizeField= */ null);
+ }
+
+ private static void checkFieldNumber(int fieldNumber) {
+ if (fieldNumber <= 0) {
+ throw new IllegalArgumentException("fieldNumber must be positive: " + fieldNumber);
+ }
+ }
+
+ /** Constructor for a proto2 required field. */
+ public static FieldInfo forProto2RequiredField(
+ Field field,
+ int fieldNumber,
+ FieldType fieldType,
+ Field presenceField,
+ int presenceMask,
+ boolean enforceUtf8,
+ EnumVerifier enumVerifier) {
+ checkFieldNumber(fieldNumber);
+ checkNotNull(field, "field");
+ checkNotNull(fieldType, "fieldType");
+ checkNotNull(presenceField, "presenceField");
+ if (presenceField != null && !isExactlyOneBitSet(presenceMask)) {
+ throw new IllegalArgumentException(
+ "presenceMask must have exactly one bit set: " + presenceMask);
+ }
+ return new FieldInfo(
+ field,
+ fieldNumber,
+ fieldType,
+ /* messageClass= */ null,
+ presenceField,
+ presenceMask,
+ /* required= */ true,
+ enforceUtf8,
+ /* oneof= */ null,
+ /* oneofStoredType= */ null,
+ /* mapDefaultEntry= */ null,
+ /* enumVerifier= */ enumVerifier,
+ /* cachedSizeField= */ null);
+ }
+
+ public static FieldInfo forMapField(
+ Field field, int fieldNumber, Object mapDefaultEntry, EnumVerifier enumVerifier) {
+ checkNotNull(mapDefaultEntry, "mapDefaultEntry");
+ checkFieldNumber(fieldNumber);
+ checkNotNull(field, "field");
+ return new FieldInfo(
+ field,
+ fieldNumber,
+ FieldType.MAP,
+ /* messageClass= */ null,
+ /* presenceField= */ null,
+ /* presenceMask= */ 0,
+ /* required= */ false,
+ /* enforceUtf8= */ true,
+ /* oneof= */ null,
+ /* oneofStoredType= */ null,
+ mapDefaultEntry,
+ enumVerifier,
+ /* cachedSizeField= */ null);
+ }
+
+ private FieldInfo(
+ Field field,
+ int fieldNumber,
+ FieldType type,
+ Class<?> messageClass,
+ Field presenceField,
+ int presenceMask,
+ boolean required,
+ boolean enforceUtf8,
+ OneofInfo oneof,
+ Class<?> oneofStoredType,
+ Object mapDefaultEntry,
+ EnumVerifier enumVerifier,
+ Field cachedSizeField) {
+ this.field = field;
+ this.type = type;
+ this.messageClass = messageClass;
+ this.fieldNumber = fieldNumber;
+ this.presenceField = presenceField;
+ this.presenceMask = presenceMask;
+ this.required = required;
+ this.enforceUtf8 = enforceUtf8;
+ this.oneof = oneof;
+ this.oneofStoredType = oneofStoredType;
+ this.mapDefaultEntry = mapDefaultEntry;
+ this.enumVerifier = enumVerifier;
+ this.cachedSizeField = cachedSizeField;
+ }
+
+ /** Gets the field number for the field. */
+ public int getFieldNumber() {
+ return fieldNumber;
+ }
+
+ /** 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 oneof for which this field is a member, or {@code null} if not part of a oneof. */
+ public OneofInfo getOneof() {
+ return oneof;
+ }
+
+ /**
+ * Gets the actual type stored in the oneof value by this field. Since the oneof value is an
+ * {@link Object}, primitives will store their boxed type. For non-oneof fields, this will always
+ * be {@code null}.
+ */
+ public Class<?> getOneofStoredType() {
+ return oneofStoredType;
+ }
+
+ /** Gets the {@code EnumVerifier} if the field is an enum field. */
+ public EnumVerifier getEnumVerifier() {
+ return enumVerifier;
+ }
+
+ @Override
+ public int compareTo(FieldInfo o) {
+ return fieldNumber - o.fieldNumber;
+ }
+
+ /**
+ * For repeated message fields, returns the message type of the field. For other fields, returns
+ * {@code null}.
+ */
+ public Class<?> getListElementType() {
+ return messageClass;
+ }
+
+ /** Gets the presence bit field. Only valid for unary fields. For lists, returns {@code null}. */
+ public Field getPresenceField() {
+ return presenceField;
+ }
+
+ public Object getMapDefaultEntry() {
+ return mapDefaultEntry;
+ }
+
+ /**
+ * 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;
+ }
+
+ /** Whether this is a required field. */
+ public boolean isRequired() {
+ return required;
+ }
+
+ /**
+ * Whether a UTF-8 should be enforced on string fields. Only applies to strings and string lists.
+ */
+ public boolean isEnforceUtf8() {
+ return enforceUtf8;
+ }
+
+ public Field getCachedSizeField() {
+ return cachedSizeField;
+ }
+
+ /**
+ * For singular or repeated message fields, returns the message type. For other fields, returns
+ * {@code null}.
+ */
+ public Class<?> getMessageFieldClass() {
+ switch (type) {
+ case MESSAGE:
+ case GROUP:
+ return field != null ? field.getType() : oneofStoredType;
+ case MESSAGE_LIST:
+ case GROUP_LIST:
+ return messageClass;
+ default:
+ return null;
+ }
+ }
+
+ 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 boolean required;
+ private boolean enforceUtf8;
+ private OneofInfo oneof;
+ private Class<?> oneofStoredType;
+ private Object mapDefaultEntry;
+ private EnumVerifier enumVerifier;
+ private Field cachedSizeField;
+
+ private Builder() {}
+
+ /**
+ * Specifies the actual field on the message represented by this field. This should not be
+ * called for oneof member fields.
+ */
+ public Builder withField(Field field) {
+ if (oneof != null) {
+ throw new IllegalStateException("Cannot set field when building a oneof.");
+ }
+ this.field = field;
+ return this;
+ }
+
+ /** Specifies the type of this field. */
+ public Builder withType(FieldType type) {
+ this.type = type;
+ return this;
+ }
+
+ /** Specifies the unique field number for this field within the message. */
+ public Builder withFieldNumber(int fieldNumber) {
+ this.fieldNumber = fieldNumber;
+ return this;
+ }
+
+ /** Specifies proto2 presence information. This should not be called for oneof fields. */
+ public Builder withPresence(Field presenceField, int presenceMask) {
+ this.presenceField = checkNotNull(presenceField, "presenceField");
+ this.presenceMask = presenceMask;
+ return this;
+ }
+
+ /**
+ * Sets the information for building a oneof member field. This is incompatible with {@link
+ * #withField(Field)} and {@link #withPresence(Field, int)}.
+ *
+ * @param oneof the oneof for which this field is associated.
+ * @param oneofStoredType the actual type stored in the oneof value for this field. Since the
+ * oneof value is an {@link Object}, primitives will store their boxed type.
+ */
+ public Builder withOneof(OneofInfo oneof, Class<?> oneofStoredType) {
+ if (field != null || presenceField != null) {
+ throw new IllegalStateException(
+ "Cannot set oneof when field or presenceField have been provided");
+ }
+ this.oneof = oneof;
+ this.oneofStoredType = oneofStoredType;
+ return this;
+ }
+
+ public Builder withRequired(boolean required) {
+ this.required = required;
+ return this;
+ }
+
+ public Builder withMapDefaultEntry(Object mapDefaultEntry) {
+ this.mapDefaultEntry = mapDefaultEntry;
+ return this;
+ }
+
+ public Builder withEnforceUtf8(boolean enforceUtf8) {
+ this.enforceUtf8 = enforceUtf8;
+ return this;
+ }
+
+ public Builder withEnumVerifier(EnumVerifier enumVerifier) {
+ this.enumVerifier = enumVerifier;
+ return this;
+ }
+
+ public Builder withCachedSizeField(Field cachedSizeField) {
+ this.cachedSizeField = cachedSizeField;
+ return this;
+ }
+
+ public FieldInfo build() {
+ if (oneof != null) {
+ return forOneofMemberField(
+ fieldNumber, type, oneof, oneofStoredType, enforceUtf8, enumVerifier);
+ }
+ if (mapDefaultEntry != null) {
+ return forMapField(field, fieldNumber, mapDefaultEntry, enumVerifier);
+ }
+ if (presenceField != null) {
+ if (required) {
+ return forProto2RequiredField(
+ field, fieldNumber, type, presenceField, presenceMask, enforceUtf8, enumVerifier);
+ } else {
+ return forProto2OptionalField(
+ field, fieldNumber, type, presenceField, presenceMask, enforceUtf8, enumVerifier);
+ }
+ }
+ if (enumVerifier != null) {
+ if (cachedSizeField == null) {
+ return forFieldWithEnumVerifier(field, fieldNumber, type, enumVerifier);
+ } else {
+ return forPackedFieldWithEnumVerifier(
+ field, fieldNumber, type, enumVerifier, cachedSizeField);
+ }
+ } else {
+ if (cachedSizeField == null) {
+ return forField(field, fieldNumber, type, enforceUtf8);
+ } else {
+ return forPackedField(field, fieldNumber, type, cachedSizeField);
+ }
+ }
+ }
+ }
+
+ private static boolean isExactlyOneBitSet(int value) {
+ return value != 0 && (value & (value - 1)) == 0;
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/FieldSet.java b/java/core/src/main/java/com/google/protobuf/FieldSet.java
index 40a3762..ddfd0e5 100644
--- a/java/core/src/main/java/com/google/protobuf/FieldSet.java
+++ b/java/core/src/main/java/com/google/protobuf/FieldSet.java
@@ -218,6 +218,17 @@
return fields.entrySet().iterator();
}
+ /**
+ * Get an iterator over the fields in the map in descending (i.e. reverse) order. This iterator
+ * should not be leaked out of the protobuf library as it is not protected from mutation when
+ * fields is not immutable.
+ */
+ Iterator<Map.Entry<FieldDescriptorType, Object>> descendingIterator() {
+ if (hasLazyField) {
+ return new LazyIterator<FieldDescriptorType>(fields.descendingEntrySet().iterator());
+ }
+ return fields.descendingEntrySet().iterator();
+ }
/** Useful for implementing {@link Message#hasField(Descriptors.FieldDescriptor)}. */
public boolean hasField(final FieldDescriptorType descriptor) {
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 100755
index 0000000..1b8f9e5
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/FieldType.java
@@ -0,0 +1,346 @@
+// 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),
+ FLOAT(1, Collection.SCALAR, JavaType.FLOAT),
+ INT64(2, Collection.SCALAR, JavaType.LONG),
+ UINT64(3, Collection.SCALAR, JavaType.LONG),
+ INT32(4, Collection.SCALAR, JavaType.INT),
+ FIXED64(5, Collection.SCALAR, JavaType.LONG),
+ FIXED32(6, Collection.SCALAR, JavaType.INT),
+ BOOL(7, Collection.SCALAR, JavaType.BOOLEAN),
+ STRING(8, Collection.SCALAR, JavaType.STRING),
+ MESSAGE(9, Collection.SCALAR, JavaType.MESSAGE),
+ BYTES(10, Collection.SCALAR, JavaType.BYTE_STRING),
+ UINT32(11, Collection.SCALAR, JavaType.INT),
+ ENUM(12, Collection.SCALAR, JavaType.ENUM),
+ SFIXED32(13, Collection.SCALAR, JavaType.INT),
+ SFIXED64(14, Collection.SCALAR, JavaType.LONG),
+ SINT32(15, Collection.SCALAR, JavaType.INT),
+ SINT64(16, Collection.SCALAR, JavaType.LONG),
+ GROUP(17, Collection.SCALAR, JavaType.MESSAGE),
+ DOUBLE_LIST(18, Collection.VECTOR, JavaType.DOUBLE),
+ FLOAT_LIST(19, Collection.VECTOR, JavaType.FLOAT),
+ INT64_LIST(20, Collection.VECTOR, JavaType.LONG),
+ UINT64_LIST(21, Collection.VECTOR, JavaType.LONG),
+ INT32_LIST(22, Collection.VECTOR, JavaType.INT),
+ FIXED64_LIST(23, Collection.VECTOR, JavaType.LONG),
+ FIXED32_LIST(24, Collection.VECTOR, JavaType.INT),
+ BOOL_LIST(25, Collection.VECTOR, JavaType.BOOLEAN),
+ STRING_LIST(26, Collection.VECTOR, JavaType.STRING),
+ MESSAGE_LIST(27, Collection.VECTOR, JavaType.MESSAGE),
+ BYTES_LIST(28, Collection.VECTOR, JavaType.BYTE_STRING),
+ UINT32_LIST(29, Collection.VECTOR, JavaType.INT),
+ ENUM_LIST(30, Collection.VECTOR, JavaType.ENUM),
+ SFIXED32_LIST(31, Collection.VECTOR, JavaType.INT),
+ SFIXED64_LIST(32, Collection.VECTOR, JavaType.LONG),
+ SINT32_LIST(33, Collection.VECTOR, JavaType.INT),
+ SINT64_LIST(34, Collection.VECTOR, JavaType.LONG),
+ DOUBLE_LIST_PACKED(35, Collection.PACKED_VECTOR, JavaType.DOUBLE),
+ FLOAT_LIST_PACKED(36, Collection.PACKED_VECTOR, JavaType.FLOAT),
+ INT64_LIST_PACKED(37, Collection.PACKED_VECTOR, JavaType.LONG),
+ UINT64_LIST_PACKED(38, Collection.PACKED_VECTOR, JavaType.LONG),
+ INT32_LIST_PACKED(39, Collection.PACKED_VECTOR, JavaType.INT),
+ FIXED64_LIST_PACKED(40, Collection.PACKED_VECTOR, JavaType.LONG),
+ FIXED32_LIST_PACKED(41, Collection.PACKED_VECTOR, JavaType.INT),
+ BOOL_LIST_PACKED(42, Collection.PACKED_VECTOR, JavaType.BOOLEAN),
+ UINT32_LIST_PACKED(43, Collection.PACKED_VECTOR, JavaType.INT),
+ ENUM_LIST_PACKED(44, Collection.PACKED_VECTOR, JavaType.ENUM),
+ SFIXED32_LIST_PACKED(45, Collection.PACKED_VECTOR, JavaType.INT),
+ SFIXED64_LIST_PACKED(46, Collection.PACKED_VECTOR, JavaType.LONG),
+ SINT32_LIST_PACKED(47, Collection.PACKED_VECTOR, JavaType.INT),
+ SINT64_LIST_PACKED(48, Collection.PACKED_VECTOR, JavaType.LONG),
+ GROUP_LIST(49, Collection.VECTOR, JavaType.MESSAGE),
+ MAP(50, Collection.MAP, JavaType.VOID);
+
+ private final JavaType javaType;
+ private final int id;
+ private final Collection collection;
+ private final Class<?> elementType;
+ private final boolean primitiveScalar;
+
+ FieldType(int id, Collection collection, JavaType javaType) {
+ this.id = id;
+ this.collection = collection;
+ this.javaType = javaType;
+
+ switch (collection) {
+ case MAP:
+ elementType = javaType.getBoxedType();
+ break;
+ case VECTOR:
+ elementType = javaType.getBoxedType();
+ break;
+ case SCALAR:
+ default:
+ elementType = null;
+ break;
+ }
+
+ boolean primitiveScalar = false;
+ if (collection == Collection.SCALAR) {
+ switch (javaType) {
+ case BYTE_STRING:
+ case MESSAGE:
+ case STRING:
+ break;
+ default:
+ primitiveScalar = true;
+ break;
+ }
+ }
+ this.primitiveScalar = primitiveScalar;
+ }
+
+ /** 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 javaType;
+ }
+
+ /** 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 type represents a primitive scalar value. If this is {@code true},
+ * then {@link #isScalar()} will also be {@code true}.
+ */
+ public boolean isPrimitiveScalar() {
+ return primitiveScalar;
+ }
+
+ /** Indicates whether this field type represents a scalar value. */
+ public boolean isScalar() {
+ return collection == Collection.SCALAR;
+ }
+
+ /** Indicates whether this field represents a list of values. */
+ public boolean isList() {
+ return collection.isList();
+ }
+
+ /** Indicates whether this field represents a map. */
+ public boolean isMap() {
+ return collection == Collection.MAP;
+ }
+
+ /** 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 javaType.getType().isAssignableFrom(field.getType());
+ }
+ }
+
+ private boolean isValidForList(Field field) {
+ Class<?> clazz = field.getType();
+ if (!javaType.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 elementType.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(int 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<T>");
+ }
+ 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/GeneratedMessageInfoFactory.java b/java/core/src/main/java/com/google/protobuf/GeneratedMessageInfoFactory.java
new file mode 100755
index 0000000..3e3efb9
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/GeneratedMessageInfoFactory.java
@@ -0,0 +1,65 @@
+// 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 for message info that is generated into the message itself. */
+@ExperimentalApi
+class GeneratedMessageInfoFactory implements MessageInfoFactory {
+
+ private static final GeneratedMessageInfoFactory instance = new GeneratedMessageInfoFactory();
+
+ // Disallow construction - it's a singleton.
+ private GeneratedMessageInfoFactory() {}
+
+ public static GeneratedMessageInfoFactory getInstance() {
+ return instance;
+ }
+
+ @Override
+ public boolean isSupported(Class<?> messageType) {
+ return GeneratedMessageLite.class.isAssignableFrom(messageType);
+ }
+
+ @Override
+ public MessageInfo messageInfoFor(Class<?> messageType) {
+ if (!GeneratedMessageLite.class.isAssignableFrom(messageType)) {
+ throw new IllegalArgumentException("Unsupported message type: " + messageType.getName());
+ }
+
+ try {
+ return (MessageInfo) GeneratedMessageLite.getDefaultInstance(
+ messageType.asSubclass(GeneratedMessageLite.class))
+ .buildMessageInfo();
+ } catch (Exception e) {
+ throw new RuntimeException("Unable to get message info for " + messageType.getName(), e);
+ }
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/GeneratedMessageLite.java b/java/core/src/main/java/com/google/protobuf/GeneratedMessageLite.java
index 619ef09..61cbed6 100644
--- a/java/core/src/main/java/com/google/protobuf/GeneratedMessageLite.java
+++ b/java/core/src/main/java/com/google/protobuf/GeneratedMessageLite.java
@@ -61,12 +61,6 @@
MessageType extends GeneratedMessageLite<MessageType, BuilderType>,
BuilderType extends GeneratedMessageLite.Builder<MessageType, BuilderType>>
extends AbstractMessageLite<MessageType, BuilderType> {
- // BEGIN REGULAR
- static final boolean ENABLE_EXPERIMENTAL_RUNTIME_AT_BUILD_TIME = false;
- // END REGULAR
- // BEGIN EXPERIMENTAL
- // static final boolean ENABLE_EXPERIMENTAL_RUNTIME_AT_BUILD_TIME = true;
- // END EXPERIMENTAL
/** For use by generated code only. Lazily initialized to reduce allocations. */
protected UnknownFieldSetLite unknownFields = UnknownFieldSetLite.getDefaultInstance();
@@ -115,31 +109,9 @@
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
- // BEGIN EXPERIMENTAL
- // memoizedHashCode = Protobuf.getInstance().schemaFor(this).hashCode(this);
- // return memoizedHashCode;
- // END EXPERIMENTAL
- // BEGIN REGULAR
- HashCodeVisitor visitor = new HashCodeVisitor();
- visit(visitor, (MessageType) this);
- memoizedHashCode = visitor.hashCode;
- return memoizedHashCode;
- // END REGULAR
- }
-
- // BEGIN REGULAR
- @SuppressWarnings("unchecked") // Guaranteed by runtime
- int hashCode(HashCodeVisitor visitor) {
- if (memoizedHashCode == 0) {
- int inProgressHashCode = visitor.hashCode;
- visitor.hashCode = 0;
- visit(visitor, (MessageType) this);
- memoizedHashCode = visitor.hashCode;
- visitor.hashCode = inProgressHashCode;
- }
+ memoizedHashCode = Protobuf.getInstance().schemaFor(this).hashCode(this);
return memoizedHashCode;
}
- // END REGULAR
@SuppressWarnings("unchecked") // Guaranteed by isInstance + runtime
@Override
@@ -152,37 +124,9 @@
return false;
}
- // BEGIN EXPERIMENTAL
- // return Protobuf.getInstance().schemaFor(this).equals(this, (MessageType) other);
- // END EXPERIMENTAL
- // BEGIN REGULAR
-
- try {
- visit(EqualsVisitor.INSTANCE, (MessageType) other);
- } catch (EqualsVisitor.NotEqualsException e) {
- return false;
- }
- return true;
- // END REGULAR
+ return Protobuf.getInstance().schemaFor(this).equals(this, (MessageType) other);
}
- // BEGIN REGULAR
- /** Same as {@link #equals(Object)} but throws {@code NotEqualsException}. */
- @SuppressWarnings("unchecked") // Guaranteed by isInstance + runtime
- boolean equals(EqualsVisitor visitor, MessageLite other) {
- if (this == other) {
- return true;
- }
-
- if (!getDefaultInstanceForType().getClass().isInstance(other)) {
- return false;
- }
-
- visit(visitor, (MessageType) other);
- return true;
- }
- // END REGULAR
-
// The general strategy for unknown fields is to use an UnknownFieldSetLite that is treated as
// mutable during the parsing constructor and immutable after. This allows us to avoid
// any unnecessary intermediary allocations while reducing the generated code size.
@@ -223,13 +167,7 @@
/** Called by subclasses to complete parsing. For use by generated code only. */
protected void makeImmutable() {
- // BEGIN REGULAR
- dynamicMethod(MethodToInvoke.MAKE_IMMUTABLE);
- unknownFields.makeImmutable();
- // END REGULAR
- // BEGIN EXPERIMENTAL
- // Protobuf.getInstance().schemaFor(this).makeImmutable(this);
- // END EXPERIMENTAL
+ Protobuf.getInstance().schemaFor(this).makeImmutable(this);
}
protected final <
@@ -266,17 +204,12 @@
* <p>For use by generated code only.
*/
public static enum MethodToInvoke {
- // BEGIN REGULAR
- IS_INITIALIZED,
- VISIT,
- MERGE_FROM_STREAM,
- MAKE_IMMUTABLE,
- // END REGULAR
// Rely on/modify instance state
GET_MEMOIZED_IS_INITIALIZED,
SET_MEMOIZED_IS_INITIALIZED,
// Rely on static state
+ BUILD_MESSAGE_INFO,
NEW_MUTABLE_INSTANCE,
NEW_BUILDER,
GET_DEFAULT_INSTANCE,
@@ -290,10 +223,6 @@
* count.
*
* <ul>
- * <li>{@code MERGE_FROM_STREAM} is parameterized with an {@link CodedInputStream} and {@link
- * ExtensionRegistryLite}. It consumes the input stream, parsing the contents into the
- * returned protocol buffer. If parsing throws an {@link InvalidProtocolBufferException},
- * the implementation wraps it in a RuntimeException.
* <li>{@code NEW_INSTANCE} returns a new instance of the protocol buffer that has not yet been
* made immutable. See {@code MAKE_IMMUTABLE}.
* <li>{@code IS_INITIALIZED} returns {@code null} for false and the default instance for true.
@@ -303,9 +232,6 @@
* <li>{@code SET_MEMOIZED_IS_INITIALIZED} sets the memoized {@code isInitilaized} byte value to
* 1 if the first parameter is not null, or to 0 if the first parameter is null.
* <li>{@code NEW_BUILDER} returns a {@code BuilderType} instance.
- * <li>{@code VISIT} is parameterized with a {@code Visitor} and a {@code MessageType} and
- * recursively iterates through the fields side by side between this and the instance.
- * <li>{@code MAKE_IMMUTABLE} sets all internal fields to an immutable state.
* </ul>
*
* This method, plus the implementation of the Builder, enables the Builder class to be proguarded
@@ -325,13 +251,6 @@
return dynamicMethod(method, null, null);
}
- // BEGIN REGULAR
- void visit(Visitor visitor, MessageType other) {
- dynamicMethod(MethodToInvoke.VISIT, visitor, other);
- unknownFields = visitor.visitUnknownFields(unknownFields, other.unknownFields);
- }
- // END REGULAR
-
@Override
int getMemoizedSerializedSize() {
return memoizedSerializedSize;
@@ -342,7 +261,60 @@
memoizedSerializedSize = size;
}
+ public void writeTo(CodedOutputStream output) throws IOException {
+ writeToInternal(output);
+ }
+ public int getSerializedSize() {
+ if (memoizedSerializedSize == -1) {
+ memoizedSerializedSize = getSerializedSizeInternal();
+ }
+ return memoizedSerializedSize;
+ }
+
+ /** Constructs a {@link MessageInfo} for this message type. */
+ Object buildMessageInfo() throws Exception {
+ return dynamicMethod(MethodToInvoke.BUILD_MESSAGE_INFO);
+ }
+
+ private static Map<Object, GeneratedMessageLite<?, ?>> defaultInstanceMap =
+ new ConcurrentHashMap<Object, GeneratedMessageLite<?, ?>>();
+
+ @SuppressWarnings("unchecked")
+ static <T extends GeneratedMessageLite<?, ?>> T getDefaultInstance(Class<T> clazz) {
+ T result = (T) defaultInstanceMap.get(clazz);
+ if (result == null) {
+ // Foo.class does not initialize the class so we need to force the initialization in order to
+ // get the default instance registered.
+ try {
+ Class.forName(clazz.getName(), true, clazz.getClassLoader());
+ } catch (ClassNotFoundException e) {
+ throw new IllegalStateException("Class initialization cannot fail.", e);
+ }
+ result = (T) defaultInstanceMap.get(clazz);
+ }
+ if (result == null) {
+ // On some Samsung devices, this still doesn't return a valid value for some reason. We add a
+ // reflective fallback to keep the device running. See b/114675342.
+ result = (T) UnsafeUtil.allocateInstance(clazz).getDefaultInstanceForType();
+ // A sanity check to ensure that <clinit> was actually invoked.
+ if (result == null) {
+ throw new IllegalStateException();
+ }
+ defaultInstanceMap.put(clazz, result);
+ }
+ return result;
+ }
+
+ protected static <T extends GeneratedMessageLite<?, ?>> void registerDefaultInstance(
+ Class<T> clazz, T defaultInstance) {
+ defaultInstanceMap.put(clazz, defaultInstance);
+ }
+
+ protected static Object newMessageInfo(
+ MessageLite defaultInstance, String info, Object[] objects) {
+ return new RawMessageInfo(defaultInstance, info, objects);
+ }
/**
* Merge some unknown fields into the {@link UnknownFieldSetLite} for this message.
@@ -437,12 +409,7 @@
}
private void mergeFromInstance(MessageType dest, MessageType src) {
- // BEGIN EXPERIMENTAL
- // Protobuf.getInstance().schemaFor(dest).mergeFrom(dest, src);
- // END EXPERIMENTAL
- // BEGIN REGULAR
- dest.visit(MergeFromVisitor.INSTANCE, src);
- // END REGULAR
+ Protobuf.getInstance().schemaFor(dest).mergeFrom(dest, src);
}
@Override
@@ -454,36 +421,26 @@
public BuilderType mergeFrom(
byte[] input, int offset, int length, ExtensionRegistryLite extensionRegistry)
throws InvalidProtocolBufferException {
- // BEGIN REGULAR
- return super.mergeFrom(input, offset, length, extensionRegistry);
- // END REGULAR
- // BEGIN EXPERIMENTAL
- // copyOnWrite();
- // try {
- // Protobuf.getInstance().schemaFor(instance).mergeFrom(
- // instance, input, offset, offset + length,
- // new ArrayDecoders.Registers(extensionRegistry));
- // } catch (InvalidProtocolBufferException e) {
- // throw e;
- // } catch (IndexOutOfBoundsException e) {
- // throw InvalidProtocolBufferException.truncatedMessage();
- // } catch (IOException e) {
- // throw new RuntimeException("Reading from byte array should not throw IOException.", e);
- // }
- // return (BuilderType) this;
- // END EXPERIMENTAL
+ copyOnWrite();
+ try {
+ Protobuf.getInstance().schemaFor(instance).mergeFrom(
+ instance, input, offset, offset + length,
+ new ArrayDecoders.Registers(extensionRegistry));
+ } catch (InvalidProtocolBufferException e) {
+ throw e;
+ } catch (IndexOutOfBoundsException e) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ } catch (IOException e) {
+ throw new RuntimeException("Reading from byte array should not throw IOException.", e);
+ }
+ return (BuilderType) this;
}
@Override
public BuilderType mergeFrom(
byte[] input, int offset, int length)
throws InvalidProtocolBufferException {
- // BEGIN REGULAR
- return super.mergeFrom(input, offset, length);
- // END REGULAR
- // BEGIN EXPERIMENTAL
- // return mergeFrom(input, offset, length, ExtensionRegistryLite.getEmptyRegistry());
- // END EXPERIMENTAL
+ return mergeFrom(input, offset, length, ExtensionRegistryLite.getEmptyRegistry());
}
@Override
@@ -493,15 +450,10 @@
throws IOException {
copyOnWrite();
try {
- // BEGIN REGULAR
- instance.dynamicMethod(MethodToInvoke.MERGE_FROM_STREAM, input, extensionRegistry);
- // END REGULAR
- // BEGIN EXPERIMENTAL
- // // TODO(yilunchong): Try to make input with type CodedInpuStream.ArrayDecoder use
- // // fast path.
- // Protobuf.getInstance().schemaFor(instance).mergeFrom(
- // instance, CodedInputStreamReader.forCodedInput(input), extensionRegistry);
- // END EXPERIMENTAL
+ // TODO(yilunchong): Try to make input with type CodedInpuStream.ArrayDecoder use
+ // fast path.
+ Protobuf.getInstance().schemaFor(instance).mergeFrom(
+ instance, CodedInputStreamReader.forCodedInput(input), extensionRegistry);
} catch (RuntimeException e) {
if (e.getCause() instanceof IOException) {
throw (IOException) e.getCause();
@@ -553,14 +505,6 @@
extensions.mergeFrom(((ExtendableMessage) other).extensions);
}
- // BEGIN REGULAR
- @Override
- final void visit(Visitor visitor, MessageType other) {
- super.visit(visitor, other);
- extensions = visitor.visitExtensions(extensions, other.extensions);
- }
- // END REGULAR
-
/**
* Parse an unknown field or an extension. For use by generated code only.
*
@@ -898,14 +842,6 @@
return extensions.isInitialized();
}
- @Override
- protected final void makeImmutable() {
- super.makeImmutable();
- // BEGIN REGULAR
- extensions.makeImmutable();
- // END REGULAR
- }
-
/**
* Used by subclasses to serialize extensions. Extension ranges may be interleaved with field
* numbers, but we must write them in canonical (sorted by field number) order. ExtensionWriter
@@ -1479,13 +1415,7 @@
if (memoizedIsInitialized == 0) {
return false;
}
- // BEGIN EXPERIMENTAL
- // boolean isInitialized = Protobuf.getInstance().schemaFor(message).isInitialized(message);
- // END EXPERIMENTAL
- // BEGIN REGULAR
- boolean isInitialized =
- message.dynamicMethod(MethodToInvoke.IS_INITIALIZED, Boolean.FALSE) != null;
- // END REGULAR
+ boolean isInitialized = Protobuf.getInstance().schemaFor(message).isInitialized(message);
if (shouldMemoize) {
message.dynamicMethod(
MethodToInvoke.SET_MEMOIZED_IS_INITIALIZED, isInitialized ? message : null);
@@ -1593,23 +1523,16 @@
@SuppressWarnings("unchecked") // Guaranteed by protoc
T result = (T) instance.dynamicMethod(MethodToInvoke.NEW_MUTABLE_INSTANCE);
try {
- // BEGIN REGULAR
- result.dynamicMethod(MethodToInvoke.MERGE_FROM_STREAM, input, extensionRegistry);
- // END REGULAR
- // BEGIN EXPERIMENTAL
- // // TODO(yilunchong): Try to make input with type CodedInpuStream.ArrayDecoder use
- // // fast path.
- // Protobuf.getInstance().schemaFor(result).mergeFrom(
- // result, CodedInputStreamReader.forCodedInput(input), extensionRegistry);
- // END EXPERIMENTAL
+ // TODO(yilunchong): Try to make input with type CodedInpuStream.ArrayDecoder use
+ // fast path.
+ Protobuf.getInstance().schemaFor(result).mergeFrom(
+ result, CodedInputStreamReader.forCodedInput(input), extensionRegistry);
result.makeImmutable();
- // BEGIN EXPERIMENTAL
- // } catch (IOException e) {
- // if (e.getCause() instanceof InvalidProtocolBufferException) {
- // throw (InvalidProtocolBufferException) e.getCause();
- // }
- // throw new InvalidProtocolBufferException(e.getMessage()).setUnfinishedMessage(result);
- // END EXPERIMENTAL
+ } catch (IOException e) {
+ if (e.getCause() instanceof InvalidProtocolBufferException) {
+ throw (InvalidProtocolBufferException) e.getCause();
+ }
+ throw new InvalidProtocolBufferException(e.getMessage()).setUnfinishedMessage(result);
} catch (RuntimeException e) {
if (e.getCause() instanceof InvalidProtocolBufferException) {
throw (InvalidProtocolBufferException) e.getCause();
@@ -1623,42 +1546,25 @@
static <T extends GeneratedMessageLite<T, ?>> T parsePartialFrom(
T instance, byte[] input, int offset, int length, ExtensionRegistryLite extensionRegistry)
throws InvalidProtocolBufferException {
- // BEGIN REGULAR
- T message;
+ @SuppressWarnings("unchecked") // Guaranteed by protoc
+ T result = (T) instance.dynamicMethod(MethodToInvoke.NEW_MUTABLE_INSTANCE);
try {
- CodedInputStream cis = CodedInputStream.newInstance(input, offset, length);
- message = parsePartialFrom(instance, cis, extensionRegistry);
- try {
- cis.checkLastTagWas(0);
- } catch (InvalidProtocolBufferException e) {
- throw e.setUnfinishedMessage(message);
+ Protobuf.getInstance().schemaFor(result).mergeFrom(
+ result, input, offset, offset + length,
+ new ArrayDecoders.Registers(extensionRegistry));
+ result.makeImmutable();
+ if (result.memoizedHashCode != 0) {
+ throw new RuntimeException();
}
- return message;
- } catch (InvalidProtocolBufferException e) {
- throw e;
+ } catch (IOException e) {
+ if (e.getCause() instanceof InvalidProtocolBufferException) {
+ throw (InvalidProtocolBufferException) e.getCause();
+ }
+ throw new InvalidProtocolBufferException(e.getMessage()).setUnfinishedMessage(result);
+ } catch (IndexOutOfBoundsException e) {
+ throw InvalidProtocolBufferException.truncatedMessage().setUnfinishedMessage(result);
}
- // END REGULAR
- // BEGIN EXPERIMENTAL
- // @SuppressWarnings("unchecked") // Guaranteed by protoc
- // T result = (T) instance.dynamicMethod(MethodToInvoke.NEW_MUTABLE_INSTANCE);
- // try {
- // Protobuf.getInstance().schemaFor(result).mergeFrom(
- // result, input, offset, offset + length,
- // new ArrayDecoders.Registers(extensionRegistry));
- // result.makeImmutable();
- // if (result.memoizedHashCode != 0) {
- // throw new RuntimeException();
- // }
- // } catch (IOException e) {
- // if (e.getCause() instanceof InvalidProtocolBufferException) {
- // throw (InvalidProtocolBufferException) e.getCause();
- // }
- // throw new InvalidProtocolBufferException(e.getMessage()).setUnfinishedMessage(result);
- // } catch (IndexOutOfBoundsException e) {
- // throw InvalidProtocolBufferException.truncatedMessage().setUnfinishedMessage(result);
- // }
- // return result;
- // END EXPERIMENTAL
+ return result;
}
protected static <T extends GeneratedMessageLite<T, ?>> T parsePartialFrom(
@@ -1825,701 +1731,4 @@
}
return message;
}
-
- // BEGIN REGULAR
- /**
- * An abstract visitor that the generated code calls into that we use to implement various
- * features. Fields that are not members of oneofs are always visited. Members of a oneof are only
- * visited when they are the set oneof case value on the "other" proto. The visitOneofNotSet
- * method is invoked if other's oneof case is not set.
- */
- protected interface Visitor {
- boolean visitBoolean(boolean minePresent, boolean mine, boolean otherPresent, boolean other);
-
- int visitInt(boolean minePresent, int mine, boolean otherPresent, int other);
-
- double visitDouble(boolean minePresent, double mine, boolean otherPresent, double other);
-
- float visitFloat(boolean minePresent, float mine, boolean otherPresent, float other);
-
- long visitLong(boolean minePresent, long mine, boolean otherPresent, long other);
-
- String visitString(boolean minePresent, String mine, boolean otherPresent, String other);
-
- ByteString visitByteString(
- boolean minePresent, ByteString mine, boolean otherPresent, ByteString other);
-
- Object visitOneofBoolean(boolean minePresent, Object mine, Object other);
-
- Object visitOneofInt(boolean minePresent, Object mine, Object other);
-
- Object visitOneofDouble(boolean minePresent, Object mine, Object other);
-
- Object visitOneofFloat(boolean minePresent, Object mine, Object other);
-
- Object visitOneofLong(boolean minePresent, Object mine, Object other);
-
- Object visitOneofString(boolean minePresent, Object mine, Object other);
-
- Object visitOneofByteString(boolean minePresent, Object mine, Object other);
-
- Object visitOneofMessage(boolean minePresent, Object mine, Object other);
-
- void visitOneofNotSet(boolean minePresent);
-
- /** Message fields use null sentinals. */
- <T extends MessageLite> T visitMessage(T mine, T other);
-
- <T> ProtobufList<T> visitList(ProtobufList<T> mine, ProtobufList<T> other);
-
- BooleanList visitBooleanList(BooleanList mine, BooleanList other);
-
- IntList visitIntList(IntList mine, IntList other);
-
- DoubleList visitDoubleList(DoubleList mine, DoubleList other);
-
- FloatList visitFloatList(FloatList mine, FloatList other);
-
- LongList visitLongList(LongList mine, LongList other);
-
- FieldSet<ExtensionDescriptor> visitExtensions(
- FieldSet<ExtensionDescriptor> mine, FieldSet<ExtensionDescriptor> other);
-
- UnknownFieldSetLite visitUnknownFields(UnknownFieldSetLite mine, UnknownFieldSetLite other);
-
- <K, V> MapFieldLite<K, V> visitMap(MapFieldLite<K, V> mine, MapFieldLite<K, V> other);
- }
-
- /** Implements equals. Throws a {@link NotEqualsException} when not equal. */
- static class EqualsVisitor implements Visitor {
-
- static final class NotEqualsException extends RuntimeException {}
-
- static final EqualsVisitor INSTANCE = new EqualsVisitor();
-
- static final NotEqualsException NOT_EQUALS = new NotEqualsException();
-
- private EqualsVisitor() {}
-
- @Override
- public boolean visitBoolean(
- boolean minePresent, boolean mine, boolean otherPresent, boolean other) {
- if (minePresent != otherPresent || mine != other) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public int visitInt(boolean minePresent, int mine, boolean otherPresent, int other) {
- if (minePresent != otherPresent || mine != other) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public double visitDouble(
- boolean minePresent, double mine, boolean otherPresent, double other) {
- if (minePresent != otherPresent || mine != other) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public float visitFloat(boolean minePresent, float mine, boolean otherPresent, float other) {
- if (minePresent != otherPresent || mine != other) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public long visitLong(boolean minePresent, long mine, boolean otherPresent, long other) {
- if (minePresent != otherPresent || mine != other) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public String visitString(
- boolean minePresent, String mine, boolean otherPresent, String other) {
- if (minePresent != otherPresent || !mine.equals(other)) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public ByteString visitByteString(
- boolean minePresent, ByteString mine, boolean otherPresent, ByteString other) {
- if (minePresent != otherPresent || !mine.equals(other)) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public Object visitOneofBoolean(boolean minePresent, Object mine, Object other) {
- if (minePresent && mine.equals(other)) {
- return mine;
- }
- throw NOT_EQUALS;
- }
-
- @Override
- public Object visitOneofInt(boolean minePresent, Object mine, Object other) {
- if (minePresent && mine.equals(other)) {
- return mine;
- }
- throw NOT_EQUALS;
- }
-
- @Override
- public Object visitOneofDouble(boolean minePresent, Object mine, Object other) {
- if (minePresent && mine.equals(other)) {
- return mine;
- }
- throw NOT_EQUALS;
- }
-
- @Override
- public Object visitOneofFloat(boolean minePresent, Object mine, Object other) {
- if (minePresent && mine.equals(other)) {
- return mine;
- }
- throw NOT_EQUALS;
- }
-
- @Override
- public Object visitOneofLong(boolean minePresent, Object mine, Object other) {
- if (minePresent && mine.equals(other)) {
- return mine;
- }
- throw NOT_EQUALS;
- }
-
- @Override
- public Object visitOneofString(boolean minePresent, Object mine, Object other) {
- if (minePresent && mine.equals(other)) {
- return mine;
- }
- throw NOT_EQUALS;
- }
-
- @Override
- public Object visitOneofByteString(boolean minePresent, Object mine, Object other) {
- if (minePresent && mine.equals(other)) {
- return mine;
- }
- throw NOT_EQUALS;
- }
-
- @Override
- public Object visitOneofMessage(boolean minePresent, Object mine, Object other) {
- if (minePresent && ((GeneratedMessageLite<?, ?>) mine).equals(this, (MessageLite) other)) {
- return mine;
- }
- throw NOT_EQUALS;
- }
-
- @Override
- public void visitOneofNotSet(boolean minePresent) {
- if (minePresent) {
- throw NOT_EQUALS;
- }
- }
-
- @Override
- public <T extends MessageLite> T visitMessage(T mine, T other) {
- if (mine == null && other == null) {
- return null;
- }
-
- if (mine == null || other == null) {
- throw NOT_EQUALS;
- }
-
- ((GeneratedMessageLite<?, ?>) mine).equals(this, other);
-
- return mine;
- }
-
- @Override
- public <T> ProtobufList<T> visitList(ProtobufList<T> mine, ProtobufList<T> other) {
- if (!mine.equals(other)) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public BooleanList visitBooleanList(BooleanList mine, BooleanList other) {
- if (!mine.equals(other)) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public IntList visitIntList(IntList mine, IntList other) {
- if (!mine.equals(other)) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public DoubleList visitDoubleList(DoubleList mine, DoubleList other) {
- if (!mine.equals(other)) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public FloatList visitFloatList(FloatList mine, FloatList other) {
- if (!mine.equals(other)) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public LongList visitLongList(LongList mine, LongList other) {
- if (!mine.equals(other)) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public FieldSet<ExtensionDescriptor> visitExtensions(
- FieldSet<ExtensionDescriptor> mine, FieldSet<ExtensionDescriptor> other) {
- if (!mine.equals(other)) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public UnknownFieldSetLite visitUnknownFields(
- UnknownFieldSetLite mine, UnknownFieldSetLite other) {
- if (!mine.equals(other)) {
- throw NOT_EQUALS;
- }
- return mine;
- }
-
- @Override
- public <K, V> MapFieldLite<K, V> visitMap(MapFieldLite<K, V> mine, MapFieldLite<K, V> other) {
- if (!mine.equals(other)) {
- throw NOT_EQUALS;
- }
- return mine;
- }
- }
-
- /** Implements hashCode by accumulating state. */
- static class HashCodeVisitor implements Visitor {
-
- // The caller must ensure that the visitor is invoked parameterized with this and this such that
- // other is this. This is required due to how oneof cases are handled. See the class comment
- // on Visitor for more information.
-
- int hashCode = 0;
-
- @Override
- public boolean visitBoolean(
- boolean minePresent, boolean mine, boolean otherPresent, boolean other) {
- hashCode = (53 * hashCode) + Internal.hashBoolean(mine);
- return mine;
- }
-
- @Override
- public int visitInt(boolean minePresent, int mine, boolean otherPresent, int other) {
- hashCode = (53 * hashCode) + mine;
- return mine;
- }
-
- @Override
- public double visitDouble(
- boolean minePresent, double mine, boolean otherPresent, double other) {
- hashCode = (53 * hashCode) + Internal.hashLong(Double.doubleToLongBits(mine));
- return mine;
- }
-
- @Override
- public float visitFloat(boolean minePresent, float mine, boolean otherPresent, float other) {
- hashCode = (53 * hashCode) + Float.floatToIntBits(mine);
- return mine;
- }
-
- @Override
- public long visitLong(boolean minePresent, long mine, boolean otherPresent, long other) {
- hashCode = (53 * hashCode) + Internal.hashLong(mine);
- return mine;
- }
-
- @Override
- public String visitString(
- boolean minePresent, String mine, boolean otherPresent, String other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public ByteString visitByteString(
- boolean minePresent, ByteString mine, boolean otherPresent, ByteString other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public Object visitOneofBoolean(boolean minePresent, Object mine, Object other) {
- hashCode = (53 * hashCode) + Internal.hashBoolean(((Boolean) mine));
- return mine;
- }
-
- @Override
- public Object visitOneofInt(boolean minePresent, Object mine, Object other) {
- hashCode = (53 * hashCode) + (Integer) mine;
- return mine;
- }
-
- @Override
- public Object visitOneofDouble(boolean minePresent, Object mine, Object other) {
- hashCode = (53 * hashCode) + Internal.hashLong(Double.doubleToLongBits((Double) mine));
- return mine;
- }
-
- @Override
- public Object visitOneofFloat(boolean minePresent, Object mine, Object other) {
- hashCode = (53 * hashCode) + Float.floatToIntBits((Float) mine);
- return mine;
- }
-
- @Override
- public Object visitOneofLong(boolean minePresent, Object mine, Object other) {
- hashCode = (53 * hashCode) + Internal.hashLong((Long) mine);
- return mine;
- }
-
- @Override
- public Object visitOneofString(boolean minePresent, Object mine, Object other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public Object visitOneofByteString(boolean minePresent, Object mine, Object other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public Object visitOneofMessage(boolean minePresent, Object mine, Object other) {
- return visitMessage((MessageLite) mine, (MessageLite) other);
- }
-
- @Override
- public void visitOneofNotSet(boolean minePresent) {
- if (minePresent) {
- throw new IllegalStateException(); // Can't happen if other == this.
- }
- }
-
- @Override
- public <T extends MessageLite> T visitMessage(T mine, T other) {
- final int protoHash;
- if (mine != null) {
- if (mine instanceof GeneratedMessageLite) {
- protoHash = ((GeneratedMessageLite) mine).hashCode(this);
- } else {
- protoHash = mine.hashCode();
- }
- } else {
- protoHash = 37;
- }
- hashCode = (53 * hashCode) + protoHash;
- return mine;
- }
-
- @Override
- public <T> ProtobufList<T> visitList(ProtobufList<T> mine, ProtobufList<T> other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public BooleanList visitBooleanList(BooleanList mine, BooleanList other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public IntList visitIntList(IntList mine, IntList other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public DoubleList visitDoubleList(DoubleList mine, DoubleList other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public FloatList visitFloatList(FloatList mine, FloatList other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public LongList visitLongList(LongList mine, LongList other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public FieldSet<ExtensionDescriptor> visitExtensions(
- FieldSet<ExtensionDescriptor> mine, FieldSet<ExtensionDescriptor> other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public UnknownFieldSetLite visitUnknownFields(
- UnknownFieldSetLite mine, UnknownFieldSetLite other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
-
- @Override
- public <K, V> MapFieldLite<K, V> visitMap(MapFieldLite<K, V> mine, MapFieldLite<K, V> other) {
- hashCode = (53 * hashCode) + mine.hashCode();
- return mine;
- }
- }
-
- /** Implements field merging semantics over the visitor interface. */
- protected static class MergeFromVisitor implements Visitor {
-
- public static final MergeFromVisitor INSTANCE = new MergeFromVisitor();
-
- private MergeFromVisitor() {}
-
- @Override
- public boolean visitBoolean(
- boolean minePresent, boolean mine, boolean otherPresent, boolean other) {
- return otherPresent ? other : mine;
- }
-
- @Override
- public int visitInt(boolean minePresent, int mine, boolean otherPresent, int other) {
- return otherPresent ? other : mine;
- }
-
- @Override
- public double visitDouble(
- boolean minePresent, double mine, boolean otherPresent, double other) {
- return otherPresent ? other : mine;
- }
-
- @Override
- public float visitFloat(boolean minePresent, float mine, boolean otherPresent, float other) {
- return otherPresent ? other : mine;
- }
-
- @Override
- public long visitLong(boolean minePresent, long mine, boolean otherPresent, long other) {
- return otherPresent ? other : mine;
- }
-
- @Override
- public String visitString(
- boolean minePresent, String mine, boolean otherPresent, String other) {
- return otherPresent ? other : mine;
- }
-
- @Override
- public ByteString visitByteString(
- boolean minePresent, ByteString mine, boolean otherPresent, ByteString other) {
- return otherPresent ? other : mine;
- }
-
- @Override
- public Object visitOneofBoolean(boolean minePresent, Object mine, Object other) {
- return other;
- }
-
- @Override
- public Object visitOneofInt(boolean minePresent, Object mine, Object other) {
- return other;
- }
-
- @Override
- public Object visitOneofDouble(boolean minePresent, Object mine, Object other) {
- return other;
- }
-
- @Override
- public Object visitOneofFloat(boolean minePresent, Object mine, Object other) {
- return other;
- }
-
- @Override
- public Object visitOneofLong(boolean minePresent, Object mine, Object other) {
- return other;
- }
-
- @Override
- public Object visitOneofString(boolean minePresent, Object mine, Object other) {
- return other;
- }
-
- @Override
- public Object visitOneofByteString(boolean minePresent, Object mine, Object other) {
- return other;
- }
-
- @Override
- public Object visitOneofMessage(boolean minePresent, Object mine, Object other) {
- if (minePresent) {
- return visitMessage((MessageLite) mine, (MessageLite) other);
- }
- return other;
- }
-
- @Override
- public void visitOneofNotSet(boolean minePresent) {
- return;
- }
-
- @SuppressWarnings("unchecked") // Guaranteed by runtime.
- @Override
- public <T extends MessageLite> T visitMessage(T mine, T other) {
- if (mine != null && other != null) {
- return (T) mine.toBuilder().mergeFrom(other).build();
- }
-
- return mine != null ? mine : other;
- }
-
- @Override
- public <T> ProtobufList<T> visitList(ProtobufList<T> mine, ProtobufList<T> other) {
- int size = mine.size();
- int otherSize = other.size();
- if (size > 0 && otherSize > 0) {
- if (!mine.isModifiable()) {
- mine = mine.mutableCopyWithCapacity(size + otherSize);
- }
- mine.addAll(other);
- }
-
- return size > 0 ? mine : other;
- }
-
- @Override
- public BooleanList visitBooleanList(BooleanList mine, BooleanList other) {
- int size = mine.size();
- int otherSize = other.size();
- if (size > 0 && otherSize > 0) {
- if (!mine.isModifiable()) {
- mine = mine.mutableCopyWithCapacity(size + otherSize);
- }
- mine.addAll(other);
- }
-
- return size > 0 ? mine : other;
- }
-
- @Override
- public IntList visitIntList(IntList mine, IntList other) {
- int size = mine.size();
- int otherSize = other.size();
- if (size > 0 && otherSize > 0) {
- if (!mine.isModifiable()) {
- mine = mine.mutableCopyWithCapacity(size + otherSize);
- }
- mine.addAll(other);
- }
-
- return size > 0 ? mine : other;
- }
-
- @Override
- public DoubleList visitDoubleList(DoubleList mine, DoubleList other) {
- int size = mine.size();
- int otherSize = other.size();
- if (size > 0 && otherSize > 0) {
- if (!mine.isModifiable()) {
- mine = mine.mutableCopyWithCapacity(size + otherSize);
- }
- mine.addAll(other);
- }
-
- return size > 0 ? mine : other;
- }
-
- @Override
- public FloatList visitFloatList(FloatList mine, FloatList other) {
- int size = mine.size();
- int otherSize = other.size();
- if (size > 0 && otherSize > 0) {
- if (!mine.isModifiable()) {
- mine = mine.mutableCopyWithCapacity(size + otherSize);
- }
- mine.addAll(other);
- }
-
- return size > 0 ? mine : other;
- }
-
- @Override
- public LongList visitLongList(LongList mine, LongList other) {
- int size = mine.size();
- int otherSize = other.size();
- if (size > 0 && otherSize > 0) {
- if (!mine.isModifiable()) {
- mine = mine.mutableCopyWithCapacity(size + otherSize);
- }
- mine.addAll(other);
- }
-
- return size > 0 ? mine : other;
- }
-
- @Override
- public FieldSet<ExtensionDescriptor> visitExtensions(
- FieldSet<ExtensionDescriptor> mine, FieldSet<ExtensionDescriptor> other) {
- if (mine.isImmutable()) {
- mine = mine.clone();
- }
- mine.mergeFrom(other);
- return mine;
- }
-
- @Override
- public UnknownFieldSetLite visitUnknownFields(
- UnknownFieldSetLite mine, UnknownFieldSetLite other) {
- return other == UnknownFieldSetLite.getDefaultInstance()
- ? mine
- : UnknownFieldSetLite.mutableCopyOf(mine, other);
- }
-
- @Override
- public <K, V> MapFieldLite<K, V> visitMap(MapFieldLite<K, V> mine, MapFieldLite<K, V> other) {
- if (!other.isEmpty()) {
- if (!mine.isMutable()) {
- mine = mine.mutableCopy();
- }
- mine.mergeFrom(other);
- }
- return mine;
- }
- }
- // END REGULAR
}
diff --git a/java/core/src/main/java/com/google/protobuf/GeneratedMessageV3.java b/java/core/src/main/java/com/google/protobuf/GeneratedMessageV3.java
index e9eb34f..0ed7243 100644
--- a/java/core/src/main/java/com/google/protobuf/GeneratedMessageV3.java
+++ b/java/core/src/main/java/com/google/protobuf/GeneratedMessageV3.java
@@ -459,6 +459,29 @@
/**
+ * This class is used to make a generated protected method inaccessible from user's code (e.g.,
+ * the {@link #newInstance} method below). When this class is used as a parameter's type in a
+ * generated protected method, the method is visible to user's code in the same package, but
+ * since the constructor of this class is private to protobuf runtime, user's code can't obtain
+ * an instance of this class and as such can't actually make a method call on the protected
+ * method.
+ */
+ protected static final class UnusedPrivateParameter {
+ static final UnusedPrivateParameter INSTANCE = new UnusedPrivateParameter();
+
+ private UnusedPrivateParameter() {
+ }
+ }
+
+ /**
+ * Creates a new instance of this message type. Overridden in the generated code.
+ */
+ @SuppressWarnings({"unused"})
+ protected Object newInstance(UnusedPrivateParameter unused) {
+ throw new UnsupportedOperationException("This method must be overridden by the subclass.");
+ }
+
+ /**
* Used by parsing constructors in generated classes.
*/
protected void makeExtensionsImmutable() {
diff --git a/java/core/src/main/java/com/google/protobuf/Internal.java b/java/core/src/main/java/com/google/protobuf/Internal.java
index 713ccb5..15deb37 100644
--- a/java/core/src/main/java/com/google/protobuf/Internal.java
+++ b/java/core/src/main/java/com/google/protobuf/Internal.java
@@ -540,6 +540,24 @@
}
return valueConverter.doForward(oldValue);
}
+
+ @Override
+ public boolean equals(Object o) {
+ if (o == this) {
+ return true;
+ }
+ if (!(o instanceof Map.Entry)) {
+ return false;
+ }
+ @SuppressWarnings("unchecked")
+ Map.Entry<?, ?> other = (Map.Entry<?, ?>) o;
+ return getKey().equals(other.getKey()) && getValue().equals(getValue());
+ }
+
+ @Override
+ public int hashCode() {
+ return realEntry.hashCode();
+ }
}
}
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 100755
index 0000000..770aa9e
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/JavaType.java
@@ -0,0 +1,76 @@
+// 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/LazyFieldLite.java b/java/core/src/main/java/com/google/protobuf/LazyFieldLite.java
index 5651e13..d6b594d 100644
--- a/java/core/src/main/java/com/google/protobuf/LazyFieldLite.java
+++ b/java/core/src/main/java/com/google/protobuf/LazyFieldLite.java
@@ -388,6 +388,18 @@
}
}
+ /** Writes this lazy field into a {@link Writer}. */
+ void writeTo(Writer writer, int fieldNumber) throws IOException {
+ if (memoizedBytes != null) {
+ writer.writeBytes(fieldNumber, memoizedBytes);
+ } else if (delayedBytes != null) {
+ writer.writeBytes(fieldNumber, delayedBytes);
+ } else if (value != null) {
+ writer.writeMessage(fieldNumber, value);
+ } else {
+ writer.writeBytes(fieldNumber, ByteString.EMPTY);
+ }
+ }
/** Might lazily parse the bytes that were previously passed in. Is thread-safe. */
protected void ensureInitialized(MessageLite defaultInstance) {
diff --git a/java/core/src/main/java/com/google/protobuf/ListFieldSchema.java b/java/core/src/main/java/com/google/protobuf/ListFieldSchema.java
new file mode 100755
index 0000000..ebc8561
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/ListFieldSchema.java
@@ -0,0 +1,190 @@
+// 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.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Utility class that aids in properly manipulating list fields for either the lite or full runtime.
+ */
+abstract class ListFieldSchema {
+ // Disallow construction.
+ private ListFieldSchema() {}
+
+ private static final ListFieldSchema FULL_INSTANCE = new ListFieldSchemaFull();
+ private static final ListFieldSchema LITE_INSTANCE = new ListFieldSchemaLite();
+
+ abstract <L> List<L> mutableListAt(Object msg, long offset);
+
+ abstract void makeImmutableListAt(Object msg, long offset);
+
+ abstract <L> void mergeListsAt(Object msg, Object otherMsg, long offset);
+
+ static ListFieldSchema full() {
+ return FULL_INSTANCE;
+ }
+
+ static ListFieldSchema lite() {
+ return LITE_INSTANCE;
+ }
+
+ /** Implementation for the full runtime. */
+ private static final class ListFieldSchemaFull extends ListFieldSchema {
+
+ private static final Class<?> UNMODIFIABLE_LIST_CLASS =
+ Collections.unmodifiableList(Collections.emptyList()).getClass();
+
+ @Override
+ <L> List<L> mutableListAt(Object message, long offset) {
+ return mutableListAt(message, offset, AbstractProtobufList.DEFAULT_CAPACITY);
+ }
+
+ @Override
+ void makeImmutableListAt(Object message, long offset) {
+ List<?> list = (List<?>) UnsafeUtil.getObject(message, offset);
+ Object immutable = null;
+ if (list instanceof LazyStringList) {
+ immutable = ((LazyStringList) list).getUnmodifiableView();
+ } else if (UNMODIFIABLE_LIST_CLASS.isAssignableFrom(list.getClass())) {
+ // already immutable
+ return;
+ } else if (list instanceof PrimitiveNonBoxingCollection && list instanceof ProtobufList) {
+ if (((ProtobufList<?>) list).isModifiable()) {
+ ((ProtobufList<?>) list).makeImmutable();
+ }
+ return;
+ } else {
+ immutable = Collections.unmodifiableList((List<?>) list);
+ }
+ UnsafeUtil.putObject(message, offset, immutable);
+ }
+
+ @SuppressWarnings("unchecked")
+ private static <L> List<L> mutableListAt(Object message, long offset, int additionalCapacity) {
+ List<L> list = getList(message, offset);
+ if (list.isEmpty()) {
+ if (list instanceof LazyStringList) {
+ list = (List<L>) new LazyStringArrayList(additionalCapacity);
+ } else if (list instanceof PrimitiveNonBoxingCollection && list instanceof ProtobufList) {
+ list = ((ProtobufList<L>) list).mutableCopyWithCapacity(additionalCapacity);
+ } else {
+ list = new ArrayList<L>(additionalCapacity);
+ }
+ UnsafeUtil.putObject(message, offset, list);
+ } else if (UNMODIFIABLE_LIST_CLASS.isAssignableFrom(list.getClass())) {
+ ArrayList<L> newList = new ArrayList<L>(list.size() + additionalCapacity);
+ newList.addAll(list);
+ list = newList;
+ UnsafeUtil.putObject(message, offset, list);
+ } else if (list instanceof UnmodifiableLazyStringList) {
+ LazyStringArrayList newList = new LazyStringArrayList(list.size() + additionalCapacity);
+ newList.addAll((UnmodifiableLazyStringList) list);
+ list = (List<L>) newList;
+ UnsafeUtil.putObject(message, offset, list);
+ } else if (list instanceof PrimitiveNonBoxingCollection
+ && list instanceof ProtobufList
+ && !((ProtobufList<L>) list).isModifiable()) {
+ list = ((ProtobufList<L>) list).mutableCopyWithCapacity(list.size() + additionalCapacity);
+ UnsafeUtil.putObject(message, offset, list);
+ }
+ return list;
+ }
+
+ @Override
+ <E> void mergeListsAt(Object msg, Object otherMsg, long offset) {
+ List<E> other = getList(otherMsg, offset);
+ List<E> mine = mutableListAt(msg, offset, other.size());
+
+ int size = mine.size();
+ int otherSize = other.size();
+ if (size > 0 && otherSize > 0) {
+ mine.addAll(other);
+ }
+
+ List<E> merged = size > 0 ? mine : other;
+ UnsafeUtil.putObject(msg, offset, merged);
+ }
+
+ @SuppressWarnings("unchecked")
+ static <E> List<E> getList(Object message, long offset) {
+ return (List<E>) UnsafeUtil.getObject(message, offset);
+ }
+ }
+
+ /** Implementation for the lite runtime. */
+ private static final class ListFieldSchemaLite extends ListFieldSchema {
+
+ @Override
+ <L> List<L> mutableListAt(Object message, long offset) {
+ ProtobufList<L> list = getProtobufList(message, offset);
+ if (!list.isModifiable()) {
+ int size = list.size();
+ list =
+ list.mutableCopyWithCapacity(
+ size == 0 ? AbstractProtobufList.DEFAULT_CAPACITY : size * 2);
+ UnsafeUtil.putObject(message, offset, list);
+ }
+ return list;
+ }
+
+ @Override
+ void makeImmutableListAt(Object message, long offset) {
+ ProtobufList<?> list = getProtobufList(message, offset);
+ list.makeImmutable();
+ }
+
+ @Override
+ <E> void mergeListsAt(Object msg, Object otherMsg, long offset) {
+ ProtobufList<E> mine = getProtobufList(msg, offset);
+ ProtobufList<E> other = getProtobufList(otherMsg, offset);
+
+ int size = mine.size();
+ int otherSize = other.size();
+ if (size > 0 && otherSize > 0) {
+ if (!mine.isModifiable()) {
+ mine = mine.mutableCopyWithCapacity(size + otherSize);
+ }
+ mine.addAll(other);
+ }
+
+ ProtobufList<E> merged = size > 0 ? mine : other;
+ UnsafeUtil.putObject(msg, offset, merged);
+ }
+
+ @SuppressWarnings("unchecked")
+ static <E> ProtobufList<E> getProtobufList(Object message, long offset) {
+ return (ProtobufList<E>) UnsafeUtil.getObject(message, offset);
+ }
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/ManifestSchemaFactory.java b/java/core/src/main/java/com/google/protobuf/ManifestSchemaFactory.java
new file mode 100755
index 0000000..84ca9ae
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/ManifestSchemaFactory.java
@@ -0,0 +1,172 @@
+// 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;
+
+/**
+ * Dynamically generates a manifest-based (i.e. table-based) schema for a given protobuf message.
+ */
+@ExperimentalApi
+final class ManifestSchemaFactory implements SchemaFactory {
+
+ private final MessageInfoFactory messageInfoFactory;
+
+ public ManifestSchemaFactory() {
+ this(getDefaultMessageInfoFactory());
+ }
+
+ private ManifestSchemaFactory(MessageInfoFactory messageInfoFactory) {
+ this.messageInfoFactory = checkNotNull(messageInfoFactory, "messageInfoFactory");
+ }
+
+ @Override
+ public <T> Schema<T> createSchema(Class<T> messageType) {
+ SchemaUtil.requireGeneratedMessage(messageType);
+
+ MessageInfo messageInfo = messageInfoFactory.messageInfoFor(messageType);
+
+ // MessageSet has a special schema.
+ if (messageInfo.isMessageSetWireFormat()) {
+ if (GeneratedMessageLite.class.isAssignableFrom(messageType)) {
+ return MessageSetSchema.newSchema(
+ SchemaUtil.unknownFieldSetLiteSchema(),
+ ExtensionSchemas.lite(),
+ messageInfo.getDefaultInstance());
+ }
+ return MessageSetSchema.newSchema(
+ SchemaUtil.proto2UnknownFieldSetSchema(),
+ ExtensionSchemas.full(),
+ messageInfo.getDefaultInstance());
+ }
+
+ return newSchema(messageType, messageInfo);
+ }
+
+ private static <T> Schema<T> newSchema(Class<T> messageType, MessageInfo messageInfo) {
+ if (GeneratedMessageLite.class.isAssignableFrom(messageType)) {
+ return isProto2(messageInfo)
+ ? MessageSchema.newSchema(
+ messageType,
+ messageInfo,
+ NewInstanceSchemas.lite(),
+ ListFieldSchema.lite(),
+ SchemaUtil.unknownFieldSetLiteSchema(),
+ ExtensionSchemas.lite(),
+ MapFieldSchemas.lite())
+ : MessageSchema.newSchema(
+ messageType,
+ messageInfo,
+ NewInstanceSchemas.lite(),
+ ListFieldSchema.lite(),
+ SchemaUtil.unknownFieldSetLiteSchema(),
+ /* extensionSchema= */ null,
+ MapFieldSchemas.lite());
+ }
+ return isProto2(messageInfo)
+ ? MessageSchema.newSchema(
+ messageType,
+ messageInfo,
+ NewInstanceSchemas.full(),
+ ListFieldSchema.full(),
+ SchemaUtil.proto2UnknownFieldSetSchema(),
+ ExtensionSchemas.full(),
+ MapFieldSchemas.full())
+ : MessageSchema.newSchema(
+ messageType,
+ messageInfo,
+ NewInstanceSchemas.full(),
+ ListFieldSchema.full(),
+ SchemaUtil.proto3UnknownFieldSetSchema(),
+ /* extensionSchema= */ null,
+ MapFieldSchemas.full());
+ }
+
+ private static boolean isProto2(MessageInfo messageInfo) {
+ return messageInfo.getSyntax() == ProtoSyntax.PROTO2;
+ }
+
+ private static MessageInfoFactory getDefaultMessageInfoFactory() {
+ return new CompositeMessageInfoFactory(
+ GeneratedMessageInfoFactory.getInstance(), getDescriptorMessageInfoFactory());
+ }
+
+ private static class CompositeMessageInfoFactory implements MessageInfoFactory {
+ private MessageInfoFactory[] factories;
+
+ CompositeMessageInfoFactory(MessageInfoFactory... factories) {
+ this.factories = factories;
+ }
+
+ @Override
+ public boolean isSupported(Class<?> clazz) {
+ for (MessageInfoFactory factory : factories) {
+ if (factory.isSupported(clazz)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public MessageInfo messageInfoFor(Class<?> clazz) {
+ for (MessageInfoFactory factory : factories) {
+ if (factory.isSupported(clazz)) {
+ return factory.messageInfoFor(clazz);
+ }
+ }
+ throw new UnsupportedOperationException(
+ "No factory is available for message type: " + clazz.getName());
+ }
+ }
+
+ private static final MessageInfoFactory EMPTY_FACTORY =
+ new MessageInfoFactory() {
+ @Override
+ public boolean isSupported(Class<?> clazz) {
+ return false;
+ }
+
+ @Override
+ public MessageInfo messageInfoFor(Class<?> clazz) {
+ throw new IllegalStateException("This should never be called.");
+ }
+ };
+
+ private static MessageInfoFactory getDescriptorMessageInfoFactory() {
+ try {
+ Class<?> clazz = Class.forName("com.google.protobuf.DescriptorMessageInfoFactory");
+ return (MessageInfoFactory) clazz.getDeclaredMethod("getInstance").invoke(null);
+ } catch (Exception e) {
+ return EMPTY_FACTORY;
+ }
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/MapFieldSchema.java b/java/core/src/main/java/com/google/protobuf/MapFieldSchema.java
new file mode 100755
index 0000000..195126e
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/MapFieldSchema.java
@@ -0,0 +1,63 @@
+// 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.Map;
+
+interface MapFieldSchema {
+ /** Returns the map data for mutation. */
+ Map<?, ?> forMutableMapData(Object mapField);
+
+ /** Returns the map data for read. */
+ Map<?, ?> forMapData(Object mapField);
+
+ /** Whether toImmutable() has been called on this map field. */
+ boolean isImmutable(Object mapField);
+
+ /**
+ * Returns an immutable instance of the map field. It may make the parameter immutable and return
+ * the parameter, or create an immutable copy. The status of the parameter after the call is
+ * undefined.
+ */
+ Object toImmutable(Object mapField);
+
+ /** Returns a new instance of the map field given a map default entry. */
+ Object newMapField(Object mapDefaultEntry);
+
+ /** Returns the metadata from a default entry. */
+ MapEntryLite.Metadata<?, ?> forMapMetadata(Object mapDefaultEntry);
+
+ /** Merges {@code srcMapField} into {@code destMapField}, and returns the merged instance. */
+ Object mergeFrom(Object destMapField, Object srcMapField);
+
+ /** Compute the serialized size for the map with a given field number. */
+ int getSerializedSize(int fieldNumber, Object mapField, Object mapDefaultEntry);
+}
diff --git a/java/core/src/main/java/com/google/protobuf/MapFieldSchemaFull.java b/java/core/src/main/java/com/google/protobuf/MapFieldSchemaFull.java
new file mode 100755
index 0000000..1efaab3
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/MapFieldSchemaFull.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 com.google.protobuf.MapEntryLite.Metadata;
+import java.util.Map;
+
+class MapFieldSchemaFull implements MapFieldSchema {
+ @Override
+ public Map<?, ?> forMutableMapData(Object mapField) {
+ return ((MapField<?, ?>) mapField).getMutableMap();
+ }
+
+ @Override
+ public Map<?, ?> forMapData(Object mapField) {
+ return ((MapField<?, ?>) mapField).getMap();
+ }
+
+ @Override
+ public boolean isImmutable(Object mapField) {
+ return !((MapField<?, ?>) mapField).isMutable();
+ }
+
+ @Override
+ public Object toImmutable(Object mapField) {
+ ((MapField<?, ?>) mapField).makeImmutable();
+ return mapField;
+ }
+
+ @Override
+ public Object newMapField(Object mapDefaultEntry) {
+ return MapField.newMapField((MapEntry<?, ?>) mapDefaultEntry);
+ }
+
+ @Override
+ public Metadata<?, ?> forMapMetadata(Object mapDefaultEntry) {
+ return ((MapEntry<?, ?>) mapDefaultEntry).getMetadata();
+ }
+
+ @Override
+ public Object mergeFrom(Object destMapField, Object srcMapField) {
+ return mergeFromFull(destMapField, srcMapField);
+ }
+
+ @SuppressWarnings("unchecked")
+ private static <K, V> Object mergeFromFull(Object destMapField, Object srcMapField) {
+ MapField<K, V> mine = (MapField<K, V>) destMapField;
+ MapField<K, V> other = (MapField<K, V>) srcMapField;
+ if (!mine.isMutable()) {
+ mine.copy();
+ }
+ mine.mergeFrom(other);
+ return mine;
+ }
+
+ @Override
+ public int getSerializedSize(int number, Object mapField, Object mapDefaultEntry) {
+ return getSerializedSizeFull(number, mapField, mapDefaultEntry);
+ }
+
+ @SuppressWarnings("unchecked")
+ private static <K, V> int getSerializedSizeFull(
+ int number, Object mapField, Object defaultEntryObject) {
+ // Full runtime allocates map fields lazily.
+ if (mapField == null) {
+ return 0;
+ }
+
+ Map<K, V> map = ((MapField<K, V>) mapField).getMap();
+ MapEntry<K, V> defaultEntry = (MapEntry<K, V>) defaultEntryObject;
+ if (map.isEmpty()) {
+ return 0;
+ }
+ int size = 0;
+ for (Map.Entry<K, V> entry : map.entrySet()) {
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeLengthDelimitedFieldSize(
+ MapEntryLite.computeSerializedSize(
+ defaultEntry.getMetadata(), entry.getKey(), entry.getValue()));
+ }
+ return size;
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/MapFieldSchemaLite.java b/java/core/src/main/java/com/google/protobuf/MapFieldSchemaLite.java
new file mode 100755
index 0000000..8a8c78d
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/MapFieldSchemaLite.java
@@ -0,0 +1,107 @@
+// 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.MapEntryLite.Metadata;
+import java.util.Map;
+
+class MapFieldSchemaLite implements MapFieldSchema {
+
+ @Override
+ public Map<?, ?> forMutableMapData(Object mapField) {
+ return (MapFieldLite<?, ?>) mapField;
+ }
+
+ @Override
+ public Metadata<?, ?> forMapMetadata(Object mapDefaultEntry) {
+ return ((MapEntryLite<?, ?>) mapDefaultEntry).getMetadata();
+ }
+
+ @Override
+ public Map<?, ?> forMapData(Object mapField) {
+ return (MapFieldLite<?, ?>) mapField;
+ }
+
+ @Override
+ public boolean isImmutable(Object mapField) {
+ return !((MapFieldLite<?, ?>) mapField).isMutable();
+ }
+
+ @Override
+ public Object toImmutable(Object mapField) {
+ ((MapFieldLite<?, ?>) mapField).makeImmutable();
+ return mapField;
+ }
+
+ @Override
+ public Object newMapField(Object unused) {
+ return MapFieldLite.emptyMapField().mutableCopy();
+ }
+
+ @Override
+ public Object mergeFrom(Object destMapField, Object srcMapField) {
+ return mergeFromLite(destMapField, srcMapField);
+ }
+
+ @SuppressWarnings("unchecked")
+ private static <K, V> MapFieldLite<K, V> mergeFromLite(Object destMapField, Object srcMapField) {
+ MapFieldLite<K, V> mine = (MapFieldLite<K, V>) destMapField;
+ MapFieldLite<K, V> other = (MapFieldLite<K, V>) srcMapField;
+ if (!other.isEmpty()) {
+ if (!mine.isMutable()) {
+ mine = mine.mutableCopy();
+ }
+ mine.mergeFrom(other);
+ }
+ return mine;
+ }
+
+ @Override
+ public int getSerializedSize(int fieldNumber, Object mapField, Object mapDefaultEntry) {
+ return getSerializedSizeLite(fieldNumber, mapField, mapDefaultEntry);
+ }
+
+ @SuppressWarnings("unchecked")
+ private static <K, V> int getSerializedSizeLite(
+ int fieldNumber, Object mapField, Object defaultEntry) {
+ MapFieldLite<K, V> mapFieldLite = (MapFieldLite<K, V>) mapField;
+ MapEntryLite<K, V> defaultEntryLite = (MapEntryLite<K, V>) defaultEntry;
+
+ if (mapFieldLite.isEmpty()) {
+ return 0;
+ }
+ int size = 0;
+ for (Map.Entry<K, V> entry : mapFieldLite.entrySet()) {
+ size += defaultEntryLite.computeMessageSize(fieldNumber, entry.getKey(), entry.getValue());
+ }
+ return size;
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/MapFieldSchemas.java b/java/core/src/main/java/com/google/protobuf/MapFieldSchemas.java
new file mode 100755
index 0000000..b398c61
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/MapFieldSchemas.java
@@ -0,0 +1,53 @@
+// 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;
+
+final class MapFieldSchemas {
+ private static final MapFieldSchema FULL_SCHEMA = loadSchemaForFullRuntime();
+ private static final MapFieldSchema LITE_SCHEMA = new MapFieldSchemaLite();
+
+ static MapFieldSchema full() {
+ return FULL_SCHEMA;
+ }
+
+ static MapFieldSchema lite() {
+ return LITE_SCHEMA;
+ }
+
+ private static MapFieldSchema loadSchemaForFullRuntime() {
+ try {
+ Class<?> clazz = Class.forName("com.google.protobuf.MapFieldSchemaFull");
+ return (MapFieldSchema) clazz.getDeclaredConstructor().newInstance();
+ } catch (Exception e) {
+ return null;
+ }
+ }
+}
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 100755
index 0000000..69e3186
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/MessageInfo.java
@@ -0,0 +1,43 @@
+// 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 MesageInfo object describes a proto message type. */
+interface MessageInfo {
+ /** Gets syntax for this type. */
+ ProtoSyntax getSyntax();
+
+ /** Whether this type is MessageSet. */
+ boolean isMessageSetWireFormat();
+
+ /** Gets the default instance of this type. */
+ MessageLite getDefaultInstance();
+}
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 100755
index 0000000..005c26d
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/MessageInfoFactory.java
@@ -0,0 +1,41 @@
+// 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
+interface MessageInfoFactory {
+ /** Whether the message class is supported by this factory. */
+ boolean isSupported(Class<?> clazz);
+
+ /** Returns a information of the message class. */
+ MessageInfo messageInfoFor(Class<?> clazz);
+}
diff --git a/java/core/src/main/java/com/google/protobuf/MessageSchema.java b/java/core/src/main/java/com/google/protobuf/MessageSchema.java
new file mode 100755
index 0000000..0c6cf99
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/MessageSchema.java
@@ -0,0 +1,5884 @@
+// 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.ArrayDecoders.decodeBoolList;
+import static com.google.protobuf.ArrayDecoders.decodeBytes;
+import static com.google.protobuf.ArrayDecoders.decodeBytesList;
+import static com.google.protobuf.ArrayDecoders.decodeDouble;
+import static com.google.protobuf.ArrayDecoders.decodeDoubleList;
+import static com.google.protobuf.ArrayDecoders.decodeExtensionOrUnknownField;
+import static com.google.protobuf.ArrayDecoders.decodeFixed32;
+import static com.google.protobuf.ArrayDecoders.decodeFixed32List;
+import static com.google.protobuf.ArrayDecoders.decodeFixed64;
+import static com.google.protobuf.ArrayDecoders.decodeFixed64List;
+import static com.google.protobuf.ArrayDecoders.decodeFloat;
+import static com.google.protobuf.ArrayDecoders.decodeFloatList;
+import static com.google.protobuf.ArrayDecoders.decodeGroupField;
+import static com.google.protobuf.ArrayDecoders.decodeGroupList;
+import static com.google.protobuf.ArrayDecoders.decodeMessageField;
+import static com.google.protobuf.ArrayDecoders.decodeMessageList;
+import static com.google.protobuf.ArrayDecoders.decodePackedBoolList;
+import static com.google.protobuf.ArrayDecoders.decodePackedDoubleList;
+import static com.google.protobuf.ArrayDecoders.decodePackedFixed32List;
+import static com.google.protobuf.ArrayDecoders.decodePackedFixed64List;
+import static com.google.protobuf.ArrayDecoders.decodePackedFloatList;
+import static com.google.protobuf.ArrayDecoders.decodePackedSInt32List;
+import static com.google.protobuf.ArrayDecoders.decodePackedSInt64List;
+import static com.google.protobuf.ArrayDecoders.decodePackedVarint32List;
+import static com.google.protobuf.ArrayDecoders.decodePackedVarint64List;
+import static com.google.protobuf.ArrayDecoders.decodeSInt32List;
+import static com.google.protobuf.ArrayDecoders.decodeSInt64List;
+import static com.google.protobuf.ArrayDecoders.decodeString;
+import static com.google.protobuf.ArrayDecoders.decodeStringList;
+import static com.google.protobuf.ArrayDecoders.decodeStringListRequireUtf8;
+import static com.google.protobuf.ArrayDecoders.decodeStringRequireUtf8;
+import static com.google.protobuf.ArrayDecoders.decodeUnknownField;
+import static com.google.protobuf.ArrayDecoders.decodeVarint32;
+import static com.google.protobuf.ArrayDecoders.decodeVarint32List;
+import static com.google.protobuf.ArrayDecoders.decodeVarint64;
+import static com.google.protobuf.ArrayDecoders.decodeVarint64List;
+import static com.google.protobuf.ArrayDecoders.skipField;
+
+import com.google.protobuf.ArrayDecoders.Registers;
+import com.google.protobuf.ByteString.CodedBuilder;
+import com.google.protobuf.FieldSet.FieldDescriptorLite;
+import com.google.protobuf.Internal.EnumVerifier;
+import com.google.protobuf.Internal.ProtobufList;
+import com.google.protobuf.MapEntryLite.Metadata;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/** Schema used for standard messages. */
+final class MessageSchema<T> implements Schema<T> {
+ private static final int INTS_PER_FIELD = 3;
+ private static final int OFFSET_BITS = 20;
+ private static final int OFFSET_MASK = 0XFFFFF;
+ private static final int FIELD_TYPE_MASK = 0x0FF00000;
+ private static final int REQUIRED_MASK = 0x10000000;
+ private static final int ENFORCE_UTF8_MASK = 0x20000000;
+ private static final int[] EMPTY_INT_ARRAY = new int[0];
+
+ /** An offset applied to the field type ID for scalar fields that are a member of a oneof. */
+ static final int ONEOF_TYPE_OFFSET = 51 /* FieldType.MAP + 1 */;
+
+ /**
+ * Keep a direct reference to the unsafe object so we don't need to go through the UnsafeUtil
+ * wrapper for every call.
+ */
+ private static final sun.misc.Unsafe UNSAFE = UnsafeUtil.getUnsafe();
+
+ /**
+ * 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):
+ *
+ * <p>
+ *
+ * <pre>
+ * [ 0 - 3] unused
+ * [ 4 - 31] field number
+ * [32 - 33] unused
+ * [34 - 34] whether UTF-8 enforcement should be applied to a string field.
+ * [35 - 35] whether the field is required
+ * [36 - 43] field type / for oneof: field type + {@link #ONEOF_TYPE_OFFSET}
+ * [44 - 63] field offset / oneof value field offset
+ * [64 - 69] unused
+ * [70 - 75] field presence mask shift (unused for oneof/repeated fields)
+ * [76 - 95] presence field offset / oneof case field offset / cached size field offset
+ * </pre>
+ */
+ private final int[] buffer;
+
+ /**
+ * Holds object references for fields. For each field entry in {@code buffer}, there are two
+ * corresponding entries in this array. The content is different from different field types:
+ *
+ * <pre>
+ * Map fields:
+ * objects[pos] = map default entry instance
+ * objects[pos + 1] = EnumVerifier if map value is enum, or message class reference if map
+ * value is message.
+ * Message fields:
+ * objects[pos] = null or cached message schema
+ * objects[pos + 1] = message class reference
+ * Enum fields:
+ * objects[pos] = null
+ * objects[pos + 1] = EnumVerifier
+ * </pre>
+ */
+ private final Object[] objects;
+
+ private final int minFieldNumber;
+ private final int maxFieldNumber;
+
+ private final MessageLite defaultInstance;
+ private final boolean hasExtensions;
+ private final boolean lite;
+ private final boolean proto3;
+ // TODO(xiaofeng): Make both full-runtime and lite-runtime support cached field size.
+ private final boolean useCachedSizeField;
+
+ /** Represents [checkInitialized positions, map field positions, repeated field offsets]. */
+ private final int[] intArray;
+
+ /**
+ * Values at indices 0 -> checkInitializedCount in intArray are positions to check for
+ * initialization.
+ */
+ private final int checkInitializedCount;
+
+ /**
+ * Values at indices checkInitializedCount -> repeatedFieldOffsetStart are map positions.
+ * Everything after that are repeated field offsets.
+ */
+ private final int repeatedFieldOffsetStart;
+
+ private final NewInstanceSchema newInstanceSchema;
+ private final ListFieldSchema listFieldSchema;
+ private final UnknownFieldSchema<?, ?> unknownFieldSchema;
+ private final ExtensionSchema<?> extensionSchema;
+ private final MapFieldSchema mapFieldSchema;
+
+ private MessageSchema(
+ int[] buffer,
+ Object[] objects,
+ int minFieldNumber,
+ int maxFieldNumber,
+ MessageLite defaultInstance,
+ boolean proto3,
+ boolean useCachedSizeField,
+ int[] intArray,
+ int checkInitialized,
+ int mapFieldPositions,
+ NewInstanceSchema newInstanceSchema,
+ ListFieldSchema listFieldSchema,
+ UnknownFieldSchema<?, ?> unknownFieldSchema,
+ ExtensionSchema<?> extensionSchema,
+ MapFieldSchema mapFieldSchema) {
+ this.buffer = buffer;
+ this.objects = objects;
+ this.minFieldNumber = minFieldNumber;
+ this.maxFieldNumber = maxFieldNumber;
+
+ this.lite = defaultInstance instanceof GeneratedMessageLite;
+ this.proto3 = proto3;
+ this.hasExtensions = extensionSchema != null && extensionSchema.hasExtensions(defaultInstance);
+ this.useCachedSizeField = useCachedSizeField;
+
+ this.intArray = intArray;
+ this.checkInitializedCount = checkInitialized;
+ this.repeatedFieldOffsetStart = mapFieldPositions;
+
+ this.newInstanceSchema = newInstanceSchema;
+ this.listFieldSchema = listFieldSchema;
+ this.unknownFieldSchema = unknownFieldSchema;
+ this.extensionSchema = extensionSchema;
+ this.defaultInstance = defaultInstance;
+ this.mapFieldSchema = mapFieldSchema;
+ }
+
+ static <T> MessageSchema<T> newSchema(
+ Class<T> messageClass,
+ MessageInfo messageInfo,
+ NewInstanceSchema newInstanceSchema,
+ ListFieldSchema listFieldSchema,
+ UnknownFieldSchema<?, ?> unknownFieldSchema,
+ ExtensionSchema<?> extensionSchema,
+ MapFieldSchema mapFieldSchema) {
+ if (messageInfo instanceof RawMessageInfo) {
+ return newSchemaForRawMessageInfo(
+ (RawMessageInfo) messageInfo,
+ newInstanceSchema,
+ listFieldSchema,
+ unknownFieldSchema,
+ extensionSchema,
+ mapFieldSchema);
+
+ } else {
+ return newSchemaForMessageInfo(
+ (StructuralMessageInfo) messageInfo,
+ newInstanceSchema,
+ listFieldSchema,
+ unknownFieldSchema,
+ extensionSchema,
+ mapFieldSchema);
+ }
+ }
+
+ static <T> MessageSchema<T> newSchemaForRawMessageInfo(
+ RawMessageInfo messageInfo,
+ NewInstanceSchema newInstanceSchema,
+ ListFieldSchema listFieldSchema,
+ UnknownFieldSchema<?, ?> unknownFieldSchema,
+ ExtensionSchema<?> extensionSchema,
+ MapFieldSchema mapFieldSchema) {
+ final boolean isProto3 = messageInfo.getSyntax() == ProtoSyntax.PROTO3;
+
+ String info = messageInfo.getStringInfo();
+ final int length = info.length();
+ int i = 0;
+
+ int next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ final int flags = next;
+
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ final int fieldCount = next;
+
+ final int oneofCount;
+ final int hasBitsCount;
+ final int minFieldNumber;
+ final int maxFieldNumber;
+ final int numEntries;
+ final int mapFieldCount;
+ final int repeatedFieldCount;
+ final int checkInitialized;
+ final int[] intArray;
+ int objectsPosition;
+ if (fieldCount == 0) {
+ oneofCount = 0;
+ hasBitsCount = 0;
+ minFieldNumber = 0;
+ maxFieldNumber = 0;
+ numEntries = 0;
+ mapFieldCount = 0;
+ repeatedFieldCount = 0;
+ checkInitialized = 0;
+ intArray = EMPTY_INT_ARRAY;
+ objectsPosition = 0;
+ } else {
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ oneofCount = next;
+
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ hasBitsCount = next;
+
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ minFieldNumber = next;
+
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ maxFieldNumber = next;
+
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ numEntries = next;
+
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ mapFieldCount = next;
+
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ repeatedFieldCount = next;
+
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ checkInitialized = next;
+ intArray = new int[checkInitialized + mapFieldCount + repeatedFieldCount];
+ // Field objects are after a list of (oneof, oneofCase) pairs + a list of hasbits fields.
+ objectsPosition = oneofCount * 2 + hasBitsCount;
+ }
+
+ final sun.misc.Unsafe unsafe = UNSAFE;
+ final Object[] messageInfoObjects = messageInfo.getObjects();
+ int checkInitializedPosition = 0;
+ final Class<?> messageClass = messageInfo.getDefaultInstance().getClass();
+ int[] buffer = new int[numEntries * INTS_PER_FIELD];
+ Object[] objects = new Object[numEntries * 2];
+
+ int mapFieldIndex = checkInitialized;
+ int repeatedFieldIndex = checkInitialized + mapFieldCount;
+
+ int bufferIndex = 0;
+ while (i < length) {
+ final int fieldNumber;
+ final int fieldTypeWithExtraBits;
+ final int fieldType;
+
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ fieldNumber = next;
+
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ fieldTypeWithExtraBits = next;
+ fieldType = fieldTypeWithExtraBits & 0xFF;
+
+ if ((fieldTypeWithExtraBits & 0x400) != 0) {
+ intArray[checkInitializedPosition++] = bufferIndex;
+ }
+
+ final int fieldOffset;
+ final int presenceMaskShift;
+ final int presenceFieldOffset;
+
+ // Oneof
+ if (fieldType >= ONEOF_TYPE_OFFSET) {
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ int oneofIndex = next;
+
+ final int oneofFieldType = fieldType - ONEOF_TYPE_OFFSET;
+ if (oneofFieldType == 9 /* FieldType.MESSAGE */
+ || oneofFieldType == 17 /* FieldType.GROUP */) {
+ objects[bufferIndex / INTS_PER_FIELD * 2 + 1] = messageInfoObjects[objectsPosition++];
+ } else if (oneofFieldType == 12 /* FieldType.ENUM */) {
+ // proto2
+ if ((flags & 0x1) == 0x1) {
+ objects[bufferIndex / INTS_PER_FIELD * 2 + 1] = messageInfoObjects[objectsPosition++];
+ }
+ }
+
+ final java.lang.reflect.Field oneofField;
+ int index = oneofIndex * 2;
+ Object o = messageInfoObjects[index];
+ if (o instanceof java.lang.reflect.Field) {
+ oneofField = (java.lang.reflect.Field) o;
+ } else {
+ oneofField = reflectField(messageClass, (String) o);
+ // Memoize java.lang.reflect.Field instances for oneof/hasbits fields, since they're
+ // potentially used for many Protobuf fields. Since there's a 1-1 mapping from the
+ // Protobuf field to the Java Field for non-oneofs, there's no benefit for memoizing
+ // those.
+ messageInfoObjects[index] = oneofField;
+ }
+
+ fieldOffset = (int) unsafe.objectFieldOffset(oneofField);
+
+ final java.lang.reflect.Field oneofCaseField;
+ index++;
+ o = messageInfoObjects[index];
+ if (o instanceof java.lang.reflect.Field) {
+ oneofCaseField = (java.lang.reflect.Field) o;
+ } else {
+ oneofCaseField = reflectField(messageClass, (String) o);
+ messageInfoObjects[index] = oneofCaseField;
+ }
+
+ presenceFieldOffset = (int) unsafe.objectFieldOffset(oneofCaseField);
+ presenceMaskShift = 0;
+ } else {
+ Field field = reflectField(messageClass, (String) messageInfoObjects[objectsPosition++]);
+ if (fieldType == 9 /* FieldType.MESSAGE */ || fieldType == 17 /* FieldType.GROUP */) {
+ objects[bufferIndex / INTS_PER_FIELD * 2 + 1] = field.getType();
+ } else if (fieldType == 27 /* FieldType.MESSAGE_LIST */
+ || fieldType == 49 /* FieldType.GROUP_LIST */) {
+ objects[bufferIndex / INTS_PER_FIELD * 2 + 1] = messageInfoObjects[objectsPosition++];
+ } else if (fieldType == 12 /* FieldType.ENUM */
+ || fieldType == 30 /* FieldType.ENUM_LIST */
+ || fieldType == 44 /* FieldType.ENUM_LIST_PACKED */) {
+ if ((flags & 0x1) == 0x1) {
+ objects[bufferIndex / INTS_PER_FIELD * 2 + 1] = messageInfoObjects[objectsPosition++];
+ }
+ } else if (fieldType == 50 /* FieldType.MAP */) {
+ intArray[mapFieldIndex++] = bufferIndex;
+ objects[bufferIndex / INTS_PER_FIELD * 2] = messageInfoObjects[objectsPosition++];
+ if ((fieldTypeWithExtraBits & 0x800) != 0) {
+ objects[bufferIndex / INTS_PER_FIELD * 2 + 1] = messageInfoObjects[objectsPosition++];
+ }
+ }
+
+ fieldOffset = (int) unsafe.objectFieldOffset(field);
+ if ((flags & 0x1) == 0x1 && fieldType <= 17 /* FieldType.GROUP */) {
+ next = info.charAt(i++);
+ if (next >= 0xD800) {
+ int result = next & 0x1FFF;
+ int shift = 13;
+ while ((next = info.charAt(i++)) >= 0xD800) {
+ result |= (next & 0x1FFF) << shift;
+ shift += 13;
+ }
+ next = result | (next << shift);
+ }
+ int hasBitsIndex = next;
+
+ final java.lang.reflect.Field hasBitsField;
+ int index = oneofCount * 2 + hasBitsIndex / 32;
+ Object o = messageInfoObjects[index];
+ if (o instanceof java.lang.reflect.Field) {
+ hasBitsField = (java.lang.reflect.Field) o;
+ } else {
+ hasBitsField = reflectField(messageClass, (String) o);
+ messageInfoObjects[index] = hasBitsField;
+ }
+
+ presenceFieldOffset = (int) unsafe.objectFieldOffset(hasBitsField);
+ presenceMaskShift = hasBitsIndex % 32;
+ } else {
+ presenceFieldOffset = 0;
+ presenceMaskShift = 0;
+ }
+
+ if (fieldType >= 18 && fieldType <= 49) {
+ // Field types of repeated fields are in a consecutive range from 18 (DOUBLE_LIST) to
+ // 49 (GROUP_LIST).
+ intArray[repeatedFieldIndex++] = fieldOffset;
+ }
+ }
+
+ buffer[bufferIndex++] = fieldNumber;
+ buffer[bufferIndex++] =
+ ((fieldTypeWithExtraBits & 0x200) != 0 ? ENFORCE_UTF8_MASK : 0)
+ | ((fieldTypeWithExtraBits & 0x100) != 0 ? REQUIRED_MASK : 0)
+ | (fieldType << OFFSET_BITS)
+ | fieldOffset;
+ buffer[bufferIndex++] = (presenceMaskShift << OFFSET_BITS) | presenceFieldOffset;
+ }
+
+ return new MessageSchema<T>(
+ buffer,
+ objects,
+ minFieldNumber,
+ maxFieldNumber,
+ messageInfo.getDefaultInstance(),
+ isProto3,
+ /* useCachedSizeField= */ false,
+ intArray,
+ checkInitialized,
+ checkInitialized + mapFieldCount,
+ newInstanceSchema,
+ listFieldSchema,
+ unknownFieldSchema,
+ extensionSchema,
+ mapFieldSchema);
+ }
+
+ private static java.lang.reflect.Field reflectField(Class<?> messageClass, String fieldName) {
+ try {
+ return messageClass.getDeclaredField(fieldName);
+ } catch (NoSuchFieldException e) {
+ // Some Samsung devices lie about what fields are present via the getDeclaredField API so
+ // we do the for loop properly that they seem to have messed up...
+ java.lang.reflect.Field[] fields = messageClass.getDeclaredFields();
+ for (java.lang.reflect.Field field : fields) {
+ if (fieldName.equals(field.getName())) {
+ return field;
+ }
+ }
+
+ // If we make it here, the runtime still lies about what we know to be true at compile
+ // time. We throw to alert server monitoring for further remediation.
+ throw new RuntimeException(
+ "Field "
+ + fieldName
+ + " for "
+ + messageClass.getName()
+ + " not found. Known fields are "
+ + Arrays.toString(fields));
+ }
+ }
+
+ static <T> MessageSchema<T> newSchemaForMessageInfo(
+ StructuralMessageInfo messageInfo,
+ NewInstanceSchema newInstanceSchema,
+ ListFieldSchema listFieldSchema,
+ UnknownFieldSchema<?, ?> unknownFieldSchema,
+ ExtensionSchema<?> extensionSchema,
+ MapFieldSchema mapFieldSchema) {
+ final boolean isProto3 = messageInfo.getSyntax() == ProtoSyntax.PROTO3;
+ FieldInfo[] fis = messageInfo.getFields();
+ final int minFieldNumber;
+ final int maxFieldNumber;
+ if (fis.length == 0) {
+ minFieldNumber = 0;
+ maxFieldNumber = 0;
+ } else {
+ minFieldNumber = fis[0].getFieldNumber();
+ maxFieldNumber = fis[fis.length - 1].getFieldNumber();
+ }
+
+ final int numEntries = fis.length;
+
+ int[] buffer = new int[numEntries * INTS_PER_FIELD];
+ Object[] objects = new Object[numEntries * 2];
+
+ int mapFieldCount = 0;
+ int repeatedFieldCount = 0;
+ for (FieldInfo fi : fis) {
+ if (fi.getType() == FieldType.MAP) {
+ mapFieldCount++;
+ } else if (fi.getType().id() >= 18 && fi.getType().id() <= 49) {
+ // Field types of repeated fields are in a consecutive range from 18 (DOUBLE_LIST) to
+ // 49 (GROUP_LIST).
+ repeatedFieldCount++;
+ }
+ }
+ int[] mapFieldPositions = mapFieldCount > 0 ? new int[mapFieldCount] : null;
+ int[] repeatedFieldOffsets = repeatedFieldCount > 0 ? new int[repeatedFieldCount] : null;
+ mapFieldCount = 0;
+ repeatedFieldCount = 0;
+
+ int[] checkInitialized = messageInfo.getCheckInitialized();
+ if (checkInitialized == null) {
+ checkInitialized = EMPTY_INT_ARRAY;
+ }
+ int checkInitializedIndex = 0;
+ // Fill in the manifest data from the descriptors.
+ int fieldIndex = 0;
+ for (int bufferIndex = 0; fieldIndex < fis.length; bufferIndex += INTS_PER_FIELD) {
+ final FieldInfo fi = fis[fieldIndex];
+ final int fieldNumber = fi.getFieldNumber();
+
+ // We found the entry for the next field. Store the entry in the manifest for
+ // this field and increment the field index.
+ storeFieldData(fi, buffer, bufferIndex, isProto3, objects);
+
+ // Convert field number to index
+ if (checkInitializedIndex < checkInitialized.length
+ && checkInitialized[checkInitializedIndex] == fieldNumber) {
+ checkInitialized[checkInitializedIndex++] = bufferIndex;
+ }
+
+ if (fi.getType() == FieldType.MAP) {
+ mapFieldPositions[mapFieldCount++] = bufferIndex;
+ } else if (fi.getType().id() >= 18 && fi.getType().id() <= 49) {
+ // Field types of repeated fields are in a consecutive range from 18 (DOUBLE_LIST) to
+ // 49 (GROUP_LIST).
+ repeatedFieldOffsets[repeatedFieldCount++] =
+ (int) UnsafeUtil.objectFieldOffset(fi.getField());
+ }
+
+ fieldIndex++;
+ }
+
+ if (mapFieldPositions == null) {
+ mapFieldPositions = EMPTY_INT_ARRAY;
+ }
+ if (repeatedFieldOffsets == null) {
+ repeatedFieldOffsets = EMPTY_INT_ARRAY;
+ }
+ int[] combined =
+ new int[checkInitialized.length + mapFieldPositions.length + repeatedFieldOffsets.length];
+ System.arraycopy(checkInitialized, 0, combined, 0, checkInitialized.length);
+ System.arraycopy(
+ mapFieldPositions, 0, combined, checkInitialized.length, mapFieldPositions.length);
+ System.arraycopy(
+ repeatedFieldOffsets,
+ 0,
+ combined,
+ checkInitialized.length + mapFieldPositions.length,
+ repeatedFieldOffsets.length);
+
+ return new MessageSchema<T>(
+ buffer,
+ objects,
+ minFieldNumber,
+ maxFieldNumber,
+ messageInfo.getDefaultInstance(),
+ isProto3,
+ /* useCachedSizeField= */ true,
+ combined,
+ checkInitialized.length,
+ checkInitialized.length + mapFieldPositions.length,
+ newInstanceSchema,
+ listFieldSchema,
+ unknownFieldSchema,
+ extensionSchema,
+ mapFieldSchema);
+ }
+
+ private static void storeFieldData(
+ FieldInfo fi, int[] buffer, int bufferIndex, boolean proto3, Object[] objects) {
+ final int fieldOffset;
+ final int typeId;
+ final int presenceMaskShift;
+ final int presenceFieldOffset;
+
+ OneofInfo oneof = fi.getOneof();
+ if (oneof != null) {
+ typeId = fi.getType().id() + ONEOF_TYPE_OFFSET;
+ fieldOffset = (int) UnsafeUtil.objectFieldOffset(oneof.getValueField());
+ presenceFieldOffset = (int) UnsafeUtil.objectFieldOffset(oneof.getCaseField());
+ presenceMaskShift = 0;
+ } else {
+ FieldType type = fi.getType();
+ fieldOffset = (int) UnsafeUtil.objectFieldOffset(fi.getField());
+ typeId = type.id();
+ if (!proto3 && !type.isList() && !type.isMap()) {
+ presenceFieldOffset = (int) UnsafeUtil.objectFieldOffset(fi.getPresenceField());
+ presenceMaskShift = Integer.numberOfTrailingZeros(fi.getPresenceMask());
+ } else {
+ if (fi.getCachedSizeField() == null) {
+ presenceFieldOffset = 0;
+ presenceMaskShift = 0;
+ } else {
+ presenceFieldOffset = (int) UnsafeUtil.objectFieldOffset(fi.getCachedSizeField());
+ presenceMaskShift = 0;
+ }
+ }
+ }
+
+ buffer[bufferIndex] = fi.getFieldNumber();
+ buffer[bufferIndex + 1] =
+ (fi.isEnforceUtf8() ? ENFORCE_UTF8_MASK : 0)
+ | (fi.isRequired() ? REQUIRED_MASK : 0)
+ | (typeId << OFFSET_BITS)
+ | fieldOffset;
+ buffer[bufferIndex + 2] = (presenceMaskShift << OFFSET_BITS) | presenceFieldOffset;
+
+ Object messageFieldClass = fi.getMessageFieldClass();
+ if (fi.getMapDefaultEntry() != null) {
+ objects[bufferIndex / INTS_PER_FIELD * 2] = fi.getMapDefaultEntry();
+ if (messageFieldClass != null) {
+ objects[bufferIndex / INTS_PER_FIELD * 2 + 1] = messageFieldClass;
+ } else if (fi.getEnumVerifier() != null) {
+ objects[bufferIndex / INTS_PER_FIELD * 2 + 1] = fi.getEnumVerifier();
+ }
+ } else {
+ if (messageFieldClass != null) {
+ objects[bufferIndex / INTS_PER_FIELD * 2 + 1] = messageFieldClass;
+ } else if (fi.getEnumVerifier() != null) {
+ objects[bufferIndex / INTS_PER_FIELD * 2 + 1] = fi.getEnumVerifier();
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public T newInstance() {
+ return (T) newInstanceSchema.newInstance(defaultInstance);
+ }
+
+ @Override
+ public boolean equals(T message, T other) {
+ final int bufferLength = buffer.length;
+ for (int pos = 0; pos < bufferLength; pos += INTS_PER_FIELD) {
+ if (!equals(message, other, pos)) {
+ return false;
+ }
+ }
+
+ Object messageUnknown = unknownFieldSchema.getFromMessage(message);
+ Object otherUnknown = unknownFieldSchema.getFromMessage(other);
+ if (!messageUnknown.equals(otherUnknown)) {
+ return false;
+ }
+
+ if (hasExtensions) {
+ FieldSet<?> messageExtensions = extensionSchema.getExtensions(message);
+ FieldSet<?> otherExtensions = extensionSchema.getExtensions(other);
+ return messageExtensions.equals(otherExtensions);
+ }
+ return true;
+ }
+
+ private boolean equals(T message, T other, int pos) {
+ final int typeAndOffset = typeAndOffsetAt(pos);
+ final long offset = offset(typeAndOffset);
+
+ switch (type(typeAndOffset)) {
+ case 0: // DOUBLE:
+ return arePresentForEquals(message, other, pos)
+ && Double.doubleToLongBits(UnsafeUtil.getDouble(message, offset))
+ == Double.doubleToLongBits(UnsafeUtil.getDouble(other, offset));
+ case 1: // FLOAT:
+ return arePresentForEquals(message, other, pos)
+ && Float.floatToIntBits(UnsafeUtil.getFloat(message, offset))
+ == Float.floatToIntBits(UnsafeUtil.getFloat(other, offset));
+ case 2: // INT64:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getLong(message, offset) == UnsafeUtil.getLong(other, offset);
+ case 3: // UINT64:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getLong(message, offset) == UnsafeUtil.getLong(other, offset);
+ case 4: // INT32:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getInt(message, offset) == UnsafeUtil.getInt(other, offset);
+ case 5: // FIXED64:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getLong(message, offset) == UnsafeUtil.getLong(other, offset);
+ case 6: // FIXED32:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getInt(message, offset) == UnsafeUtil.getInt(other, offset);
+ case 7: // BOOL:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getBoolean(message, offset) == UnsafeUtil.getBoolean(other, offset);
+ case 8: // STRING:
+ return arePresentForEquals(message, other, pos)
+ && SchemaUtil.safeEquals(
+ UnsafeUtil.getObject(message, offset), UnsafeUtil.getObject(other, offset));
+ case 9: // MESSAGE:
+ return arePresentForEquals(message, other, pos)
+ && SchemaUtil.safeEquals(
+ UnsafeUtil.getObject(message, offset), UnsafeUtil.getObject(other, offset));
+ case 10: // BYTES:
+ return arePresentForEquals(message, other, pos)
+ && SchemaUtil.safeEquals(
+ UnsafeUtil.getObject(message, offset), UnsafeUtil.getObject(other, offset));
+ case 11: // UINT32:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getInt(message, offset) == UnsafeUtil.getInt(other, offset);
+ case 12: // ENUM:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getInt(message, offset) == UnsafeUtil.getInt(other, offset);
+ case 13: // SFIXED32:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getInt(message, offset) == UnsafeUtil.getInt(other, offset);
+ case 14: // SFIXED64:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getLong(message, offset) == UnsafeUtil.getLong(other, offset);
+ case 15: // SINT32:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getInt(message, offset) == UnsafeUtil.getInt(other, offset);
+ case 16: // SINT64:
+ return arePresentForEquals(message, other, pos)
+ && UnsafeUtil.getLong(message, offset) == UnsafeUtil.getLong(other, offset);
+ case 17: // GROUP:
+ return arePresentForEquals(message, other, pos)
+ && SchemaUtil.safeEquals(
+ UnsafeUtil.getObject(message, offset), UnsafeUtil.getObject(other, offset));
+
+ case 18: // DOUBLE_LIST:
+ case 19: // FLOAT_LIST:
+ case 20: // INT64_LIST:
+ case 21: // UINT64_LIST:
+ case 22: // INT32_LIST:
+ case 23: // FIXED64_LIST:
+ case 24: // FIXED32_LIST:
+ case 25: // BOOL_LIST:
+ case 26: // STRING_LIST:
+ case 27: // MESSAGE_LIST:
+ case 28: // BYTES_LIST:
+ case 29: // UINT32_LIST:
+ case 30: // ENUM_LIST:
+ case 31: // SFIXED32_LIST:
+ case 32: // SFIXED64_LIST:
+ case 33: // SINT32_LIST:
+ case 34: // SINT64_LIST:
+ case 35: // DOUBLE_LIST_PACKED:
+ case 36: // FLOAT_LIST_PACKED:
+ case 37: // INT64_LIST_PACKED:
+ case 38: // UINT64_LIST_PACKED:
+ case 39: // INT32_LIST_PACKED:
+ case 40: // FIXED64_LIST_PACKED:
+ case 41: // FIXED32_LIST_PACKED:
+ case 42: // BOOL_LIST_PACKED:
+ case 43: // UINT32_LIST_PACKED:
+ case 44: // ENUM_LIST_PACKED:
+ case 45: // SFIXED32_LIST_PACKED:
+ case 46: // SFIXED64_LIST_PACKED:
+ case 47: // SINT32_LIST_PACKED:
+ case 48: // SINT64_LIST_PACKED:
+ case 49: // GROUP_LIST:
+ return SchemaUtil.safeEquals(
+ UnsafeUtil.getObject(message, offset), UnsafeUtil.getObject(other, offset));
+ case 50: // MAP:
+ return SchemaUtil.safeEquals(
+ UnsafeUtil.getObject(message, offset), UnsafeUtil.getObject(other, offset));
+ case 51: // ONEOF_DOUBLE:
+ case 52: // ONEOF_FLOAT:
+ case 53: // ONEOF_INT64:
+ case 54: // ONEOF_UINT64:
+ case 55: // ONEOF_INT32:
+ case 56: // ONEOF_FIXED64:
+ case 57: // ONEOF_FIXED32:
+ case 58: // ONEOF_BOOL:
+ case 59: // ONEOF_STRING:
+ case 60: // ONEOF_MESSAGE:
+ case 61: // ONEOF_BYTES:
+ case 62: // ONEOF_UINT32:
+ case 63: // ONEOF_ENUM:
+ case 64: // ONEOF_SFIXED32:
+ case 65: // ONEOF_SFIXED64:
+ case 66: // ONEOF_SINT32:
+ case 67: // ONEOF_SINT64:
+ case 68: // ONEOF_GROUP:
+ return isOneofCaseEqual(message, other, pos)
+ && SchemaUtil.safeEquals(
+ UnsafeUtil.getObject(message, offset), UnsafeUtil.getObject(other, offset));
+ default:
+ // Assume it's an empty entry - just go to the next entry.
+ return true;
+ }
+ }
+
+ @Override
+ public int hashCode(T message) {
+ int hashCode = 0;
+ final int bufferLength = buffer.length;
+ for (int pos = 0; pos < bufferLength; pos += INTS_PER_FIELD) {
+ final int typeAndOffset = typeAndOffsetAt(pos);
+ final int entryNumber = numberAt(pos);
+
+ final long offset = offset(typeAndOffset);
+
+ switch (type(typeAndOffset)) {
+ case 0: // DOUBLE:
+ hashCode =
+ (hashCode * 53)
+ + Internal.hashLong(
+ Double.doubleToLongBits(UnsafeUtil.getDouble(message, offset)));
+ break;
+ case 1: // FLOAT:
+ hashCode = (hashCode * 53) + Float.floatToIntBits(UnsafeUtil.getFloat(message, offset));
+ break;
+ case 2: // INT64:
+ hashCode = (hashCode * 53) + Internal.hashLong(UnsafeUtil.getLong(message, offset));
+ break;
+ case 3: // UINT64:
+ hashCode = (hashCode * 53) + Internal.hashLong(UnsafeUtil.getLong(message, offset));
+ break;
+ case 4: // INT32:
+ hashCode = (hashCode * 53) + (UnsafeUtil.getInt(message, offset));
+ break;
+ case 5: // FIXED64:
+ hashCode = (hashCode * 53) + Internal.hashLong(UnsafeUtil.getLong(message, offset));
+ break;
+ case 6: // FIXED32:
+ hashCode = (hashCode * 53) + (UnsafeUtil.getInt(message, offset));
+ break;
+ case 7: // BOOL:
+ hashCode = (hashCode * 53) + Internal.hashBoolean(UnsafeUtil.getBoolean(message, offset));
+ break;
+ case 8: // STRING:
+ hashCode = (hashCode * 53) + ((String) UnsafeUtil.getObject(message, offset)).hashCode();
+ break;
+ case 9: // MESSAGE:
+ {
+ int protoHash = 37;
+ Object submessage = UnsafeUtil.getObject(message, offset);
+ if (submessage != null) {
+ protoHash = submessage.hashCode();
+ }
+ hashCode = (53 * hashCode) + protoHash;
+ break;
+ }
+ case 10: // BYTES:
+ hashCode = (hashCode * 53) + UnsafeUtil.getObject(message, offset).hashCode();
+ break;
+ case 11: // UINT32:
+ hashCode = (hashCode * 53) + (UnsafeUtil.getInt(message, offset));
+ break;
+ case 12: // ENUM:
+ hashCode = (hashCode * 53) + (UnsafeUtil.getInt(message, offset));
+ break;
+ case 13: // SFIXED32:
+ hashCode = (hashCode * 53) + (UnsafeUtil.getInt(message, offset));
+ break;
+ case 14: // SFIXED64:
+ hashCode = (hashCode * 53) + Internal.hashLong(UnsafeUtil.getLong(message, offset));
+ break;
+ case 15: // SINT32:
+ hashCode = (hashCode * 53) + (UnsafeUtil.getInt(message, offset));
+ break;
+ case 16: // SINT64:
+ hashCode = (hashCode * 53) + Internal.hashLong(UnsafeUtil.getLong(message, offset));
+ break;
+
+ case 17: // GROUP:
+ {
+ int protoHash = 37;
+ Object submessage = UnsafeUtil.getObject(message, offset);
+ if (submessage != null) {
+ protoHash = submessage.hashCode();
+ }
+ hashCode = (53 * hashCode) + protoHash;
+ break;
+ }
+ case 18: // DOUBLE_LIST:
+ case 19: // FLOAT_LIST:
+ case 20: // INT64_LIST:
+ case 21: // UINT64_LIST:
+ case 22: // INT32_LIST:
+ case 23: // FIXED64_LIST:
+ case 24: // FIXED32_LIST:
+ case 25: // BOOL_LIST:
+ case 26: // STRING_LIST:
+ case 27: // MESSAGE_LIST:
+ case 28: // BYTES_LIST:
+ case 29: // UINT32_LIST:
+ case 30: // ENUM_LIST:
+ case 31: // SFIXED32_LIST:
+ case 32: // SFIXED64_LIST:
+ case 33: // SINT32_LIST:
+ case 34: // SINT64_LIST:
+ case 35: // DOUBLE_LIST_PACKED:
+ case 36: // FLOAT_LIST_PACKED:
+ case 37: // INT64_LIST_PACKED:
+ case 38: // UINT64_LIST_PACKED:
+ case 39: // INT32_LIST_PACKED:
+ case 40: // FIXED64_LIST_PACKED:
+ case 41: // FIXED32_LIST_PACKED:
+ case 42: // BOOL_LIST_PACKED:
+ case 43: // UINT32_LIST_PACKED:
+ case 44: // ENUM_LIST_PACKED:
+ case 45: // SFIXED32_LIST_PACKED:
+ case 46: // SFIXED64_LIST_PACKED:
+ case 47: // SINT32_LIST_PACKED:
+ case 48: // SINT64_LIST_PACKED:
+ case 49: // GROUP_LIST:
+ hashCode = (hashCode * 53) + UnsafeUtil.getObject(message, offset).hashCode();
+ break;
+ case 50: // MAP:
+ hashCode = (hashCode * 53) + UnsafeUtil.getObject(message, offset).hashCode();
+ break;
+ case 51: // ONEOF_DOUBLE:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode =
+ (hashCode * 53)
+ + Internal.hashLong(Double.doubleToLongBits(oneofDoubleAt(message, offset)));
+ }
+ break;
+ case 52: // ONEOF_FLOAT:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + Float.floatToIntBits(oneofFloatAt(message, offset));
+ }
+ break;
+ case 53: // ONEOF_INT64:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + Internal.hashLong(oneofLongAt(message, offset));
+ }
+ break;
+ case 54: // ONEOF_UINT64:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + Internal.hashLong(oneofLongAt(message, offset));
+ }
+ break;
+ case 55: // ONEOF_INT32:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + (oneofIntAt(message, offset));
+ }
+ break;
+ case 56: // ONEOF_FIXED64:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + Internal.hashLong(oneofLongAt(message, offset));
+ }
+ break;
+ case 57: // ONEOF_FIXED32:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + (oneofIntAt(message, offset));
+ }
+ break;
+ case 58: // ONEOF_BOOL:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + Internal.hashBoolean(oneofBooleanAt(message, offset));
+ }
+ break;
+ case 59: // ONEOF_STRING:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode =
+ (hashCode * 53) + ((String) UnsafeUtil.getObject(message, offset)).hashCode();
+ }
+ break;
+ case 60: // ONEOF_MESSAGE:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ Object submessage = UnsafeUtil.getObject(message, offset);
+ hashCode = (53 * hashCode) + submessage.hashCode();
+ }
+ break;
+ case 61: // ONEOF_BYTES:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + UnsafeUtil.getObject(message, offset).hashCode();
+ }
+ break;
+ case 62: // ONEOF_UINT32:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + (oneofIntAt(message, offset));
+ }
+ break;
+ case 63: // ONEOF_ENUM:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + (oneofIntAt(message, offset));
+ }
+ break;
+ case 64: // ONEOF_SFIXED32:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + (oneofIntAt(message, offset));
+ }
+ break;
+ case 65: // ONEOF_SFIXED64:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + Internal.hashLong(oneofLongAt(message, offset));
+ }
+ break;
+ case 66: // ONEOF_SINT32:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + (oneofIntAt(message, offset));
+ }
+ break;
+ case 67: // ONEOF_SINT64:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ hashCode = (hashCode * 53) + Internal.hashLong(oneofLongAt(message, offset));
+ }
+ break;
+ case 68: // ONEOF_GROUP:
+ if (isOneofPresent(message, entryNumber, pos)) {
+ Object submessage = UnsafeUtil.getObject(message, offset);
+ hashCode = (53 * hashCode) + submessage.hashCode();
+ }
+ break;
+ default:
+ // Assume it's an empty entry - just go to the next entry.
+ break;
+ }
+ }
+
+ hashCode = (hashCode * 53) + unknownFieldSchema.getFromMessage(message).hashCode();
+
+ if (hasExtensions) {
+ hashCode = (hashCode * 53) + extensionSchema.getExtensions(message).hashCode();
+ }
+
+ return hashCode;
+ }
+
+ @Override
+ public void mergeFrom(T message, T other) {
+ if (other == null) {
+ throw new NullPointerException();
+ }
+ for (int i = 0; i < buffer.length; i += INTS_PER_FIELD) {
+ // A separate method allows for better JIT optimizations
+ mergeSingleField(message, other, i);
+ }
+
+ if (!proto3) {
+ SchemaUtil.mergeUnknownFields(unknownFieldSchema, message, other);
+
+ if (hasExtensions) {
+ SchemaUtil.mergeExtensions(extensionSchema, message, other);
+ }
+ }
+ }
+
+ private void mergeSingleField(T message, T other, int pos) {
+ final int typeAndOffset = typeAndOffsetAt(pos);
+ final long offset = offset(typeAndOffset);
+ final int number = numberAt(pos);
+
+ switch (type(typeAndOffset)) {
+ case 0: // DOUBLE:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putDouble(message, offset, UnsafeUtil.getDouble(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 1: // FLOAT:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putFloat(message, offset, UnsafeUtil.getFloat(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 2: // INT64:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putLong(message, offset, UnsafeUtil.getLong(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 3: // UINT64:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putLong(message, offset, UnsafeUtil.getLong(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 4: // INT32:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putInt(message, offset, UnsafeUtil.getInt(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 5: // FIXED64:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putLong(message, offset, UnsafeUtil.getLong(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 6: // FIXED32:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putInt(message, offset, UnsafeUtil.getInt(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 7: // BOOL:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putBoolean(message, offset, UnsafeUtil.getBoolean(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 8: // STRING:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putObject(message, offset, UnsafeUtil.getObject(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 9: // MESSAGE:
+ mergeMessage(message, other, pos);
+ break;
+ case 10: // BYTES:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putObject(message, offset, UnsafeUtil.getObject(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 11: // UINT32:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putInt(message, offset, UnsafeUtil.getInt(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 12: // ENUM:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putInt(message, offset, UnsafeUtil.getInt(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 13: // SFIXED32:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putInt(message, offset, UnsafeUtil.getInt(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 14: // SFIXED64:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putLong(message, offset, UnsafeUtil.getLong(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 15: // SINT32:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putInt(message, offset, UnsafeUtil.getInt(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 16: // SINT64:
+ if (isFieldPresent(other, pos)) {
+ UnsafeUtil.putLong(message, offset, UnsafeUtil.getLong(other, offset));
+ setFieldPresent(message, pos);
+ }
+ break;
+ case 17: // GROUP:
+ mergeMessage(message, other, pos);
+ break;
+ case 18: // DOUBLE_LIST:
+ case 19: // FLOAT_LIST:
+ case 20: // INT64_LIST:
+ case 21: // UINT64_LIST:
+ case 22: // INT32_LIST:
+ case 23: // FIXED64_LIST:
+ case 24: // FIXED32_LIST:
+ case 25: // BOOL_LIST:
+ case 26: // STRING_LIST:
+ case 27: // MESSAGE_LIST:
+ case 28: // BYTES_LIST:
+ case 29: // UINT32_LIST:
+ case 30: // ENUM_LIST:
+ case 31: // SFIXED32_LIST:
+ case 32: // SFIXED64_LIST:
+ case 33: // SINT32_LIST:
+ case 34: // SINT64_LIST:
+ case 35: // DOUBLE_LIST_PACKED:
+ case 36: // FLOAT_LIST_PACKED:
+ case 37: // INT64_LIST_PACKED:
+ case 38: // UINT64_LIST_PACKED:
+ case 39: // INT32_LIST_PACKED:
+ case 40: // FIXED64_LIST_PACKED:
+ case 41: // FIXED32_LIST_PACKED:
+ case 42: // BOOL_LIST_PACKED:
+ case 43: // UINT32_LIST_PACKED:
+ case 44: // ENUM_LIST_PACKED:
+ case 45: // SFIXED32_LIST_PACKED:
+ case 46: // SFIXED64_LIST_PACKED:
+ case 47: // SINT32_LIST_PACKED:
+ case 48: // SINT64_LIST_PACKED:
+ case 49: // GROUP_LIST:
+ listFieldSchema.mergeListsAt(message, other, offset);
+ break;
+ case 50: // MAP:
+ SchemaUtil.mergeMap(mapFieldSchema, message, other, offset);
+ break;
+ case 51: // ONEOF_DOUBLE:
+ case 52: // ONEOF_FLOAT:
+ case 53: // ONEOF_INT64:
+ case 54: // ONEOF_UINT64:
+ case 55: // ONEOF_INT32:
+ case 56: // ONEOF_FIXED64:
+ case 57: // ONEOF_FIXED32:
+ case 58: // ONEOF_BOOL:
+ case 59: // ONEOF_STRING:
+ if (isOneofPresent(other, number, pos)) {
+ UnsafeUtil.putObject(message, offset, UnsafeUtil.getObject(other, offset));
+ setOneofPresent(message, number, pos);
+ }
+ break;
+
+ case 60: // ONEOF_MESSAGE:
+ mergeOneofMessage(message, other, pos);
+ break;
+ case 61: // ONEOF_BYTES:
+ case 62: // ONEOF_UINT32:
+ case 63: // ONEOF_ENUM:
+ case 64: // ONEOF_SFIXED32:
+ case 65: // ONEOF_SFIXED64:
+ case 66: // ONEOF_SINT32:
+ case 67: // ONEOF_SINT64:
+ if (isOneofPresent(other, number, pos)) {
+ UnsafeUtil.putObject(message, offset, UnsafeUtil.getObject(other, offset));
+ setOneofPresent(message, number, pos);
+ }
+ break;
+ case 68: // ONEOF_GROUP:
+ mergeOneofMessage(message, other, pos);
+ break;
+ default:
+ break;
+ }
+ }
+
+ private void mergeMessage(T message, T other, int pos) {
+ final int typeAndOffset = typeAndOffsetAt(pos);
+ final long offset = offset(typeAndOffset);
+
+ if (!isFieldPresent(other, pos)) {
+ return;
+ }
+
+ Object mine = UnsafeUtil.getObject(message, offset);
+ Object theirs = UnsafeUtil.getObject(other, offset);
+ if (mine != null && theirs != null) {
+ Object merged = Internal.mergeMessage(mine, theirs);
+ UnsafeUtil.putObject(message, offset, merged);
+ setFieldPresent(message, pos);
+ } else if (theirs != null) {
+ UnsafeUtil.putObject(message, offset, theirs);
+ setFieldPresent(message, pos);
+ }
+ }
+
+ private void mergeOneofMessage(T message, T other, int pos) {
+ int typeAndOffset = typeAndOffsetAt(pos);
+ int number = numberAt(pos);
+ long offset = offset(typeAndOffset);
+
+ if (!isOneofPresent(other, number, pos)) {
+ return;
+ }
+
+ Object mine = UnsafeUtil.getObject(message, offset);
+ Object theirs = UnsafeUtil.getObject(other, offset);
+ if (mine != null && theirs != null) {
+ Object merged = Internal.mergeMessage(mine, theirs);
+ UnsafeUtil.putObject(message, offset, merged);
+ setOneofPresent(message, number, pos);
+ } else if (theirs != null) {
+ UnsafeUtil.putObject(message, offset, theirs);
+ setOneofPresent(message, number, pos);
+ }
+ }
+
+ @Override
+ public int getSerializedSize(T message) {
+ return proto3 ? getSerializedSizeProto3(message) : getSerializedSizeProto2(message);
+ }
+
+ @SuppressWarnings("unchecked")
+ private int getSerializedSizeProto2(T message) {
+ int size = 0;
+
+ final sun.misc.Unsafe unsafe = UNSAFE;
+ int currentPresenceFieldOffset = -1;
+ int currentPresenceField = 0;
+ for (int i = 0; i < buffer.length; i += INTS_PER_FIELD) {
+ final int typeAndOffset = typeAndOffsetAt(i);
+ final int number = numberAt(i);
+
+ int fieldType = type(typeAndOffset);
+ int presenceMaskAndOffset = 0;
+ int presenceMask = 0;
+ if (fieldType <= 17) {
+ presenceMaskAndOffset = buffer[i + 2];
+ final int presenceFieldOffset = presenceMaskAndOffset & OFFSET_MASK;
+ presenceMask = 1 << (presenceMaskAndOffset >>> OFFSET_BITS);
+ if (presenceFieldOffset != currentPresenceFieldOffset) {
+ currentPresenceFieldOffset = presenceFieldOffset;
+ currentPresenceField = unsafe.getInt(message, (long) presenceFieldOffset);
+ }
+ } else if (useCachedSizeField
+ && fieldType >= FieldType.DOUBLE_LIST_PACKED.id()
+ && fieldType <= FieldType.SINT64_LIST_PACKED.id()) {
+ presenceMaskAndOffset = buffer[i + 2] & OFFSET_MASK;
+ }
+
+ final long offset = offset(typeAndOffset);
+
+ switch (fieldType) {
+ case 0: // DOUBLE:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeDoubleSize(number, 0);
+ }
+ break;
+ case 1: // FLOAT:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeFloatSize(number, 0);
+ }
+ break;
+ case 2: // INT64:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeInt64Size(number, unsafe.getLong(message, offset));
+ }
+ break;
+ case 3: // UINT64:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeUInt64Size(number, unsafe.getLong(message, offset));
+ }
+ break;
+ case 4: // INT32:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeInt32Size(number, unsafe.getInt(message, offset));
+ }
+ break;
+ case 5: // FIXED64:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeFixed64Size(number, 0);
+ }
+ break;
+ case 6: // FIXED32:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeFixed32Size(number, 0);
+ }
+ break;
+ case 7: // BOOL:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeBoolSize(number, true);
+ }
+ break;
+ case 8: // STRING:
+ if ((currentPresenceField & presenceMask) != 0) {
+ Object value = unsafe.getObject(message, offset);
+ if (value instanceof ByteString) {
+ size += CodedOutputStream.computeBytesSize(number, (ByteString) value);
+ } else {
+ size += CodedOutputStream.computeStringSize(number, (String) value);
+ }
+ }
+ break;
+ case 9: // MESSAGE:
+ if ((currentPresenceField & presenceMask) != 0) {
+ Object value = unsafe.getObject(message, offset);
+ size += SchemaUtil.computeSizeMessage(number, value, getMessageFieldSchema(i));
+ }
+ break;
+ case 10: // BYTES:
+ if ((currentPresenceField & presenceMask) != 0) {
+ ByteString value = (ByteString) unsafe.getObject(message, offset);
+ size += CodedOutputStream.computeBytesSize(number, value);
+ }
+ break;
+ case 11: // UINT32:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeUInt32Size(number, unsafe.getInt(message, offset));
+ }
+ break;
+ case 12: // ENUM:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeEnumSize(number, unsafe.getInt(message, offset));
+ }
+ break;
+ case 13: // SFIXED32:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeSFixed32Size(number, 0);
+ }
+ break;
+ case 14: // SFIXED64:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeSFixed64Size(number, 0);
+ }
+ break;
+ case 15: // SINT32:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeSInt32Size(number, unsafe.getInt(message, offset));
+ }
+ break;
+ case 16: // SINT64:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size += CodedOutputStream.computeSInt64Size(number, unsafe.getLong(message, offset));
+ }
+ break;
+ case 17: // GROUP:
+ if ((currentPresenceField & presenceMask) != 0) {
+ size +=
+ CodedOutputStream.computeGroupSize(
+ number,
+ (MessageLite) unsafe.getObject(message, offset),
+ getMessageFieldSchema(i));
+ }
+ break;
+ case 18: // DOUBLE_LIST:
+ size +=
+ SchemaUtil.computeSizeFixed64List(
+ number, (List<?>) unsafe.getObject(message, offset), false);
+ break;
+ case 19: // FLOAT_LIST:
+ size +=
+ SchemaUtil.computeSizeFixed32List(
+ number, (List<?>) unsafe.getObject(message, offset), false);
+ break;
+ case 20: // INT64_LIST:
+ size +=
+ SchemaUtil.computeSizeInt64List(
+ number, (List<Long>) unsafe.getObject(message, offset), false);
+ break;
+ case 21: // UINT64_LIST:
+ size +=
+ SchemaUtil.computeSizeUInt64List(
+ number, (List<Long>) unsafe.getObject(message, offset), false);
+ break;
+ case 22: // INT32_LIST:
+ size +=
+ SchemaUtil.computeSizeInt32List(
+ number, (List<Integer>) unsafe.getObject(message, offset), false);
+ break;
+ case 23: // FIXED64_LIST:
+ size +=
+ SchemaUtil.computeSizeFixed64List(
+ number, (List<?>) unsafe.getObject(message, offset), false);
+ break;
+ case 24: // FIXED32_LIST:
+ size +=
+ SchemaUtil.computeSizeFixed32List(
+ number, (List<?>) unsafe.getObject(message, offset), false);
+ break;
+ case 25: // BOOL_LIST:
+ size +=
+ SchemaUtil.computeSizeBoolList(
+ number, (List<?>) unsafe.getObject(message, offset), false);
+ break;
+ case 26: // STRING_LIST:
+ size +=
+ SchemaUtil.computeSizeStringList(number, (List<?>) unsafe.getObject(message, offset));
+ break;
+ case 27: // MESSAGE_LIST:
+ size +=
+ SchemaUtil.computeSizeMessageList(
+ number, (List<?>) unsafe.getObject(message, offset), getMessageFieldSchema(i));
+ break;
+ case 28: // BYTES_LIST:
+ size +=
+ SchemaUtil.computeSizeByteStringList(
+ number, (List<ByteString>) unsafe.getObject(message, offset));
+ break;
+ case 29: // UINT32_LIST:
+ size +=
+ SchemaUtil.computeSizeUInt32List(
+ number, (List<Integer>) unsafe.getObject(message, offset), false);
+ break;
+ case 30: // ENUM_LIST:
+ size +=
+ SchemaUtil.computeSizeEnumList(
+ number, (List<Integer>) unsafe.getObject(message, offset), false);
+ break;
+ case 31: // SFIXED32_LIST:
+ size +=
+ SchemaUtil.computeSizeFixed32List(
+ number, (List<Integer>) unsafe.getObject(message, offset), false);
+ break;
+ case 32: // SFIXED64_LIST:
+ size +=
+ SchemaUtil.computeSizeFixed64List(
+ number, (List<Long>) unsafe.getObject(message, offset), false);
+ break;
+ case 33: // SINT32_LIST:
+ size +=
+ SchemaUtil.computeSizeSInt32List(
+ number, (List<Integer>) unsafe.getObject(message, offset), false);
+ break;
+ case 34: // SINT64_LIST:
+ size +=
+ SchemaUtil.computeSizeSInt64List(
+ number, (List<Long>) unsafe.getObject(message, offset), false);
+ break;
+ case 35:
+ { // DOUBLE_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed64ListNoTag(
+ (List<Double>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 36:
+ { // FLOAT_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed32ListNoTag(
+ (List<Float>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 37:
+ { // INT64_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeInt64ListNoTag(
+ (List<Long>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 38:
+ { // UINT64_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeUInt64ListNoTag(
+ (List<Long>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 39:
+ { // INT32_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeInt32ListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 40:
+ { // FIXED64_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed64ListNoTag(
+ (List<Long>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 41:
+ { // FIXED32_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed32ListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 42:
+ { // BOOL_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeBoolListNoTag(
+ (List<Boolean>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 43:
+ { // UINT32_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeUInt32ListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 44:
+ { // ENUM_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeEnumListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 45:
+ { // SFIXED32_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed32ListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 46:
+ { // SFIXED64_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed64ListNoTag(
+ (List<Long>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 47:
+ { // SINT32_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeSInt32ListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 48:
+ { // SINT64_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeSInt64ListNoTag(
+ (List<Long>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) presenceMaskAndOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 49: // GROUP_LIST:
+ size +=
+ SchemaUtil.computeSizeGroupList(
+ number,
+ (List<MessageLite>) unsafe.getObject(message, offset),
+ getMessageFieldSchema(i));
+ break;
+ case 50: // MAP:
+ // TODO(dweis): Use schema cache.
+ size +=
+ mapFieldSchema.getSerializedSize(
+ number, unsafe.getObject(message, offset), getMapFieldDefaultEntry(i));
+ break;
+ case 51: // ONEOF_DOUBLE:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeDoubleSize(number, 0);
+ }
+ break;
+ case 52: // ONEOF_FLOAT:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeFloatSize(number, 0);
+ }
+ break;
+ case 53: // ONEOF_INT64:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeInt64Size(number, oneofLongAt(message, offset));
+ }
+ break;
+ case 54: // ONEOF_UINT64:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeUInt64Size(number, oneofLongAt(message, offset));
+ }
+ break;
+ case 55: // ONEOF_INT32:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeInt32Size(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 56: // ONEOF_FIXED64:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeFixed64Size(number, 0);
+ }
+ break;
+ case 57: // ONEOF_FIXED32:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeFixed32Size(number, 0);
+ }
+ break;
+ case 58: // ONEOF_BOOL:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeBoolSize(number, true);
+ }
+ break;
+ case 59: // ONEOF_STRING:
+ if (isOneofPresent(message, number, i)) {
+ Object value = unsafe.getObject(message, offset);
+ if (value instanceof ByteString) {
+ size += CodedOutputStream.computeBytesSize(number, (ByteString) value);
+ } else {
+ size += CodedOutputStream.computeStringSize(number, (String) value);
+ }
+ }
+ break;
+ case 60: // ONEOF_MESSAGE:
+ if (isOneofPresent(message, number, i)) {
+ Object value = unsafe.getObject(message, offset);
+ size += SchemaUtil.computeSizeMessage(number, value, getMessageFieldSchema(i));
+ }
+ break;
+ case 61: // ONEOF_BYTES:
+ if (isOneofPresent(message, number, i)) {
+ size +=
+ CodedOutputStream.computeBytesSize(
+ number, (ByteString) unsafe.getObject(message, offset));
+ }
+ break;
+ case 62: // ONEOF_UINT32:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeUInt32Size(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 63: // ONEOF_ENUM:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeEnumSize(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 64: // ONEOF_SFIXED32:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeSFixed32Size(number, 0);
+ }
+ break;
+ case 65: // ONEOF_SFIXED64:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeSFixed64Size(number, 0);
+ }
+ break;
+ case 66: // ONEOF_SINT32:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeSInt32Size(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 67: // ONEOF_SINT64:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeSInt64Size(number, oneofLongAt(message, offset));
+ }
+ break;
+ case 68: // ONEOF_GROUP:
+ if (isOneofPresent(message, number, i)) {
+ size +=
+ CodedOutputStream.computeGroupSize(
+ number,
+ (MessageLite) unsafe.getObject(message, offset),
+ getMessageFieldSchema(i));
+ }
+ break;
+ default:
+ // Assume it's an empty entry.
+ }
+ }
+
+ size += getUnknownFieldsSerializedSize(unknownFieldSchema, message);
+
+ if (hasExtensions) {
+ size += extensionSchema.getExtensions(message).getSerializedSize();
+ }
+
+ return size;
+ }
+
+ private int getSerializedSizeProto3(T message) {
+ final sun.misc.Unsafe unsafe = UNSAFE;
+ int size = 0;
+ for (int i = 0; i < buffer.length; i += INTS_PER_FIELD) {
+ final int typeAndOffset = typeAndOffsetAt(i);
+ final int fieldType = type(typeAndOffset);
+ final int number = numberAt(i);
+
+ final long offset = offset(typeAndOffset);
+ final int cachedSizeOffset =
+ fieldType >= FieldType.DOUBLE_LIST_PACKED.id()
+ && fieldType <= FieldType.SINT64_LIST_PACKED.id()
+ ? buffer[i + 2] & OFFSET_MASK
+ : 0;
+
+ switch (fieldType) {
+ case 0: // DOUBLE:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeDoubleSize(number, 0);
+ }
+ break;
+ case 1: // FLOAT:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeFloatSize(number, 0);
+ }
+ break;
+ case 2: // INT64:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeInt64Size(number, UnsafeUtil.getLong(message, offset));
+ }
+ break;
+ case 3: // UINT64:
+ if (isFieldPresent(message, i)) {
+ size +=
+ CodedOutputStream.computeUInt64Size(number, UnsafeUtil.getLong(message, offset));
+ }
+ break;
+ case 4: // INT32:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeInt32Size(number, UnsafeUtil.getInt(message, offset));
+ }
+ break;
+ case 5: // FIXED64:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeFixed64Size(number, 0);
+ }
+ break;
+ case 6: // FIXED32:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeFixed32Size(number, 0);
+ }
+ break;
+ case 7: // BOOL:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeBoolSize(number, true);
+ }
+ break;
+ case 8: // STRING:
+ if (isFieldPresent(message, i)) {
+ Object value = UnsafeUtil.getObject(message, offset);
+ if (value instanceof ByteString) {
+ size += CodedOutputStream.computeBytesSize(number, (ByteString) value);
+ } else {
+ size += CodedOutputStream.computeStringSize(number, (String) value);
+ }
+ }
+ break;
+ case 9: // MESSAGE:
+ if (isFieldPresent(message, i)) {
+ Object value = UnsafeUtil.getObject(message, offset);
+ size += SchemaUtil.computeSizeMessage(number, value, getMessageFieldSchema(i));
+ }
+ break;
+ case 10: // BYTES:
+ if (isFieldPresent(message, i)) {
+ ByteString value = (ByteString) UnsafeUtil.getObject(message, offset);
+ size += CodedOutputStream.computeBytesSize(number, value);
+ }
+ break;
+ case 11: // UINT32:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeUInt32Size(number, UnsafeUtil.getInt(message, offset));
+ }
+ break;
+ case 12: // ENUM:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeEnumSize(number, UnsafeUtil.getInt(message, offset));
+ }
+ break;
+ case 13: // SFIXED32:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeSFixed32Size(number, 0);
+ }
+ break;
+ case 14: // SFIXED64:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeSFixed64Size(number, 0);
+ }
+ break;
+ case 15: // SINT32:
+ if (isFieldPresent(message, i)) {
+ size += CodedOutputStream.computeSInt32Size(number, UnsafeUtil.getInt(message, offset));
+ }
+ break;
+ case 16: // SINT64:
+ if (isFieldPresent(message, i)) {
+ size +=
+ CodedOutputStream.computeSInt64Size(number, UnsafeUtil.getLong(message, offset));
+ }
+ break;
+ case 17: // GROUP:
+ if (isFieldPresent(message, i)) {
+ size +=
+ CodedOutputStream.computeGroupSize(
+ number,
+ (MessageLite) UnsafeUtil.getObject(message, offset),
+ getMessageFieldSchema(i));
+ }
+ break;
+ case 18: // DOUBLE_LIST:
+ size += SchemaUtil.computeSizeFixed64List(number, listAt(message, offset), false);
+ break;
+ case 19: // FLOAT_LIST:
+ size += SchemaUtil.computeSizeFixed32List(number, listAt(message, offset), false);
+ break;
+ case 20: // INT64_LIST:
+ size +=
+ SchemaUtil.computeSizeInt64List(number, (List<Long>) listAt(message, offset), false);
+ break;
+ case 21: // UINT64_LIST:
+ size +=
+ SchemaUtil.computeSizeUInt64List(number, (List<Long>) listAt(message, offset), false);
+ break;
+ case 22: // INT32_LIST:
+ size +=
+ SchemaUtil.computeSizeInt32List(
+ number, (List<Integer>) listAt(message, offset), false);
+ break;
+ case 23: // FIXED64_LIST:
+ size += SchemaUtil.computeSizeFixed64List(number, listAt(message, offset), false);
+ break;
+ case 24: // FIXED32_LIST:
+ size += SchemaUtil.computeSizeFixed32List(number, listAt(message, offset), false);
+ break;
+ case 25: // BOOL_LIST:
+ size += SchemaUtil.computeSizeBoolList(number, listAt(message, offset), false);
+ break;
+ case 26: // STRING_LIST:
+ size += SchemaUtil.computeSizeStringList(number, listAt(message, offset));
+ break;
+ case 27: // MESSAGE_LIST:
+ size +=
+ SchemaUtil.computeSizeMessageList(
+ number, listAt(message, offset), getMessageFieldSchema(i));
+ break;
+ case 28: // BYTES_LIST:
+ size +=
+ SchemaUtil.computeSizeByteStringList(
+ number, (List<ByteString>) listAt(message, offset));
+ break;
+ case 29: // UINT32_LIST:
+ size +=
+ SchemaUtil.computeSizeUInt32List(
+ number, (List<Integer>) listAt(message, offset), false);
+ break;
+ case 30: // ENUM_LIST:
+ size +=
+ SchemaUtil.computeSizeEnumList(
+ number, (List<Integer>) listAt(message, offset), false);
+ break;
+ case 31: // SFIXED32_LIST:
+ size += SchemaUtil.computeSizeFixed32List(number, listAt(message, offset), false);
+ break;
+ case 32: // SFIXED64_LIST:
+ size += SchemaUtil.computeSizeFixed64List(number, listAt(message, offset), false);
+ break;
+ case 33: // SINT32_LIST:
+ size +=
+ SchemaUtil.computeSizeSInt32List(
+ number, (List<Integer>) listAt(message, offset), false);
+ break;
+ case 34: // SINT64_LIST:
+ size +=
+ SchemaUtil.computeSizeSInt64List(number, (List<Long>) listAt(message, offset), false);
+ break;
+ case 35:
+ { // DOUBLE_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed64ListNoTag(
+ (List<Double>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 36:
+ { // FLOAT_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed32ListNoTag(
+ (List<Float>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 37:
+ { // INT64_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeInt64ListNoTag(
+ (List<Long>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 38:
+ { // UINT64_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeUInt64ListNoTag(
+ (List<Long>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 39:
+ { // INT32_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeInt32ListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 40:
+ { // FIXED64_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed64ListNoTag(
+ (List<Long>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 41:
+ { // FIXED32_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed32ListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 42:
+ { // BOOL_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeBoolListNoTag(
+ (List<Boolean>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 43:
+ { // UINT32_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeUInt32ListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 44:
+ { // ENUM_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeEnumListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 45:
+ { // SFIXED32_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed32ListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 46:
+ { // SFIXED64_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeFixed64ListNoTag(
+ (List<Long>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 47:
+ { // SINT32_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeSInt32ListNoTag(
+ (List<Integer>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 48:
+ { // SINT64_LIST_PACKED:
+ int fieldSize =
+ SchemaUtil.computeSizeSInt64ListNoTag(
+ (List<Long>) unsafe.getObject(message, offset));
+ if (fieldSize > 0) {
+ if (useCachedSizeField) {
+ unsafe.putInt(message, (long) cachedSizeOffset, fieldSize);
+ }
+ size +=
+ CodedOutputStream.computeTagSize(number)
+ + CodedOutputStream.computeUInt32SizeNoTag(fieldSize)
+ + fieldSize;
+ }
+ break;
+ }
+ case 49: // GROUP_LIST:
+ size +=
+ SchemaUtil.computeSizeGroupList(
+ number, (List<MessageLite>) listAt(message, offset), getMessageFieldSchema(i));
+ break;
+ case 50: // MAP:
+ // TODO(dweis): Use schema cache.
+ size +=
+ mapFieldSchema.getSerializedSize(
+ number, UnsafeUtil.getObject(message, offset), getMapFieldDefaultEntry(i));
+ break;
+ case 51: // ONEOF_DOUBLE:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeDoubleSize(number, 0);
+ }
+ break;
+ case 52: // ONEOF_FLOAT:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeFloatSize(number, 0);
+ }
+ break;
+ case 53: // ONEOF_INT64:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeInt64Size(number, oneofLongAt(message, offset));
+ }
+ break;
+ case 54: // ONEOF_UINT64:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeUInt64Size(number, oneofLongAt(message, offset));
+ }
+ break;
+ case 55: // ONEOF_INT32:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeInt32Size(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 56: // ONEOF_FIXED64:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeFixed64Size(number, 0);
+ }
+ break;
+ case 57: // ONEOF_FIXED32:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeFixed32Size(number, 0);
+ }
+ break;
+ case 58: // ONEOF_BOOL:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeBoolSize(number, true);
+ }
+ break;
+ case 59: // ONEOF_STRING:
+ if (isOneofPresent(message, number, i)) {
+ Object value = UnsafeUtil.getObject(message, offset);
+ if (value instanceof ByteString) {
+ size += CodedOutputStream.computeBytesSize(number, (ByteString) value);
+ } else {
+ size += CodedOutputStream.computeStringSize(number, (String) value);
+ }
+ }
+ break;
+ case 60: // ONEOF_MESSAGE:
+ if (isOneofPresent(message, number, i)) {
+ Object value = UnsafeUtil.getObject(message, offset);
+ size += SchemaUtil.computeSizeMessage(number, value, getMessageFieldSchema(i));
+ }
+ break;
+ case 61: // ONEOF_BYTES:
+ if (isOneofPresent(message, number, i)) {
+ size +=
+ CodedOutputStream.computeBytesSize(
+ number, (ByteString) UnsafeUtil.getObject(message, offset));
+ }
+ break;
+ case 62: // ONEOF_UINT32:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeUInt32Size(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 63: // ONEOF_ENUM:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeEnumSize(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 64: // ONEOF_SFIXED32:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeSFixed32Size(number, 0);
+ }
+ break;
+ case 65: // ONEOF_SFIXED64:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeSFixed64Size(number, 0);
+ }
+ break;
+ case 66: // ONEOF_SINT32:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeSInt32Size(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 67: // ONEOF_SINT64:
+ if (isOneofPresent(message, number, i)) {
+ size += CodedOutputStream.computeSInt64Size(number, oneofLongAt(message, offset));
+ }
+ break;
+ case 68: // ONEOF_GROUP:
+ if (isOneofPresent(message, number, i)) {
+ size +=
+ CodedOutputStream.computeGroupSize(
+ number,
+ (MessageLite) UnsafeUtil.getObject(message, offset),
+ getMessageFieldSchema(i));
+ }
+ break;
+ default:
+ // Assume it's an empty entry.
+ }
+ }
+
+ size += getUnknownFieldsSerializedSize(unknownFieldSchema, message);
+
+ return size;
+ }
+
+ private <UT, UB> int getUnknownFieldsSerializedSize(
+ UnknownFieldSchema<UT, UB> schema, T message) {
+ UT unknowns = schema.getFromMessage(message);
+ return schema.getSerializedSize(unknowns);
+ }
+
+ private static List<?> listAt(Object message, long offset) {
+ return (List<?>) UnsafeUtil.getObject(message, offset);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ // TODO(nathanmittler): Consider serializing oneof fields last so that only one entry per
+ // oneof is actually serialized. This would mean that we would violate the serialization order
+ // contract. It should also be noted that Go currently does this.
+ public void writeTo(T message, Writer writer) throws IOException {
+ if (writer.fieldOrder() == Writer.FieldOrder.DESCENDING) {
+ writeFieldsInDescendingOrder(message, writer);
+ } else {
+ if (proto3) {
+ writeFieldsInAscendingOrderProto3(message, writer);
+ } else {
+ writeFieldsInAscendingOrderProto2(message, writer);
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private void writeFieldsInAscendingOrderProto2(T message, Writer writer) throws IOException {
+ Iterator<? extends Map.Entry<?, ?>> extensionIterator = null;
+ Map.Entry nextExtension = null;
+ if (hasExtensions) {
+ FieldSet<?> extensions = extensionSchema.getExtensions(message);
+ if (!extensions.isEmpty()) {
+ extensionIterator = extensions.iterator();
+ nextExtension = extensionIterator.next();
+ }
+ }
+ int currentPresenceFieldOffset = -1;
+ int currentPresenceField = 0;
+ final int bufferLength = buffer.length;
+ final sun.misc.Unsafe unsafe = UNSAFE;
+ for (int pos = 0; pos < bufferLength; pos += INTS_PER_FIELD) {
+ final int typeAndOffset = typeAndOffsetAt(pos);
+ final int number = numberAt(pos);
+ final int fieldType = type(typeAndOffset);
+
+ int presenceMaskAndOffset = 0;
+ int presenceMask = 0;
+ if (!proto3 && fieldType <= 17) {
+ presenceMaskAndOffset = buffer[pos + 2];
+ final int presenceFieldOffset = presenceMaskAndOffset & OFFSET_MASK;
+ if (presenceFieldOffset != currentPresenceFieldOffset) {
+ currentPresenceFieldOffset = presenceFieldOffset;
+ currentPresenceField = unsafe.getInt(message, (long) presenceFieldOffset);
+ }
+ presenceMask = 1 << (presenceMaskAndOffset >>> OFFSET_BITS);
+ }
+
+ // Write any extensions that need to be written before the current field.
+ while (nextExtension != null && extensionSchema.extensionNumber(nextExtension) <= number) {
+ extensionSchema.serializeExtension(writer, nextExtension);
+ nextExtension = extensionIterator.hasNext() ? extensionIterator.next() : null;
+ }
+ final long offset = offset(typeAndOffset);
+
+ switch (fieldType) {
+ case 0: // DOUBLE:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeDouble(number, doubleAt(message, offset));
+ }
+ break;
+ case 1: // FLOAT:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeFloat(number, floatAt(message, offset));
+ }
+ break;
+ case 2: // INT64:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeInt64(number, unsafe.getLong(message, offset));
+ }
+ break;
+ case 3: // UINT64:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeUInt64(number, unsafe.getLong(message, offset));
+ }
+ break;
+ case 4: // INT32:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeInt32(number, unsafe.getInt(message, offset));
+ }
+ break;
+ case 5: // FIXED64:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeFixed64(number, unsafe.getLong(message, offset));
+ }
+ break;
+ case 6: // FIXED32:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeFixed32(number, unsafe.getInt(message, offset));
+ }
+ break;
+ case 7: // BOOL:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeBool(number, booleanAt(message, offset));
+ }
+ break;
+ case 8: // STRING:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writeString(number, unsafe.getObject(message, offset), writer);
+ }
+ break;
+ case 9: // MESSAGE:
+ if ((currentPresenceField & presenceMask) != 0) {
+ Object value = unsafe.getObject(message, offset);
+ writer.writeMessage(number, value, getMessageFieldSchema(pos));
+ }
+ break;
+ case 10: // BYTES:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeBytes(number, (ByteString) unsafe.getObject(message, offset));
+ }
+ break;
+ case 11: // UINT32:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeUInt32(number, unsafe.getInt(message, offset));
+ }
+ break;
+ case 12: // ENUM:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeEnum(number, unsafe.getInt(message, offset));
+ }
+ break;
+ case 13: // SFIXED32:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeSFixed32(number, unsafe.getInt(message, offset));
+ }
+ break;
+ case 14: // SFIXED64:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeSFixed64(number, unsafe.getLong(message, offset));
+ }
+ break;
+ case 15: // SINT32:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeSInt32(number, unsafe.getInt(message, offset));
+ }
+ break;
+ case 16: // SINT64:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeSInt64(number, unsafe.getLong(message, offset));
+ }
+ break;
+ case 17: // GROUP:
+ if ((currentPresenceField & presenceMask) != 0) {
+ writer.writeGroup(
+ number, unsafe.getObject(message, offset), getMessageFieldSchema(pos));
+ }
+ break;
+ case 18: // DOUBLE_LIST:
+ SchemaUtil.writeDoubleList(
+ numberAt(pos), (List<Double>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 19: // FLOAT_LIST:
+ SchemaUtil.writeFloatList(
+ numberAt(pos), (List<Float>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 20: // INT64_LIST:
+ SchemaUtil.writeInt64List(
+ numberAt(pos), (List<Long>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 21: // UINT64_LIST:
+ SchemaUtil.writeUInt64List(
+ numberAt(pos), (List<Long>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 22: // INT32_LIST:
+ SchemaUtil.writeInt32List(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 23: // FIXED64_LIST:
+ SchemaUtil.writeFixed64List(
+ numberAt(pos), (List<Long>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 24: // FIXED32_LIST:
+ SchemaUtil.writeFixed32List(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 25: // BOOL_LIST:
+ SchemaUtil.writeBoolList(
+ numberAt(pos), (List<Boolean>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 26: // STRING_LIST:
+ SchemaUtil.writeStringList(
+ numberAt(pos), (List<String>) unsafe.getObject(message, offset), writer);
+ break;
+ case 27: // MESSAGE_LIST:
+ SchemaUtil.writeMessageList(
+ numberAt(pos),
+ (List<?>) unsafe.getObject(message, offset),
+ writer,
+ getMessageFieldSchema(pos));
+ break;
+ case 28: // BYTES_LIST:
+ SchemaUtil.writeBytesList(
+ numberAt(pos), (List<ByteString>) unsafe.getObject(message, offset), writer);
+ break;
+ case 29: // UINT32_LIST:
+ SchemaUtil.writeUInt32List(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 30: // ENUM_LIST:
+ SchemaUtil.writeEnumList(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 31: // SFIXED32_LIST:
+ SchemaUtil.writeSFixed32List(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 32: // SFIXED64_LIST:
+ SchemaUtil.writeSFixed64List(
+ numberAt(pos), (List<Long>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 33: // SINT32_LIST:
+ SchemaUtil.writeSInt32List(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 34: // SINT64_LIST:
+ SchemaUtil.writeSInt64List(
+ numberAt(pos), (List<Long>) unsafe.getObject(message, offset), writer, false);
+ break;
+ case 35: // DOUBLE_LIST_PACKED:
+ // TODO(xiaofeng): Make use of cached field size to speed up serialization.
+ SchemaUtil.writeDoubleList(
+ numberAt(pos), (List<Double>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 36: // FLOAT_LIST_PACKED:
+ SchemaUtil.writeFloatList(
+ numberAt(pos), (List<Float>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 37: // INT64_LIST_PACKED:
+ SchemaUtil.writeInt64List(
+ numberAt(pos), (List<Long>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 38: // UINT64_LIST_PACKED:
+ SchemaUtil.writeUInt64List(
+ numberAt(pos), (List<Long>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 39: // INT32_LIST_PACKED:
+ SchemaUtil.writeInt32List(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 40: // FIXED64_LIST_PACKED:
+ SchemaUtil.writeFixed64List(
+ numberAt(pos), (List<Long>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 41: // FIXED32_LIST_PACKED:
+ SchemaUtil.writeFixed32List(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, true);
+
+ break;
+ case 42: // BOOL_LIST_PACKED:
+ SchemaUtil.writeBoolList(
+ numberAt(pos), (List<Boolean>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 43: // UINT32_LIST_PACKED:
+ SchemaUtil.writeUInt32List(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 44: // ENUM_LIST_PACKED:
+ SchemaUtil.writeEnumList(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 45: // SFIXED32_LIST_PACKED:
+ SchemaUtil.writeSFixed32List(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 46: // SFIXED64_LIST_PACKED:
+ SchemaUtil.writeSFixed64List(
+ numberAt(pos), (List<Long>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 47: // SINT32_LIST_PACKED:
+ SchemaUtil.writeSInt32List(
+ numberAt(pos), (List<Integer>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 48: // SINT64_LIST_PACKED:
+ SchemaUtil.writeSInt64List(
+ numberAt(pos), (List<Long>) unsafe.getObject(message, offset), writer, true);
+ break;
+ case 49: // GROUP_LIST:
+ SchemaUtil.writeGroupList(
+ numberAt(pos),
+ (List<?>) unsafe.getObject(message, offset),
+ writer,
+ getMessageFieldSchema(pos));
+ break;
+ case 50: // MAP:
+ // TODO(dweis): Use schema cache.
+ writeMapHelper(writer, number, unsafe.getObject(message, offset), pos);
+ break;
+ case 51: // ONEOF_DOUBLE:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeDouble(number, oneofDoubleAt(message, offset));
+ }
+ break;
+ case 52: // ONEOF_FLOAT:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeFloat(number, oneofFloatAt(message, offset));
+ }
+ break;
+ case 53: // ONEOF_INT64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeInt64(number, oneofLongAt(message, offset));
+ }
+ break;
+ case 54: // ONEOF_UINT64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeUInt64(number, oneofLongAt(message, offset));
+ }
+ break;
+ case 55: // ONEOF_INT32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeInt32(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 56: // ONEOF_FIXED64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeFixed64(number, oneofLongAt(message, offset));
+ }
+ break;
+ case 57: // ONEOF_FIXED32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeFixed32(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 58: // ONEOF_BOOL:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeBool(number, oneofBooleanAt(message, offset));
+ }
+ break;
+ case 59: // ONEOF_STRING:
+ if (isOneofPresent(message, number, pos)) {
+ writeString(number, unsafe.getObject(message, offset), writer);
+ }
+ break;
+ case 60: // ONEOF_MESSAGE:
+ if (isOneofPresent(message, number, pos)) {
+ Object value = unsafe.getObject(message, offset);
+ writer.writeMessage(number, value, getMessageFieldSchema(pos));
+ }
+ break;
+ case 61: // ONEOF_BYTES:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeBytes(number, (ByteString) unsafe.getObject(message, offset));
+ }
+ break;
+ case 62: // ONEOF_UINT32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeUInt32(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 63: // ONEOF_ENUM:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeEnum(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 64: // ONEOF_SFIXED32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSFixed32(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 65: // ONEOF_SFIXED64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSFixed64(number, oneofLongAt(message, offset));
+ }
+ break;
+ case 66: // ONEOF_SINT32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSInt32(number, oneofIntAt(message, offset));
+ }
+ break;
+ case 67: // ONEOF_SINT64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSInt64(number, oneofLongAt(message, offset));
+ }
+ break;
+ case 68: // ONEOF_GROUP:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeGroup(
+ number, unsafe.getObject(message, offset), getMessageFieldSchema(pos));
+ }
+ break;
+ default:
+ // Assume it's an empty entry - just go to the next entry.
+ break;
+ }
+ }
+ while (nextExtension != null) {
+ extensionSchema.serializeExtension(writer, nextExtension);
+ nextExtension = extensionIterator.hasNext() ? extensionIterator.next() : null;
+ }
+ writeUnknownInMessageTo(unknownFieldSchema, message, writer);
+ }
+
+ @SuppressWarnings("unchecked")
+ private void writeFieldsInAscendingOrderProto3(T message, Writer writer) throws IOException {
+ Iterator<? extends Map.Entry<?, ?>> extensionIterator = null;
+ Map.Entry nextExtension = null;
+ if (hasExtensions) {
+ FieldSet<?> extensions = extensionSchema.getExtensions(message);
+ if (!extensions.isEmpty()) {
+ extensionIterator = extensions.iterator();
+ nextExtension = extensionIterator.next();
+ }
+ }
+
+ final int bufferLength = buffer.length;
+ for (int pos = 0; pos < bufferLength; pos += INTS_PER_FIELD) {
+ final int typeAndOffset = typeAndOffsetAt(pos);
+ final int number = numberAt(pos);
+
+ // Write any extensions that need to be written before the current field.
+ while (nextExtension != null && extensionSchema.extensionNumber(nextExtension) <= number) {
+ extensionSchema.serializeExtension(writer, nextExtension);
+ nextExtension = extensionIterator.hasNext() ? extensionIterator.next() : null;
+ }
+
+ switch (type(typeAndOffset)) {
+ case 0: // DOUBLE:
+ if (isFieldPresent(message, pos)) {
+ writer.writeDouble(number, doubleAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 1: // FLOAT:
+ if (isFieldPresent(message, pos)) {
+ writer.writeFloat(number, floatAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 2: // INT64:
+ if (isFieldPresent(message, pos)) {
+ writer.writeInt64(number, longAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 3: // UINT64:
+ if (isFieldPresent(message, pos)) {
+ writer.writeUInt64(number, longAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 4: // INT32:
+ if (isFieldPresent(message, pos)) {
+ writer.writeInt32(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 5: // FIXED64:
+ if (isFieldPresent(message, pos)) {
+ writer.writeFixed64(number, longAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 6: // FIXED32:
+ if (isFieldPresent(message, pos)) {
+ writer.writeFixed32(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 7: // BOOL:
+ if (isFieldPresent(message, pos)) {
+ writer.writeBool(number, booleanAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 8: // STRING:
+ if (isFieldPresent(message, pos)) {
+ writeString(number, UnsafeUtil.getObject(message, offset(typeAndOffset)), writer);
+ }
+ break;
+ case 9: // MESSAGE:
+ if (isFieldPresent(message, pos)) {
+ Object value = UnsafeUtil.getObject(message, offset(typeAndOffset));
+ writer.writeMessage(number, value, getMessageFieldSchema(pos));
+ }
+ break;
+ case 10: // BYTES:
+ if (isFieldPresent(message, pos)) {
+ writer.writeBytes(
+ number, (ByteString) UnsafeUtil.getObject(message, offset(typeAndOffset)));
+ }
+ break;
+ case 11: // UINT32:
+ if (isFieldPresent(message, pos)) {
+ writer.writeUInt32(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 12: // ENUM:
+ if (isFieldPresent(message, pos)) {
+ writer.writeEnum(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 13: // SFIXED32:
+ if (isFieldPresent(message, pos)) {
+ writer.writeSFixed32(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 14: // SFIXED64:
+ if (isFieldPresent(message, pos)) {
+ writer.writeSFixed64(number, longAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 15: // SINT32:
+ if (isFieldPresent(message, pos)) {
+ writer.writeSInt32(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 16: // SINT64:
+ if (isFieldPresent(message, pos)) {
+ writer.writeSInt64(number, longAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 17: // GROUP:
+ if (isFieldPresent(message, pos)) {
+ writer.writeGroup(
+ number,
+ UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ getMessageFieldSchema(pos));
+ }
+ break;
+ case 18: // DOUBLE_LIST:
+ SchemaUtil.writeDoubleList(
+ numberAt(pos),
+ (List<Double>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 19: // FLOAT_LIST:
+ SchemaUtil.writeFloatList(
+ numberAt(pos),
+ (List<Float>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 20: // INT64_LIST:
+ SchemaUtil.writeInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 21: // UINT64_LIST:
+ SchemaUtil.writeUInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 22: // INT32_LIST:
+ SchemaUtil.writeInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 23: // FIXED64_LIST:
+ SchemaUtil.writeFixed64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 24: // FIXED32_LIST:
+ SchemaUtil.writeFixed32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 25: // BOOL_LIST:
+ SchemaUtil.writeBoolList(
+ numberAt(pos),
+ (List<Boolean>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 26: // STRING_LIST:
+ SchemaUtil.writeStringList(
+ numberAt(pos),
+ (List<String>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer);
+ break;
+ case 27: // MESSAGE_LIST:
+ SchemaUtil.writeMessageList(
+ numberAt(pos),
+ (List<?>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ getMessageFieldSchema(pos));
+ break;
+ case 28: // BYTES_LIST:
+ SchemaUtil.writeBytesList(
+ numberAt(pos),
+ (List<ByteString>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer);
+ break;
+ case 29: // UINT32_LIST:
+ SchemaUtil.writeUInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 30: // ENUM_LIST:
+ SchemaUtil.writeEnumList(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 31: // SFIXED32_LIST:
+ SchemaUtil.writeSFixed32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 32: // SFIXED64_LIST:
+ SchemaUtil.writeSFixed64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 33: // SINT32_LIST:
+ SchemaUtil.writeSInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 34: // SINT64_LIST:
+ SchemaUtil.writeSInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 35: // DOUBLE_LIST_PACKED:
+ // TODO(xiaofeng): Make use of cached field size to speed up serialization.
+ SchemaUtil.writeDoubleList(
+ numberAt(pos),
+ (List<Double>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 36: // FLOAT_LIST_PACKED:
+ SchemaUtil.writeFloatList(
+ numberAt(pos),
+ (List<Float>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 37: // INT64_LIST_PACKED:
+ SchemaUtil.writeInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 38: // UINT64_LIST_PACKED:
+ SchemaUtil.writeUInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 39: // INT32_LIST_PACKED:
+ SchemaUtil.writeInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 40: // FIXED64_LIST_PACKED:
+ SchemaUtil.writeFixed64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 41: // FIXED32_LIST_PACKED:
+ SchemaUtil.writeFixed32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+
+ break;
+ case 42: // BOOL_LIST_PACKED:
+ SchemaUtil.writeBoolList(
+ numberAt(pos),
+ (List<Boolean>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 43: // UINT32_LIST_PACKED:
+ SchemaUtil.writeUInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 44: // ENUM_LIST_PACKED:
+ SchemaUtil.writeEnumList(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 45: // SFIXED32_LIST_PACKED:
+ SchemaUtil.writeSFixed32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 46: // SFIXED64_LIST_PACKED:
+ SchemaUtil.writeSFixed64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 47: // SINT32_LIST_PACKED:
+ SchemaUtil.writeSInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 48: // SINT64_LIST_PACKED:
+ SchemaUtil.writeSInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 49: // GROUP_LIST:
+ SchemaUtil.writeGroupList(
+ numberAt(pos),
+ (List<?>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ getMessageFieldSchema(pos));
+ break;
+ case 50: // MAP:
+ // TODO(dweis): Use schema cache.
+ writeMapHelper(writer, number, UnsafeUtil.getObject(message, offset(typeAndOffset)), pos);
+ break;
+ case 51: // ONEOF_DOUBLE:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeDouble(number, oneofDoubleAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 52: // ONEOF_FLOAT:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeFloat(number, oneofFloatAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 53: // ONEOF_INT64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeInt64(number, oneofLongAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 54: // ONEOF_UINT64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeUInt64(number, oneofLongAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 55: // ONEOF_INT32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeInt32(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 56: // ONEOF_FIXED64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeFixed64(number, oneofLongAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 57: // ONEOF_FIXED32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeFixed32(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 58: // ONEOF_BOOL:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeBool(number, oneofBooleanAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 59: // ONEOF_STRING:
+ if (isOneofPresent(message, number, pos)) {
+ writeString(number, UnsafeUtil.getObject(message, offset(typeAndOffset)), writer);
+ }
+ break;
+ case 60: // ONEOF_MESSAGE:
+ if (isOneofPresent(message, number, pos)) {
+ Object value = UnsafeUtil.getObject(message, offset(typeAndOffset));
+ writer.writeMessage(number, value, getMessageFieldSchema(pos));
+ }
+ break;
+ case 61: // ONEOF_BYTES:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeBytes(
+ number, (ByteString) UnsafeUtil.getObject(message, offset(typeAndOffset)));
+ }
+ break;
+ case 62: // ONEOF_UINT32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeUInt32(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 63: // ONEOF_ENUM:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeEnum(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 64: // ONEOF_SFIXED32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSFixed32(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 65: // ONEOF_SFIXED64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSFixed64(number, oneofLongAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 66: // ONEOF_SINT32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSInt32(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 67: // ONEOF_SINT64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSInt64(number, oneofLongAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 68: // ONEOF_GROUP:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeGroup(
+ number,
+ UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ getMessageFieldSchema(pos));
+ }
+ break;
+ default:
+ // Assume it's an empty entry - just go to the next entry.
+ break;
+ }
+ }
+ while (nextExtension != null) {
+ extensionSchema.serializeExtension(writer, nextExtension);
+ nextExtension = extensionIterator.hasNext() ? extensionIterator.next() : null;
+ }
+ writeUnknownInMessageTo(unknownFieldSchema, message, writer);
+ }
+
+ @SuppressWarnings("unchecked")
+ private void writeFieldsInDescendingOrder(T message, Writer writer) throws IOException {
+ writeUnknownInMessageTo(unknownFieldSchema, message, writer);
+
+ Iterator<? extends Map.Entry<?, ?>> extensionIterator = null;
+ Map.Entry nextExtension = null;
+ if (hasExtensions) {
+ FieldSet<?> extensions = extensionSchema.getExtensions(message);
+ if (!extensions.isEmpty()) {
+ extensionIterator = extensions.descendingIterator();
+ nextExtension = extensionIterator.next();
+ }
+ }
+
+ for (int pos = buffer.length - INTS_PER_FIELD; pos >= 0; pos -= INTS_PER_FIELD) {
+ final int typeAndOffset = typeAndOffsetAt(pos);
+ final int number = numberAt(pos);
+
+ // Write any extensions that need to be written before the current field.
+ while (nextExtension != null && extensionSchema.extensionNumber(nextExtension) > number) {
+ extensionSchema.serializeExtension(writer, nextExtension);
+ nextExtension = extensionIterator.hasNext() ? extensionIterator.next() : null;
+ }
+
+ switch (type(typeAndOffset)) {
+ case 0: // DOUBLE:
+ if (isFieldPresent(message, pos)) {
+ writer.writeDouble(number, doubleAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 1: // FLOAT:
+ if (isFieldPresent(message, pos)) {
+ writer.writeFloat(number, floatAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 2: // INT64:
+ if (isFieldPresent(message, pos)) {
+ writer.writeInt64(number, longAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 3: // UINT64:
+ if (isFieldPresent(message, pos)) {
+ writer.writeUInt64(number, longAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 4: // INT32:
+ if (isFieldPresent(message, pos)) {
+ writer.writeInt32(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 5: // FIXED64:
+ if (isFieldPresent(message, pos)) {
+ writer.writeFixed64(number, longAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 6: // FIXED32:
+ if (isFieldPresent(message, pos)) {
+ writer.writeFixed32(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 7: // BOOL:
+ if (isFieldPresent(message, pos)) {
+ writer.writeBool(number, booleanAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 8: // STRING:
+ if (isFieldPresent(message, pos)) {
+ writeString(number, UnsafeUtil.getObject(message, offset(typeAndOffset)), writer);
+ }
+ break;
+ case 9: // MESSAGE:
+ if (isFieldPresent(message, pos)) {
+ Object value = UnsafeUtil.getObject(message, offset(typeAndOffset));
+ writer.writeMessage(number, value, getMessageFieldSchema(pos));
+ }
+ break;
+ case 10: // BYTES:
+ if (isFieldPresent(message, pos)) {
+ writer.writeBytes(
+ number, (ByteString) UnsafeUtil.getObject(message, offset(typeAndOffset)));
+ }
+ break;
+ case 11: // UINT32:
+ if (isFieldPresent(message, pos)) {
+ writer.writeUInt32(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 12: // ENUM:
+ if (isFieldPresent(message, pos)) {
+ writer.writeEnum(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 13: // SFIXED32:
+ if (isFieldPresent(message, pos)) {
+ writer.writeSFixed32(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 14: // SFIXED64:
+ if (isFieldPresent(message, pos)) {
+ writer.writeSFixed64(number, longAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 15: // SINT32:
+ if (isFieldPresent(message, pos)) {
+ writer.writeSInt32(number, intAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 16: // SINT64:
+ if (isFieldPresent(message, pos)) {
+ writer.writeSInt64(number, longAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 17: // GROUP:
+ if (isFieldPresent(message, pos)) {
+ writer.writeGroup(
+ number,
+ UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ getMessageFieldSchema(pos));
+ }
+ break;
+ case 18: // DOUBLE_LIST:
+ SchemaUtil.writeDoubleList(
+ numberAt(pos),
+ (List<Double>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 19: // FLOAT_LIST:
+ SchemaUtil.writeFloatList(
+ numberAt(pos),
+ (List<Float>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 20: // INT64_LIST:
+ SchemaUtil.writeInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 21: // UINT64_LIST:
+ SchemaUtil.writeUInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 22: // INT32_LIST:
+ SchemaUtil.writeInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 23: // FIXED64_LIST:
+ SchemaUtil.writeFixed64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 24: // FIXED32_LIST:
+ SchemaUtil.writeFixed32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 25: // BOOL_LIST:
+ SchemaUtil.writeBoolList(
+ numberAt(pos),
+ (List<Boolean>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 26: // STRING_LIST:
+ SchemaUtil.writeStringList(
+ numberAt(pos),
+ (List<String>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer);
+ break;
+ case 27: // MESSAGE_LIST:
+ SchemaUtil.writeMessageList(
+ numberAt(pos),
+ (List<?>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ getMessageFieldSchema(pos));
+ break;
+ case 28: // BYTES_LIST:
+ SchemaUtil.writeBytesList(
+ numberAt(pos),
+ (List<ByteString>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer);
+ break;
+ case 29: // UINT32_LIST:
+ SchemaUtil.writeUInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 30: // ENUM_LIST:
+ SchemaUtil.writeEnumList(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 31: // SFIXED32_LIST:
+ SchemaUtil.writeSFixed32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 32: // SFIXED64_LIST:
+ SchemaUtil.writeSFixed64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 33: // SINT32_LIST:
+ SchemaUtil.writeSInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 34: // SINT64_LIST:
+ SchemaUtil.writeSInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ false);
+ break;
+ case 35: // DOUBLE_LIST_PACKED:
+ SchemaUtil.writeDoubleList(
+ numberAt(pos),
+ (List<Double>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 36: // FLOAT_LIST_PACKED:
+ SchemaUtil.writeFloatList(
+ numberAt(pos),
+ (List<Float>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 37: // INT64_LIST_PACKED:
+ SchemaUtil.writeInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 38: // UINT64_LIST_PACKED:
+ SchemaUtil.writeUInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 39: // INT32_LIST_PACKED:
+ SchemaUtil.writeInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 40: // FIXED64_LIST_PACKED:
+ SchemaUtil.writeFixed64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 41: // FIXED32_LIST_PACKED:
+ SchemaUtil.writeFixed32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+
+ break;
+ case 42: // BOOL_LIST_PACKED:
+ SchemaUtil.writeBoolList(
+ numberAt(pos),
+ (List<Boolean>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 43: // UINT32_LIST_PACKED:
+ SchemaUtil.writeUInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 44: // ENUM_LIST_PACKED:
+ SchemaUtil.writeEnumList(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 45: // SFIXED32_LIST_PACKED:
+ SchemaUtil.writeSFixed32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 46: // SFIXED64_LIST_PACKED:
+ SchemaUtil.writeSFixed64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 47: // SINT32_LIST_PACKED:
+ SchemaUtil.writeSInt32List(
+ numberAt(pos),
+ (List<Integer>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 48: // SINT64_LIST_PACKED:
+ SchemaUtil.writeSInt64List(
+ numberAt(pos),
+ (List<Long>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ true);
+ break;
+ case 49: // GROUP_LIST:
+ SchemaUtil.writeGroupList(
+ numberAt(pos),
+ (List<?>) UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ writer,
+ getMessageFieldSchema(pos));
+ break;
+ case 50: // MAP:
+ // TODO(dweis): Use schema cache.
+ writeMapHelper(writer, number, UnsafeUtil.getObject(message, offset(typeAndOffset)), pos);
+ break;
+ case 51: // ONEOF_DOUBLE:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeDouble(number, oneofDoubleAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 52: // ONEOF_FLOAT:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeFloat(number, oneofFloatAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 53: // ONEOF_INT64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeInt64(number, oneofLongAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 54: // ONEOF_UINT64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeUInt64(number, oneofLongAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 55: // ONEOF_INT32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeInt32(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 56: // ONEOF_FIXED64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeFixed64(number, oneofLongAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 57: // ONEOF_FIXED32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeFixed32(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 58: // ONEOF_BOOL:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeBool(number, oneofBooleanAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 59: // ONEOF_STRING:
+ if (isOneofPresent(message, number, pos)) {
+ writeString(number, UnsafeUtil.getObject(message, offset(typeAndOffset)), writer);
+ }
+ break;
+ case 60: // ONEOF_MESSAGE:
+ if (isOneofPresent(message, number, pos)) {
+ Object value = UnsafeUtil.getObject(message, offset(typeAndOffset));
+ writer.writeMessage(number, value, getMessageFieldSchema(pos));
+ }
+ break;
+ case 61: // ONEOF_BYTES:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeBytes(
+ number, (ByteString) UnsafeUtil.getObject(message, offset(typeAndOffset)));
+ }
+ break;
+ case 62: // ONEOF_UINT32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeUInt32(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 63: // ONEOF_ENUM:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeEnum(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 64: // ONEOF_SFIXED32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSFixed32(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 65: // ONEOF_SFIXED64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSFixed64(number, oneofLongAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 66: // ONEOF_SINT32:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSInt32(number, oneofIntAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 67: // ONEOF_SINT64:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeSInt64(number, oneofLongAt(message, offset(typeAndOffset)));
+ }
+ break;
+ case 68: // ONEOF_GROUP:
+ if (isOneofPresent(message, number, pos)) {
+ writer.writeGroup(
+ number,
+ UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ getMessageFieldSchema(pos));
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ while (nextExtension != null) {
+ extensionSchema.serializeExtension(writer, nextExtension);
+ nextExtension = extensionIterator.hasNext() ? extensionIterator.next() : null;
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private <K, V> void writeMapHelper(Writer writer, int number, Object mapField, int pos)
+ throws IOException {
+ if (mapField != null) {
+ writer.writeMap(
+ number,
+ (MapEntryLite.Metadata<K, V>) mapFieldSchema.forMapMetadata(getMapFieldDefaultEntry(pos)),
+ (Map<K, V>) mapFieldSchema.forMapData(mapField));
+ }
+ }
+
+ private <UT, UB> void writeUnknownInMessageTo(
+ UnknownFieldSchema<UT, UB> schema, T message, Writer writer) throws IOException {
+ schema.writeTo(schema.getFromMessage(message), writer);
+ }
+
+ @Override
+ public void mergeFrom(T message, Reader reader, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ if (extensionRegistry == null) {
+ throw new NullPointerException();
+ }
+ mergeFromHelper(unknownFieldSchema, extensionSchema, message, reader, extensionRegistry);
+ }
+
+ /**
+ * A helper method for wildcard capture of {@code unknownFieldSchema}. See:
+ * https://docs.oracle.com/javase/tutorial/java/generics/capture.html
+ */
+ private <UT, UB, ET extends FieldDescriptorLite<ET>> void mergeFromHelper(
+ UnknownFieldSchema<UT, UB> unknownFieldSchema,
+ ExtensionSchema<ET> extensionSchema,
+ T message,
+ Reader reader,
+ ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ UB unknownFields = null;
+ FieldSet<ET> extensions = null;
+ try {
+ while (true) {
+ final int number = reader.getFieldNumber();
+ final int pos = positionForFieldNumber(number);
+ if (pos < 0) {
+ if (number == Reader.READ_DONE) {
+ return;
+ }
+ // Check if it's an extension.
+ Object extension =
+ !hasExtensions
+ ? null
+ : extensionSchema.findExtensionByNumber(
+ extensionRegistry, defaultInstance, number);
+ if (extension != null) {
+ if (extensions == null) {
+ extensions = extensionSchema.getMutableExtensions(message);
+ }
+ unknownFields =
+ extensionSchema.parseExtension(
+ reader,
+ extension,
+ extensionRegistry,
+ extensions,
+ unknownFields,
+ unknownFieldSchema);
+ continue;
+ }
+ if (unknownFieldSchema.shouldDiscardUnknownFields(reader)) {
+ if (reader.skipField()) {
+ continue;
+ }
+ } else {
+ if (unknownFields == null) {
+ unknownFields = unknownFieldSchema.getBuilderFromMessage(message);
+ }
+ // Unknown field.
+ if (unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader)) {
+ continue;
+ }
+ }
+ // Done reading.
+ return;
+ }
+ final int typeAndOffset = typeAndOffsetAt(pos);
+
+ try {
+ switch (type(typeAndOffset)) {
+ case 0: // DOUBLE:
+ UnsafeUtil.putDouble(message, offset(typeAndOffset), reader.readDouble());
+ setFieldPresent(message, pos);
+ break;
+ case 1: // FLOAT:
+ UnsafeUtil.putFloat(message, offset(typeAndOffset), reader.readFloat());
+ setFieldPresent(message, pos);
+ break;
+ case 2: // INT64:
+ UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readInt64());
+ setFieldPresent(message, pos);
+ break;
+ case 3: // UINT64:
+ UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readUInt64());
+ setFieldPresent(message, pos);
+ break;
+ case 4: // INT32:
+ UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readInt32());
+ setFieldPresent(message, pos);
+ break;
+ case 5: // FIXED64:
+ UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readFixed64());
+ setFieldPresent(message, pos);
+ break;
+ case 6: // FIXED32:
+ UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readFixed32());
+ setFieldPresent(message, pos);
+ break;
+ case 7: // BOOL:
+ UnsafeUtil.putBoolean(message, offset(typeAndOffset), reader.readBool());
+ setFieldPresent(message, pos);
+ break;
+ case 8: // STRING:
+ readString(message, typeAndOffset, reader);
+ setFieldPresent(message, pos);
+ break;
+ case 9:
+ { // MESSAGE:
+ if (isFieldPresent(message, pos)) {
+ Object mergedResult =
+ Internal.mergeMessage(
+ UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ reader.readMessageBySchemaWithCheck(
+ (Schema<T>) getMessageFieldSchema(pos), extensionRegistry));
+ UnsafeUtil.putObject(message, offset(typeAndOffset), mergedResult);
+ } else {
+ UnsafeUtil.putObject(
+ message,
+ offset(typeAndOffset),
+ reader.readMessageBySchemaWithCheck(
+ (Schema<T>) getMessageFieldSchema(pos), extensionRegistry));
+ setFieldPresent(message, pos);
+ }
+ break;
+ }
+ case 10: // BYTES:
+ UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes());
+ setFieldPresent(message, pos);
+ break;
+ case 11: // UINT32:
+ UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readUInt32());
+ setFieldPresent(message, pos);
+ break;
+ case 12: // ENUM:
+ {
+ int enumValue = reader.readEnum();
+ EnumVerifier enumVerifier = getEnumFieldVerifier(pos);
+ if (enumVerifier == null || enumVerifier.isInRange(enumValue)) {
+ UnsafeUtil.putInt(message, offset(typeAndOffset), enumValue);
+ setFieldPresent(message, pos);
+ } else {
+ unknownFields =
+ SchemaUtil.storeUnknownEnum(
+ number, enumValue, unknownFields, unknownFieldSchema);
+ }
+ break;
+ }
+ case 13: // SFIXED32:
+ UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSFixed32());
+ setFieldPresent(message, pos);
+ break;
+ case 14: // SFIXED64:
+ UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSFixed64());
+ setFieldPresent(message, pos);
+ break;
+ case 15: // SINT32:
+ UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSInt32());
+ setFieldPresent(message, pos);
+ break;
+ case 16: // SINT64:
+ UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSInt64());
+ setFieldPresent(message, pos);
+ break;
+ case 17:
+ { // GROUP:
+ if (isFieldPresent(message, pos)) {
+ Object mergedResult =
+ Internal.mergeMessage(
+ UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ reader.readGroupBySchemaWithCheck(
+ (Schema<T>) getMessageFieldSchema(pos), extensionRegistry));
+ UnsafeUtil.putObject(message, offset(typeAndOffset), mergedResult);
+ } else {
+ UnsafeUtil.putObject(
+ message,
+ offset(typeAndOffset),
+ reader.readGroupBySchemaWithCheck(
+ (Schema<T>) getMessageFieldSchema(pos), extensionRegistry));
+ setFieldPresent(message, pos);
+ }
+ break;
+ }
+ case 18: // DOUBLE_LIST:
+ reader.readDoubleList(
+ listFieldSchema.<Double>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 19: // FLOAT_LIST:
+ reader.readFloatList(
+ listFieldSchema.<Float>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 20: // INT64_LIST:
+ reader.readInt64List(
+ listFieldSchema.<Long>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 21: // UINT64_LIST:
+ reader.readUInt64List(
+ listFieldSchema.<Long>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 22: // INT32_LIST:
+ reader.readInt32List(
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 23: // FIXED64_LIST:
+ reader.readFixed64List(
+ listFieldSchema.<Long>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 24: // FIXED32_LIST:
+ reader.readFixed32List(
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 25: // BOOL_LIST:
+ reader.readBoolList(
+ listFieldSchema.<Boolean>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 26: // STRING_LIST:
+ readStringList(message, typeAndOffset, reader);
+ break;
+ case 27:
+ { // MESSAGE_LIST:
+ readMessageList(
+ message,
+ typeAndOffset,
+ reader,
+ (Schema<T>) getMessageFieldSchema(pos),
+ extensionRegistry);
+ break;
+ }
+ case 28: // BYTES_LIST:
+ reader.readBytesList(
+ listFieldSchema.<ByteString>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 29: // UINT32_LIST:
+ reader.readUInt32List(
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 30: // ENUM_LIST:
+ {
+ List<Integer> enumList =
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset));
+ reader.readEnumList(enumList);
+ unknownFields =
+ SchemaUtil.filterUnknownEnumList(
+ number,
+ enumList,
+ getEnumFieldVerifier(pos),
+ unknownFields,
+ unknownFieldSchema);
+ break;
+ }
+ case 31: // SFIXED32_LIST:
+ reader.readSFixed32List(
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 32: // SFIXED64_LIST:
+ reader.readSFixed64List(
+ listFieldSchema.<Long>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 33: // SINT32_LIST:
+ reader.readSInt32List(
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 34: // SINT64_LIST:
+ reader.readSInt64List(
+ listFieldSchema.<Long>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 35: // DOUBLE_LIST_PACKED:
+ reader.readDoubleList(
+ listFieldSchema.<Double>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 36: // FLOAT_LIST_PACKED:
+ reader.readFloatList(
+ listFieldSchema.<Float>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 37: // INT64_LIST_PACKED:
+ reader.readInt64List(
+ listFieldSchema.<Long>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 38: // UINT64_LIST_PACKED:
+ reader.readUInt64List(
+ listFieldSchema.<Long>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 39: // INT32_LIST_PACKED:
+ reader.readInt32List(
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 40: // FIXED64_LIST_PACKED:
+ reader.readFixed64List(
+ listFieldSchema.<Long>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 41: // FIXED32_LIST_PACKED:
+ reader.readFixed32List(
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 42: // BOOL_LIST_PACKED:
+ reader.readBoolList(
+ listFieldSchema.<Boolean>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 43: // UINT32_LIST_PACKED:
+ reader.readUInt32List(
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 44: // ENUM_LIST_PACKED:
+ {
+ List<Integer> enumList =
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset));
+ reader.readEnumList(enumList);
+ unknownFields =
+ SchemaUtil.filterUnknownEnumList(
+ number,
+ enumList,
+ getEnumFieldVerifier(pos),
+ unknownFields,
+ unknownFieldSchema);
+ break;
+ }
+ case 45: // SFIXED32_LIST_PACKED:
+ reader.readSFixed32List(
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 46: // SFIXED64_LIST_PACKED:
+ reader.readSFixed64List(
+ listFieldSchema.<Long>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 47: // SINT32_LIST_PACKED:
+ reader.readSInt32List(
+ listFieldSchema.<Integer>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 48: // SINT64_LIST_PACKED:
+ reader.readSInt64List(
+ listFieldSchema.<Long>mutableListAt(message, offset(typeAndOffset)));
+ break;
+ case 49:
+ { // GROUP_LIST:
+ readGroupList(
+ message,
+ offset(typeAndOffset),
+ reader,
+ (Schema<T>) getMessageFieldSchema(pos),
+ extensionRegistry);
+ break;
+ }
+ case 50: // MAP:
+ mergeMap(message, pos, getMapFieldDefaultEntry(pos), extensionRegistry, reader);
+ break;
+ case 51: // ONEOF_DOUBLE:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Double.valueOf(reader.readDouble()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 52: // ONEOF_FLOAT:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Float.valueOf(reader.readFloat()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 53: // ONEOF_INT64:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Long.valueOf(reader.readInt64()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 54: // ONEOF_UINT64:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Long.valueOf(reader.readUInt64()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 55: // ONEOF_INT32:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Integer.valueOf(reader.readInt32()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 56: // ONEOF_FIXED64:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Long.valueOf(reader.readFixed64()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 57: // ONEOF_FIXED32:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Integer.valueOf(reader.readFixed32()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 58: // ONEOF_BOOL:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Boolean.valueOf(reader.readBool()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 59: // ONEOF_STRING:
+ readString(message, typeAndOffset, reader);
+ setOneofPresent(message, number, pos);
+ break;
+ case 60: // ONEOF_MESSAGE:
+ if (isOneofPresent(message, number, pos)) {
+ Object mergedResult =
+ Internal.mergeMessage(
+ UnsafeUtil.getObject(message, offset(typeAndOffset)),
+ reader.readMessageBySchemaWithCheck(
+ getMessageFieldSchema(pos), extensionRegistry));
+ UnsafeUtil.putObject(message, offset(typeAndOffset), mergedResult);
+ } else {
+ UnsafeUtil.putObject(
+ message,
+ offset(typeAndOffset),
+ reader.readMessageBySchemaWithCheck(
+ getMessageFieldSchema(pos), extensionRegistry));
+ setFieldPresent(message, pos);
+ }
+ setOneofPresent(message, number, pos);
+ break;
+ case 61: // ONEOF_BYTES:
+ UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes());
+ setOneofPresent(message, number, pos);
+ break;
+ case 62: // ONEOF_UINT32:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Integer.valueOf(reader.readUInt32()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 63: // ONEOF_ENUM:
+ {
+ int enumValue = reader.readEnum();
+ EnumVerifier enumVerifier = getEnumFieldVerifier(pos);
+ if (enumVerifier == null || enumVerifier.isInRange(enumValue)) {
+ UnsafeUtil.putObject(message, offset(typeAndOffset), enumValue);
+ setOneofPresent(message, number, pos);
+ } else {
+ unknownFields =
+ SchemaUtil.storeUnknownEnum(
+ number, enumValue, unknownFields, unknownFieldSchema);
+ }
+ break;
+ }
+ case 64: // ONEOF_SFIXED32:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Integer.valueOf(reader.readSFixed32()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 65: // ONEOF_SFIXED64:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Long.valueOf(reader.readSFixed64()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 66: // ONEOF_SINT32:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Integer.valueOf(reader.readSInt32()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 67: // ONEOF_SINT64:
+ UnsafeUtil.putObject(
+ message, offset(typeAndOffset), Long.valueOf(reader.readSInt64()));
+ setOneofPresent(message, number, pos);
+ break;
+ case 68: // ONEOF_GROUP:
+ UnsafeUtil.putObject(
+ message,
+ offset(typeAndOffset),
+ reader.readGroupBySchemaWithCheck(getMessageFieldSchema(pos), extensionRegistry));
+ setOneofPresent(message, number, pos);
+ break;
+ default:
+ // Assume we've landed on an empty entry. Treat it as an unknown field.
+ if (unknownFields == null) {
+ unknownFields = unknownFieldSchema.newBuilder();
+ }
+ if (!unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader)) {
+ return;
+ }
+ break;
+ }
+ } catch (InvalidProtocolBufferException.InvalidWireTypeException e) {
+ // Treat fields with an invalid wire type as unknown fields
+ // (i.e. same as the default case).
+ if (unknownFieldSchema.shouldDiscardUnknownFields(reader)) {
+ if (!reader.skipField()) {
+ return;
+ }
+ } else {
+ if (unknownFields == null) {
+ unknownFields = unknownFieldSchema.getBuilderFromMessage(message);
+ }
+ if (!unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader)) {
+ return;
+ }
+ }
+ }
+ }
+ } finally {
+ for (int i = checkInitializedCount; i < repeatedFieldOffsetStart; i++) {
+ unknownFields =
+ filterMapUnknownEnumValues(message, intArray[i], unknownFields, unknownFieldSchema);
+ }
+ if (unknownFields != null) {
+ unknownFieldSchema.setBuilderToMessage(message, unknownFields);
+ }
+ }
+ }
+
+ @SuppressWarnings("ReferenceEquality")
+ static UnknownFieldSetLite getMutableUnknownFields(Object message) {
+ UnknownFieldSetLite unknownFields = ((GeneratedMessageLite) message).unknownFields;
+ if (unknownFields == UnknownFieldSetLite.getDefaultInstance()) {
+ unknownFields = UnknownFieldSetLite.newInstance();
+ ((GeneratedMessageLite) message).unknownFields = unknownFields;
+ }
+ return unknownFields;
+ }
+
+ /** Decodes a map entry key or value. Stores result in registers.object1. */
+ private int decodeMapEntryValue(
+ byte[] data,
+ int position,
+ int limit,
+ WireFormat.FieldType fieldType,
+ Class<?> messageType,
+ Registers registers)
+ throws IOException {
+ switch (fieldType) {
+ case BOOL:
+ position = decodeVarint64(data, position, registers);
+ registers.object1 = registers.long1 != 0;
+ break;
+ case BYTES:
+ position = decodeBytes(data, position, registers);
+ break;
+ case DOUBLE:
+ registers.object1 = decodeDouble(data, position);
+ position += 8;
+ break;
+ case FIXED32:
+ case SFIXED32:
+ registers.object1 = decodeFixed32(data, position);
+ position += 4;
+ break;
+ case FIXED64:
+ case SFIXED64:
+ registers.object1 = decodeFixed64(data, position);
+ position += 8;
+ break;
+ case FLOAT:
+ registers.object1 = decodeFloat(data, position);
+ position += 4;
+ break;
+ case ENUM:
+ case INT32:
+ case UINT32:
+ position = decodeVarint32(data, position, registers);
+ registers.object1 = registers.int1;
+ break;
+ case INT64:
+ case UINT64:
+ position = decodeVarint64(data, position, registers);
+ registers.object1 = registers.long1;
+ break;
+ case MESSAGE:
+ position =
+ decodeMessageField(
+ Protobuf.getInstance().schemaFor(messageType), data, position, limit, registers);
+ break;
+ case SINT32:
+ position = decodeVarint32(data, position, registers);
+ registers.object1 = CodedInputStream.decodeZigZag32(registers.int1);
+ break;
+ case SINT64:
+ position = decodeVarint64(data, position, registers);
+ registers.object1 = CodedInputStream.decodeZigZag64(registers.long1);
+ break;
+ case STRING:
+ position = decodeStringRequireUtf8(data, position, registers);
+ break;
+ default:
+ throw new RuntimeException("unsupported field type.");
+ }
+ return position;
+ }
+
+ /** Decodes a map entry. */
+ private <K, V> int decodeMapEntry(
+ byte[] data,
+ int position,
+ int limit,
+ MapEntryLite.Metadata<K, V> metadata,
+ Map<K, V> target,
+ Registers registers)
+ throws IOException {
+ position = decodeVarint32(data, position, registers);
+ final int length = registers.int1;
+ if (length < 0 || length > limit - position) {
+ throw InvalidProtocolBufferException.truncatedMessage();
+ }
+ final int end = position + length;
+ K key = metadata.defaultKey;
+ V value = metadata.defaultValue;
+ while (position < end) {
+ int tag = data[position++];
+ if (tag < 0) {
+ position = decodeVarint32(tag, data, position, registers);
+ tag = registers.int1;
+ }
+ final int fieldNumber = tag >>> 3;
+ final int wireType = tag & 0x7;
+ switch (fieldNumber) {
+ case 1:
+ if (wireType == metadata.keyType.getWireType()) {
+ position =
+ decodeMapEntryValue(data, position, limit, metadata.keyType, null, registers);
+ key = (K) registers.object1;
+ continue;
+ }
+ break;
+ case 2:
+ if (wireType == metadata.valueType.getWireType()) {
+ position =
+ decodeMapEntryValue(
+ data,
+ position,
+ limit,
+ metadata.valueType,
+ metadata.defaultValue.getClass(),
+ registers);
+ value = (V) registers.object1;
+ continue;
+ }
+ break;
+ default:
+ break;
+ }
+ position = skipField(tag, data, position, limit, registers);
+ }
+ if (position != end) {
+ throw InvalidProtocolBufferException.parseFailure();
+ }
+ target.put(key, value);
+ return end;
+ }
+
+ @SuppressWarnings("ReferenceEquality")
+ private int parseRepeatedField(
+ T message,
+ byte[] data,
+ int position,
+ int limit,
+ int tag,
+ int number,
+ int wireType,
+ int bufferPosition,
+ long typeAndOffset,
+ int fieldType,
+ long fieldOffset,
+ Registers registers)
+ throws IOException {
+ ProtobufList<?> list = (ProtobufList<?>) UNSAFE.getObject(message, fieldOffset);
+ if (!list.isModifiable()) {
+ final int size = list.size();
+ list =
+ list.mutableCopyWithCapacity(
+ size == 0 ? AbstractProtobufList.DEFAULT_CAPACITY : size * 2);
+ UNSAFE.putObject(message, fieldOffset, list);
+ }
+ switch (fieldType) {
+ case 18: // DOUBLE_LIST:
+ case 35: // DOUBLE_LIST_PACKED:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodePackedDoubleList(data, position, list, registers);
+ } else if (wireType == WireFormat.WIRETYPE_FIXED64) {
+ position = decodeDoubleList(tag, data, position, limit, list, registers);
+ }
+ break;
+ case 19: // FLOAT_LIST:
+ case 36: // FLOAT_LIST_PACKED:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodePackedFloatList(data, position, list, registers);
+ } else if (wireType == WireFormat.WIRETYPE_FIXED32) {
+ position = decodeFloatList(tag, data, position, limit, list, registers);
+ }
+ break;
+ case 20: // INT64_LIST:
+ case 21: // UINT64_LIST:
+ case 37: // INT64_LIST_PACKED:
+ case 38: // UINT64_LIST_PACKED:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodePackedVarint64List(data, position, list, registers);
+ } else if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint64List(tag, data, position, limit, list, registers);
+ }
+ break;
+ case 22: // INT32_LIST:
+ case 29: // UINT32_LIST:
+ case 39: // INT32_LIST_PACKED:
+ case 43: // UINT32_LIST_PACKED:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodePackedVarint32List(data, position, list, registers);
+ } else if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint32List(tag, data, position, limit, list, registers);
+ }
+ break;
+ case 23: // FIXED64_LIST:
+ case 32: // SFIXED64_LIST:
+ case 40: // FIXED64_LIST_PACKED:
+ case 46: // SFIXED64_LIST_PACKED:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodePackedFixed64List(data, position, list, registers);
+ } else if (wireType == WireFormat.WIRETYPE_FIXED64) {
+ position = decodeFixed64List(tag, data, position, limit, list, registers);
+ }
+ break;
+ case 24: // FIXED32_LIST:
+ case 31: // SFIXED32_LIST:
+ case 41: // FIXED32_LIST_PACKED:
+ case 45: // SFIXED32_LIST_PACKED:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodePackedFixed32List(data, position, list, registers);
+ } else if (wireType == WireFormat.WIRETYPE_FIXED32) {
+ position = decodeFixed32List(tag, data, position, limit, list, registers);
+ }
+ break;
+ case 25: // BOOL_LIST:
+ case 42: // BOOL_LIST_PACKED:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodePackedBoolList(data, position, list, registers);
+ } else if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeBoolList(tag, data, position, limit, list, registers);
+ }
+ break;
+ case 26: // STRING_LIST:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ if ((typeAndOffset & ENFORCE_UTF8_MASK) == 0) {
+ position = decodeStringList(tag, data, position, limit, list, registers);
+ } else {
+ position = decodeStringListRequireUtf8(tag, data, position, limit, list, registers);
+ }
+ }
+ break;
+ case 27: // MESSAGE_LIST:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position =
+ decodeMessageList(
+ getMessageFieldSchema(bufferPosition),
+ tag,
+ data,
+ position,
+ limit,
+ list,
+ registers);
+ }
+ break;
+ case 28: // BYTES_LIST:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodeBytesList(tag, data, position, limit, list, registers);
+ }
+ break;
+ case 30: // ENUM_LIST:
+ case 44: // ENUM_LIST_PACKED:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodePackedVarint32List(data, position, list, registers);
+ } else if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint32List(tag, data, position, limit, list, registers);
+ } else {
+ break;
+ }
+ UnknownFieldSetLite unknownFields = ((GeneratedMessageLite) message).unknownFields;
+ if (unknownFields == UnknownFieldSetLite.getDefaultInstance()) {
+ // filterUnknownEnumList() expects the unknownFields parameter to be mutable or null.
+ // Since we don't know yet whether there exist unknown enum values, we'd better pass
+ // null to it instead of allocating a mutable instance. This is also needed to be
+ // consistent with the behavior of generated parser/builder.
+ unknownFields = null;
+ }
+ unknownFields =
+ SchemaUtil.filterUnknownEnumList(
+ number,
+ (ProtobufList<Integer>) list,
+ getEnumFieldVerifier(bufferPosition),
+ unknownFields,
+ (UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite>) unknownFieldSchema);
+ if (unknownFields != null) {
+ ((GeneratedMessageLite) message).unknownFields = unknownFields;
+ }
+ break;
+ case 33: // SINT32_LIST:
+ case 47: // SINT32_LIST_PACKED:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodePackedSInt32List(data, position, list, registers);
+ } else if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeSInt32List(tag, data, position, limit, list, registers);
+ }
+ break;
+ case 34: // SINT64_LIST:
+ case 48: // SINT64_LIST_PACKED:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodePackedSInt64List(data, position, list, registers);
+ } else if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeSInt64List(tag, data, position, limit, list, registers);
+ }
+ break;
+ case 49: // GROUP_LIST:
+ if (wireType == WireFormat.WIRETYPE_START_GROUP) {
+ position =
+ decodeGroupList(
+ getMessageFieldSchema(bufferPosition),
+ tag,
+ data,
+ position,
+ limit,
+ list,
+ registers);
+ }
+ break;
+ default:
+ break;
+ }
+ return position;
+ }
+
+ private <K, V> int parseMapField(
+ T message,
+ byte[] data,
+ int position,
+ int limit,
+ int bufferPosition,
+ long fieldOffset,
+ Registers registers)
+ throws IOException {
+ final sun.misc.Unsafe unsafe = UNSAFE;
+ Object mapDefaultEntry = getMapFieldDefaultEntry(bufferPosition);
+ Object mapField = unsafe.getObject(message, fieldOffset);
+ if (mapFieldSchema.isImmutable(mapField)) {
+ Object oldMapField = mapField;
+ mapField = mapFieldSchema.newMapField(mapDefaultEntry);
+ mapFieldSchema.mergeFrom(mapField, oldMapField);
+ unsafe.putObject(message, fieldOffset, mapField);
+ }
+ return decodeMapEntry(
+ data,
+ position,
+ limit,
+ (Metadata<K, V>) mapFieldSchema.forMapMetadata(mapDefaultEntry),
+ (Map<K, V>) mapFieldSchema.forMutableMapData(mapField),
+ registers);
+ }
+
+ private int parseOneofField(
+ T message,
+ byte[] data,
+ int position,
+ int limit,
+ int tag,
+ int number,
+ int wireType,
+ int typeAndOffset,
+ int fieldType,
+ long fieldOffset,
+ int bufferPosition,
+ Registers registers)
+ throws IOException {
+ final sun.misc.Unsafe unsafe = UNSAFE;
+ final long oneofCaseOffset = buffer[bufferPosition + 2] & OFFSET_MASK;
+ switch (fieldType) {
+ case 51: // ONEOF_DOUBLE:
+ if (wireType == WireFormat.WIRETYPE_FIXED64) {
+ unsafe.putObject(message, fieldOffset, decodeDouble(data, position));
+ position += 8;
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 52: // ONEOF_FLOAT:
+ if (wireType == WireFormat.WIRETYPE_FIXED32) {
+ unsafe.putObject(message, fieldOffset, decodeFloat(data, position));
+ position += 4;
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 53: // ONEOF_INT64:
+ case 54: // ONEOF_UINT64:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint64(data, position, registers);
+ unsafe.putObject(message, fieldOffset, registers.long1);
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 55: // ONEOF_INT32:
+ case 62: // ONEOF_UINT32:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint32(data, position, registers);
+ unsafe.putObject(message, fieldOffset, registers.int1);
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 56: // ONEOF_FIXED64:
+ case 65: // ONEOF_SFIXED64:
+ if (wireType == WireFormat.WIRETYPE_FIXED64) {
+ unsafe.putObject(message, fieldOffset, decodeFixed64(data, position));
+ position += 8;
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 57: // ONEOF_FIXED32:
+ case 64: // ONEOF_SFIXED32:
+ if (wireType == WireFormat.WIRETYPE_FIXED32) {
+ unsafe.putObject(message, fieldOffset, decodeFixed32(data, position));
+ position += 4;
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 58: // ONEOF_BOOL:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint64(data, position, registers);
+ unsafe.putObject(message, fieldOffset, registers.long1 != 0);
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 59: // ONEOF_STRING:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodeVarint32(data, position, registers);
+ final int length = registers.int1;
+ if (length == 0) {
+ unsafe.putObject(message, fieldOffset, "");
+ } else {
+ if ((typeAndOffset & ENFORCE_UTF8_MASK) != 0
+ && !Utf8.isValidUtf8(data, position, position + length)) {
+ throw InvalidProtocolBufferException.invalidUtf8();
+ }
+ final String value = new String(data, position, length, Internal.UTF_8);
+ unsafe.putObject(message, fieldOffset, value);
+ position += length;
+ }
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 60: // ONEOF_MESSAGE:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position =
+ decodeMessageField(
+ getMessageFieldSchema(bufferPosition), data, position, limit, registers);
+ final Object oldValue =
+ unsafe.getInt(message, oneofCaseOffset) == number
+ ? unsafe.getObject(message, fieldOffset)
+ : null;
+ if (oldValue == null) {
+ unsafe.putObject(message, fieldOffset, registers.object1);
+ } else {
+ unsafe.putObject(
+ message, fieldOffset, Internal.mergeMessage(oldValue, registers.object1));
+ }
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 61: // ONEOF_BYTES:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodeBytes(data, position, registers);
+ unsafe.putObject(message, fieldOffset, registers.object1);
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 63: // ONEOF_ENUM:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint32(data, position, registers);
+ final int enumValue = registers.int1;
+ EnumVerifier enumVerifier = getEnumFieldVerifier(bufferPosition);
+ if (enumVerifier == null || enumVerifier.isInRange(enumValue)) {
+ unsafe.putObject(message, fieldOffset, enumValue);
+ unsafe.putInt(message, oneofCaseOffset, number);
+ } else {
+ // UnknownFieldSetLite requires varint to be represented as Long.
+ getMutableUnknownFields(message).storeField(tag, (long) enumValue);
+ }
+ }
+ break;
+ case 66: // ONEOF_SINT32:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint32(data, position, registers);
+ unsafe.putObject(message, fieldOffset, CodedInputStream.decodeZigZag32(registers.int1));
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 67: // ONEOF_SINT64:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint64(data, position, registers);
+ unsafe.putObject(message, fieldOffset, CodedInputStream.decodeZigZag64(registers.long1));
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ case 68: // ONEOF_GROUP:
+ if (wireType == WireFormat.WIRETYPE_START_GROUP) {
+ final int endTag = (tag & ~0x7) | WireFormat.WIRETYPE_END_GROUP;
+ position =
+ decodeGroupField(
+ getMessageFieldSchema(bufferPosition), data, position, limit, endTag, registers);
+ final Object oldValue =
+ unsafe.getInt(message, oneofCaseOffset) == number
+ ? unsafe.getObject(message, fieldOffset)
+ : null;
+ if (oldValue == null) {
+ unsafe.putObject(message, fieldOffset, registers.object1);
+ } else {
+ unsafe.putObject(
+ message, fieldOffset, Internal.mergeMessage(oldValue, registers.object1));
+ }
+ unsafe.putInt(message, oneofCaseOffset, number);
+ }
+ break;
+ default:
+ break;
+ }
+ return position;
+ }
+
+ private Schema getMessageFieldSchema(int pos) {
+ final int index = pos / INTS_PER_FIELD * 2;
+ Schema schema = (Schema) objects[index];
+ if (schema != null) {
+ return schema;
+ }
+ schema = Protobuf.getInstance().schemaFor((Class) objects[index + 1]);
+ objects[index] = schema;
+ return schema;
+ }
+
+ private Object getMapFieldDefaultEntry(int pos) {
+ return objects[pos / INTS_PER_FIELD * 2];
+ }
+
+ private EnumVerifier getEnumFieldVerifier(int pos) {
+ return (EnumVerifier) objects[pos / INTS_PER_FIELD * 2 + 1];
+ }
+
+ /**
+ * Parses a proto2 message or group and returns the position after the message/group. If it's
+ * parsing a message (endGroup == 0), returns limit if parsing is successful; It it's parsing a
+ * group (endGroup != 0), parsing ends when a tag == endGroup is encountered and the position
+ * after that tag is returned.
+ */
+ int parseProto2Message(
+ T message, byte[] data, int position, int limit, int endGroup, Registers registers)
+ throws IOException {
+ final sun.misc.Unsafe unsafe = UNSAFE;
+ int currentPresenceFieldOffset = -1;
+ int currentPresenceField = 0;
+ int tag = 0;
+ int oldNumber = -1;
+ int pos = 0;
+ while (position < limit) {
+ tag = data[position++];
+ if (tag < 0) {
+ position = decodeVarint32(tag, data, position, registers);
+ tag = registers.int1;
+ }
+ final int number = tag >>> 3;
+ final int wireType = tag & 0x7;
+ if (number > oldNumber) {
+ pos = positionForFieldNumber(number, pos / INTS_PER_FIELD);
+ } else {
+ pos = positionForFieldNumber(number);
+ }
+ oldNumber = number;
+ if (pos == -1) {
+ // need to reset
+ pos = 0;
+ } else {
+ final int typeAndOffset = buffer[pos + 1];
+ final int fieldType = type(typeAndOffset);
+ final long fieldOffset = offset(typeAndOffset);
+ if (fieldType <= 17) {
+ // Proto2 optional fields have has-bits.
+ final int presenceMaskAndOffset = buffer[pos + 2];
+ final int presenceMask = 1 << (presenceMaskAndOffset >>> OFFSET_BITS);
+ final int presenceFieldOffset = presenceMaskAndOffset & OFFSET_MASK;
+ // We cache the 32-bit has-bits integer value and only write it back when parsing a field
+ // using a different has-bits integer.
+ if (presenceFieldOffset != currentPresenceFieldOffset) {
+ if (currentPresenceFieldOffset != -1) {
+ unsafe.putInt(message, (long) currentPresenceFieldOffset, currentPresenceField);
+ }
+ currentPresenceFieldOffset = presenceFieldOffset;
+ currentPresenceField = unsafe.getInt(message, (long) presenceFieldOffset);
+ }
+ switch (fieldType) {
+ case 0: // DOUBLE
+ if (wireType == WireFormat.WIRETYPE_FIXED64) {
+ UnsafeUtil.putDouble(message, fieldOffset, decodeDouble(data, position));
+ position += 8;
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 1: // FLOAT
+ if (wireType == WireFormat.WIRETYPE_FIXED32) {
+ UnsafeUtil.putFloat(message, fieldOffset, decodeFloat(data, position));
+ position += 4;
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 2: // INT64
+ case 3: // UINT64
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint64(data, position, registers);
+ unsafe.putLong(message, fieldOffset, registers.long1);
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 4: // INT32
+ case 11: // UINT32
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint32(data, position, registers);
+ unsafe.putInt(message, fieldOffset, registers.int1);
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 5: // FIXED64
+ case 14: // SFIXED64
+ if (wireType == WireFormat.WIRETYPE_FIXED64) {
+ unsafe.putLong(message, fieldOffset, decodeFixed64(data, position));
+ position += 8;
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 6: // FIXED32
+ case 13: // SFIXED32
+ if (wireType == WireFormat.WIRETYPE_FIXED32) {
+ unsafe.putInt(message, fieldOffset, decodeFixed32(data, position));
+ position += 4;
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 7: // BOOL
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint64(data, position, registers);
+ UnsafeUtil.putBoolean(message, fieldOffset, registers.long1 != 0);
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 8: // STRING
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ if ((typeAndOffset & ENFORCE_UTF8_MASK) == 0) {
+ position = decodeString(data, position, registers);
+ } else {
+ position = decodeStringRequireUtf8(data, position, registers);
+ }
+ unsafe.putObject(message, fieldOffset, registers.object1);
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 9: // MESSAGE
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position =
+ decodeMessageField(
+ getMessageFieldSchema(pos), data, position, limit, registers);
+ if ((currentPresenceField & presenceMask) == 0) {
+ unsafe.putObject(message, fieldOffset, registers.object1);
+ } else {
+ unsafe.putObject(
+ message,
+ fieldOffset,
+ Internal.mergeMessage(
+ unsafe.getObject(message, fieldOffset), registers.object1));
+ }
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 10: // BYTES
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodeBytes(data, position, registers);
+ unsafe.putObject(message, fieldOffset, registers.object1);
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 12: // ENUM
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint32(data, position, registers);
+ final int enumValue = registers.int1;
+ EnumVerifier enumVerifier = getEnumFieldVerifier(pos);
+ if (enumVerifier == null || enumVerifier.isInRange(enumValue)) {
+ unsafe.putInt(message, fieldOffset, enumValue);
+ currentPresenceField |= presenceMask;
+ } else {
+ // UnknownFieldSetLite requires varint to be represented as Long.
+ getMutableUnknownFields(message).storeField(tag, (long) enumValue);
+ }
+ continue;
+ }
+ break;
+ case 15: // SINT32
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint32(data, position, registers);
+ unsafe.putInt(
+ message, fieldOffset, CodedInputStream.decodeZigZag32(registers.int1));
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 16: // SINT64
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint64(data, position, registers);
+ unsafe.putLong(
+ message, fieldOffset, CodedInputStream.decodeZigZag64(registers.long1));
+
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ case 17: // GROUP
+ if (wireType == WireFormat.WIRETYPE_START_GROUP) {
+ final int endTag = (number << 3) | WireFormat.WIRETYPE_END_GROUP;
+ position =
+ decodeGroupField(
+ getMessageFieldSchema(pos), data, position, limit, endTag, registers);
+ if ((currentPresenceField & presenceMask) == 0) {
+ unsafe.putObject(message, fieldOffset, registers.object1);
+ } else {
+ unsafe.putObject(
+ message,
+ fieldOffset,
+ Internal.mergeMessage(
+ unsafe.getObject(message, fieldOffset), registers.object1));
+ }
+
+ currentPresenceField |= presenceMask;
+ continue;
+ }
+ break;
+ default:
+ break;
+ }
+ } else if (fieldType == 27) {
+ // Handle repeated message fields.
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ ProtobufList<?> list = (ProtobufList<?>) unsafe.getObject(message, fieldOffset);
+ if (!list.isModifiable()) {
+ final int size = list.size();
+ list =
+ list.mutableCopyWithCapacity(
+ size == 0 ? AbstractProtobufList.DEFAULT_CAPACITY : size * 2);
+ unsafe.putObject(message, fieldOffset, list);
+ }
+ position =
+ decodeMessageList(
+ getMessageFieldSchema(pos), tag, data, position, limit, list, registers);
+ continue;
+ }
+ } else if (fieldType <= 49) {
+ // Handle all other repeated fields.
+ final int oldPosition = position;
+ position =
+ parseRepeatedField(
+ message,
+ data,
+ position,
+ limit,
+ tag,
+ number,
+ wireType,
+ pos,
+ typeAndOffset,
+ fieldType,
+ fieldOffset,
+ registers);
+ if (position != oldPosition) {
+ continue;
+ }
+ } else if (fieldType == 50) {
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ final int oldPosition = position;
+ position = parseMapField(message, data, position, limit, pos, fieldOffset, registers);
+ if (position != oldPosition) {
+ continue;
+ }
+ }
+ } else {
+ final int oldPosition = position;
+ position =
+ parseOneofField(
+ message,
+ data,
+ position,
+ limit,
+ tag,
+ number,
+ wireType,
+ typeAndOffset,
+ fieldType,
+ fieldOffset,
+ pos,
+ registers);
+ if (position != oldPosition) {
+ continue;
+ }
+ }
+ }
+ if (tag == endGroup && endGroup != 0) {
+ break;
+ }
+
+ if (hasExtensions
+ && registers.extensionRegistry != ExtensionRegistryLite.getEmptyRegistry()) {
+ position = decodeExtensionOrUnknownField(
+ tag, data, position, limit, message, defaultInstance,
+ (UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite>) unknownFieldSchema,
+ registers);
+ } else {
+ position = decodeUnknownField(
+ tag, data, position, limit, getMutableUnknownFields(message), registers);
+ }
+ }
+ if (currentPresenceFieldOffset != -1) {
+ unsafe.putInt(message, (long) currentPresenceFieldOffset, currentPresenceField);
+ }
+ UnknownFieldSetLite unknownFields = null;
+ for (int i = checkInitializedCount; i < repeatedFieldOffsetStart; i++) {
+ unknownFields =
+ filterMapUnknownEnumValues(
+ message,
+ intArray[i],
+ unknownFields,
+ (UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite>) unknownFieldSchema);
+ }
+ if (unknownFields != null) {
+ ((UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite>) unknownFieldSchema)
+ .setBuilderToMessage(message, unknownFields);
+ }
+ if (endGroup == 0) {
+ if (position != limit) {
+ throw InvalidProtocolBufferException.parseFailure();
+ }
+ } else {
+ if (position > limit || tag != endGroup) {
+ throw InvalidProtocolBufferException.parseFailure();
+ }
+ }
+ return position;
+ }
+
+ /** Parses a proto3 message and returns the limit if parsing is successful. */
+ private int parseProto3Message(
+ T message, byte[] data, int position, int limit, Registers registers) throws IOException {
+ final sun.misc.Unsafe unsafe = UNSAFE;
+ int tag = 0;
+ int oldNumber = -1;
+ int pos = 0;
+ while (position < limit) {
+ tag = data[position++];
+ if (tag < 0) {
+ position = decodeVarint32(tag, data, position, registers);
+ tag = registers.int1;
+ }
+ final int number = tag >>> 3;
+ final int wireType = tag & 0x7;
+ if (number > oldNumber) {
+ pos = positionForFieldNumber(number, pos / INTS_PER_FIELD);
+ } else {
+ pos = positionForFieldNumber(number);
+ }
+ oldNumber = number;
+ if (pos == -1) {
+ // need to reset
+ pos = 0;
+ } else {
+ final int typeAndOffset = buffer[pos + 1];
+ final int fieldType = type(typeAndOffset);
+ final long fieldOffset = offset(typeAndOffset);
+ if (fieldType <= 17) {
+ switch (fieldType) {
+ case 0: // DOUBLE:
+ if (wireType == WireFormat.WIRETYPE_FIXED64) {
+ UnsafeUtil.putDouble(message, fieldOffset, decodeDouble(data, position));
+ position += 8;
+ continue;
+ }
+ break;
+ case 1: // FLOAT:
+ if (wireType == WireFormat.WIRETYPE_FIXED32) {
+ UnsafeUtil.putFloat(message, fieldOffset, decodeFloat(data, position));
+ position += 4;
+ continue;
+ }
+ break;
+ case 2: // INT64:
+ case 3: // UINT64:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint64(data, position, registers);
+ unsafe.putLong(message, fieldOffset, registers.long1);
+ continue;
+ }
+ break;
+ case 4: // INT32:
+ case 11: // UINT32:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint32(data, position, registers);
+ unsafe.putInt(message, fieldOffset, registers.int1);
+ continue;
+ }
+ break;
+ case 5: // FIXED64:
+ case 14: // SFIXED64:
+ if (wireType == WireFormat.WIRETYPE_FIXED64) {
+ unsafe.putLong(message, fieldOffset, decodeFixed64(data, position));
+ position += 8;
+ continue;
+ }
+ break;
+ case 6: // FIXED32:
+ case 13: // SFIXED32:
+ if (wireType == WireFormat.WIRETYPE_FIXED32) {
+ unsafe.putInt(message, fieldOffset, decodeFixed32(data, position));
+ position += 4;
+ continue;
+ }
+ break;
+ case 7: // BOOL:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint64(data, position, registers);
+ UnsafeUtil.putBoolean(message, fieldOffset, registers.long1 != 0);
+ continue;
+ }
+ break;
+ case 8: // STRING:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ if ((typeAndOffset & ENFORCE_UTF8_MASK) == 0) {
+ position = decodeString(data, position, registers);
+ } else {
+ position = decodeStringRequireUtf8(data, position, registers);
+ }
+ unsafe.putObject(message, fieldOffset, registers.object1);
+ continue;
+ }
+ break;
+ case 9: // MESSAGE:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position =
+ decodeMessageField(
+ getMessageFieldSchema(pos), data, position, limit, registers);
+ final Object oldValue = unsafe.getObject(message, fieldOffset);
+ if (oldValue == null) {
+ unsafe.putObject(message, fieldOffset, registers.object1);
+ } else {
+ unsafe.putObject(
+ message, fieldOffset, Internal.mergeMessage(oldValue, registers.object1));
+ }
+ continue;
+ }
+ break;
+ case 10: // BYTES:
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = decodeBytes(data, position, registers);
+ unsafe.putObject(message, fieldOffset, registers.object1);
+ continue;
+ }
+ break;
+ case 12: // ENUM:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint32(data, position, registers);
+ unsafe.putInt(message, fieldOffset, registers.int1);
+ continue;
+ }
+ break;
+ case 15: // SINT32:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint32(data, position, registers);
+ unsafe.putInt(
+ message, fieldOffset, CodedInputStream.decodeZigZag32(registers.int1));
+ continue;
+ }
+ break;
+ case 16: // SINT64:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = decodeVarint64(data, position, registers);
+ unsafe.putLong(
+ message, fieldOffset, CodedInputStream.decodeZigZag64(registers.long1));
+ continue;
+ }
+ break;
+ default:
+ break;
+ }
+ } else if (fieldType == 27) {
+ // Handle repeated message field.
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ ProtobufList<?> list = (ProtobufList<?>) unsafe.getObject(message, fieldOffset);
+ if (!list.isModifiable()) {
+ final int size = list.size();
+ list =
+ list.mutableCopyWithCapacity(
+ size == 0 ? AbstractProtobufList.DEFAULT_CAPACITY : size * 2);
+ unsafe.putObject(message, fieldOffset, list);
+ }
+ position =
+ decodeMessageList(
+ getMessageFieldSchema(pos), tag, data, position, limit, list, registers);
+ continue;
+ }
+ } else if (fieldType <= 49) {
+ // Handle all other repeated fields.
+ final int oldPosition = position;
+ position =
+ parseRepeatedField(
+ message,
+ data,
+ position,
+ limit,
+ tag,
+ number,
+ wireType,
+ pos,
+ typeAndOffset,
+ fieldType,
+ fieldOffset,
+ registers);
+ if (position != oldPosition) {
+ continue;
+ }
+ } else if (fieldType == 50) {
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ final int oldPosition = position;
+ position = parseMapField(message, data, position, limit, pos, fieldOffset, registers);
+ if (position != oldPosition) {
+ continue;
+ }
+ }
+ } else {
+ final int oldPosition = position;
+ position =
+ parseOneofField(
+ message,
+ data,
+ position,
+ limit,
+ tag,
+ number,
+ wireType,
+ typeAndOffset,
+ fieldType,
+ fieldOffset,
+ pos,
+ registers);
+ if (position != oldPosition) {
+ continue;
+ }
+ }
+ }
+ position = decodeUnknownField(
+ tag, data, position, limit, getMutableUnknownFields(message), registers);
+ }
+ if (position != limit) {
+ throw InvalidProtocolBufferException.parseFailure();
+ }
+ return position;
+ }
+
+ @Override
+ public void mergeFrom(T message, byte[] data, int position, int limit, Registers registers)
+ throws IOException {
+ if (proto3) {
+ parseProto3Message(message, data, position, limit, registers);
+ } else {
+ parseProto2Message(message, data, position, limit, 0, registers);
+ }
+ }
+
+ @Override
+ public void makeImmutable(T message) {
+ // Make all repeated/map fields immutable.
+ for (int i = checkInitializedCount; i < repeatedFieldOffsetStart; i++) {
+ long offset = offset(typeAndOffsetAt(intArray[i]));
+ Object mapField = UnsafeUtil.getObject(message, offset);
+ if (mapField == null) {
+ continue;
+ }
+ UnsafeUtil.putObject(message, offset, mapFieldSchema.toImmutable(mapField));
+ }
+ final int length = intArray.length;
+ for (int i = repeatedFieldOffsetStart; i < length; i++) {
+ listFieldSchema.makeImmutableListAt(message, intArray[i]);
+ }
+ unknownFieldSchema.makeImmutable(message);
+ if (hasExtensions) {
+ extensionSchema.makeImmutable(message);
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private final <K, V> void mergeMap(
+ Object message,
+ int pos,
+ Object mapDefaultEntry,
+ ExtensionRegistryLite extensionRegistry,
+ Reader reader)
+ throws IOException {
+ long offset = offset(typeAndOffsetAt(pos));
+ Object mapField = UnsafeUtil.getObject(message, offset);
+ // TODO(xiaofeng): Consider creating separate implementations for full and lite. In lite
+ // runtime map field will never be null but here we still need to check null because the
+ // code is shared by both full and lite. It might be better if full/lite uses different
+ // schema implementations.
+ if (mapField == null) {
+ mapField = mapFieldSchema.newMapField(mapDefaultEntry);
+ UnsafeUtil.putObject(message, offset, mapField);
+ } else if (mapFieldSchema.isImmutable(mapField)) {
+ Object oldMapField = mapField;
+ mapField = mapFieldSchema.newMapField(mapDefaultEntry);
+ mapFieldSchema.mergeFrom(mapField, oldMapField);
+ UnsafeUtil.putObject(message, offset, mapField);
+ }
+ reader.readMap(
+ (Map<K, V>) mapFieldSchema.forMutableMapData(mapField),
+ (Metadata<K, V>) mapFieldSchema.forMapMetadata(mapDefaultEntry),
+ extensionRegistry);
+ }
+
+ private final <UT, UB> UB filterMapUnknownEnumValues(
+ Object message, int pos, UB unknownFields, UnknownFieldSchema<UT, UB> unknownFieldSchema) {
+ int fieldNumber = numberAt(pos);
+ long offset = offset(typeAndOffsetAt(pos));
+ Object mapField = UnsafeUtil.getObject(message, offset);
+ if (mapField == null) {
+ return unknownFields;
+ }
+ EnumVerifier enumVerifier = getEnumFieldVerifier(pos);
+ if (enumVerifier == null) {
+ return unknownFields;
+ }
+ Map<?, ?> mapData = mapFieldSchema.forMutableMapData(mapField);
+ // Filter unknown enum values.
+ unknownFields =
+ filterUnknownEnumMap(
+ pos, fieldNumber, mapData, enumVerifier, unknownFields, unknownFieldSchema);
+ return unknownFields;
+ }
+
+ @SuppressWarnings("unchecked")
+ private final <K, V, UT, UB> UB filterUnknownEnumMap(
+ int pos,
+ int number,
+ Map<K, V> mapData,
+ EnumVerifier enumVerifier,
+ UB unknownFields,
+ UnknownFieldSchema<UT, UB> unknownFieldSchema) {
+ Metadata<K, V> metadata =
+ (Metadata<K, V>) mapFieldSchema.forMapMetadata(getMapFieldDefaultEntry(pos));
+ for (Iterator<Map.Entry<K, V>> it = mapData.entrySet().iterator(); it.hasNext(); ) {
+ Map.Entry<K, V> entry = it.next();
+ if (!enumVerifier.isInRange((Integer) entry.getValue())) {
+ if (unknownFields == null) {
+ unknownFields = unknownFieldSchema.newBuilder();
+ }
+ int entrySize =
+ MapEntryLite.computeSerializedSize(metadata, entry.getKey(), entry.getValue());
+ CodedBuilder codedBuilder = ByteString.newCodedBuilder(entrySize);
+ CodedOutputStream codedOutput = codedBuilder.getCodedOutput();
+ try {
+ MapEntryLite.writeTo(codedOutput, metadata, entry.getKey(), entry.getValue());
+ } catch (IOException e) {
+ // Writing to ByteString CodedOutputStream should not throw IOException.
+ throw new RuntimeException(e);
+ }
+ unknownFieldSchema.addLengthDelimited(unknownFields, number, codedBuilder.build());
+ it.remove();
+ }
+ }
+ return unknownFields;
+ }
+
+ @Override
+ public final boolean isInitialized(T message) {
+ int currentPresenceFieldOffset = -1;
+ int currentPresenceField = 0;
+ for (int i = 0; i < checkInitializedCount; i++) {
+ final int pos = intArray[i];
+ final int number = numberAt(pos);
+
+ final int typeAndOffset = typeAndOffsetAt(pos);
+
+ int presenceMaskAndOffset = 0;
+ int presenceMask = 0;
+ if (!proto3) {
+ presenceMaskAndOffset = buffer[pos + 2];
+ final int presenceFieldOffset = presenceMaskAndOffset & OFFSET_MASK;
+ presenceMask = 1 << (presenceMaskAndOffset >>> OFFSET_BITS);
+ if (presenceFieldOffset != currentPresenceFieldOffset) {
+ currentPresenceFieldOffset = presenceFieldOffset;
+ currentPresenceField = UNSAFE.getInt(message, (long) presenceFieldOffset);
+ }
+ }
+
+ if (isRequired(typeAndOffset)) {
+ if (!isFieldPresent(message, pos, currentPresenceField, presenceMask)) {
+ return false;
+ }
+ // If a required message field is set but has no required fields of it's own, we still
+ // proceed and check the message is initialized. It should be fairly cheap to check these
+ // messages but is worth documenting.
+ }
+ // Check nested message and groups.
+ switch (type(typeAndOffset)) {
+ case 9: // MESSAGE
+ case 17: // GROUP
+ if (isFieldPresent(message, pos, currentPresenceField, presenceMask)
+ && !isInitialized(message, typeAndOffset, getMessageFieldSchema(pos))) {
+ return false;
+ }
+ break;
+ case 27: // MESSAGE_LIST
+ case 49: // GROUP_LIST
+ if (!isListInitialized(message, typeAndOffset, pos)) {
+ return false;
+ }
+ break;
+ case 60: // ONEOF_MESSAGE
+ case 68: // ONEOF_GROUP
+ if (isOneofPresent(message, number, pos)
+ && !isInitialized(message, typeAndOffset, getMessageFieldSchema(pos))) {
+ return false;
+ }
+ break;
+ case 50: // MAP
+ if (!isMapInitialized(message, typeAndOffset, pos)) {
+ return false;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (hasExtensions) {
+ if (!extensionSchema.getExtensions(message).isInitialized()) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ private static boolean isInitialized(Object message, int typeAndOffset, Schema schema) {
+ Object nested = UnsafeUtil.getObject(message, offset(typeAndOffset));
+ return schema.isInitialized(nested);
+ }
+
+ private <N> boolean isListInitialized(Object message, int typeAndOffset, int pos) {
+ @SuppressWarnings("unchecked")
+ List<N> list = (List<N>) UnsafeUtil.getObject(message, offset(typeAndOffset));
+ if (list.isEmpty()) {
+ return true;
+ }
+
+ Schema schema = getMessageFieldSchema(pos);
+ for (int i = 0; i < list.size(); i++) {
+ N nested = list.get(i);
+ if (!schema.isInitialized(nested)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private boolean isMapInitialized(T message, int typeAndOffset, int pos) {
+ Map<?, ?> map = mapFieldSchema.forMapData(UnsafeUtil.getObject(message, offset(typeAndOffset)));
+ if (map.isEmpty()) {
+ return true;
+ }
+ Object mapDefaultEntry = getMapFieldDefaultEntry(pos);
+ MapEntryLite.Metadata<?, ?> metadata = mapFieldSchema.forMapMetadata(mapDefaultEntry);
+ if (metadata.valueType.getJavaType() != WireFormat.JavaType.MESSAGE) {
+ return true;
+ }
+ // TODO(dweis): Use schema cache.
+ Schema schema = null;
+ for (Object nested : map.values()) {
+ if (schema == null) {
+ schema = Protobuf.getInstance().schemaFor(nested.getClass());
+ }
+ if (!schema.isInitialized(nested)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private void writeString(int fieldNumber, Object value, Writer writer) throws IOException {
+ if (value instanceof String) {
+ writer.writeString(fieldNumber, (String) value);
+ } else {
+ writer.writeBytes(fieldNumber, (ByteString) value);
+ }
+ }
+
+ private void readString(Object message, int typeAndOffset, Reader reader) throws IOException {
+ if (isEnforceUtf8(typeAndOffset)) {
+ // Enforce valid UTF-8 on the read.
+ UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readStringRequireUtf8());
+ } else if (lite) {
+ // Lite messages use String fields to store strings. Read a string but do not
+ // enforce UTF-8
+ UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readString());
+ } else {
+ // Full runtime messages use Objects to store either a String or ByteString. Read
+ // the string as a ByteString and do not enforce UTF-8.
+ UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes());
+ }
+ }
+
+ private void readStringList(Object message, int typeAndOffset, Reader reader) throws IOException {
+ if (isEnforceUtf8(typeAndOffset)) {
+ reader.readStringListRequireUtf8(
+ listFieldSchema.<String>mutableListAt(message, offset(typeAndOffset)));
+ } else {
+ reader.readStringList(listFieldSchema.<String>mutableListAt(message, offset(typeAndOffset)));
+ }
+ }
+
+ private <E> void readMessageList(
+ Object message,
+ int typeAndOffset,
+ Reader reader,
+ Schema<E> schema,
+ ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ long offset = offset(typeAndOffset);
+ reader.readMessageList(
+ listFieldSchema.<E>mutableListAt(message, offset), schema, extensionRegistry);
+ }
+
+ private <E> void readGroupList(
+ Object message,
+ long offset,
+ Reader reader,
+ Schema<E> schema,
+ ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ reader.readGroupList(
+ listFieldSchema.<E>mutableListAt(message, offset), schema, extensionRegistry);
+ }
+
+ private int numberAt(int pos) {
+ return buffer[pos];
+ }
+
+ private int typeAndOffsetAt(int pos) {
+ return buffer[pos + 1];
+ }
+
+ private int presenceMaskAndOffsetAt(int pos) {
+ return buffer[pos + 2];
+ }
+
+ private static int type(int value) {
+ return (value & FIELD_TYPE_MASK) >>> OFFSET_BITS;
+ }
+
+ private static boolean isRequired(int value) {
+ return (value & REQUIRED_MASK) != 0;
+ }
+
+ private static boolean isEnforceUtf8(int value) {
+ return (value & ENFORCE_UTF8_MASK) != 0;
+ }
+
+ private static long offset(int value) {
+ return value & OFFSET_MASK;
+ }
+
+ private static <T> double doubleAt(T message, long offset) {
+ return UnsafeUtil.getDouble(message, offset);
+ }
+
+ private static <T> float floatAt(T message, long offset) {
+ return UnsafeUtil.getFloat(message, offset);
+ }
+
+ private static <T> int intAt(T message, long offset) {
+ return UnsafeUtil.getInt(message, offset);
+ }
+
+ private static <T> long longAt(T message, long offset) {
+ return UnsafeUtil.getLong(message, offset);
+ }
+
+ private static <T> boolean booleanAt(T message, long offset) {
+ return UnsafeUtil.getBoolean(message, offset);
+ }
+
+ private static <T> double oneofDoubleAt(T message, long offset) {
+ return ((Double) UnsafeUtil.getObject(message, offset)).doubleValue();
+ }
+
+ private static <T> float oneofFloatAt(T message, long offset) {
+ return ((Float) UnsafeUtil.getObject(message, offset)).floatValue();
+ }
+
+ private static <T> int oneofIntAt(T message, long offset) {
+ return ((Integer) UnsafeUtil.getObject(message, offset)).intValue();
+ }
+
+ private static <T> long oneofLongAt(T message, long offset) {
+ return ((Long) UnsafeUtil.getObject(message, offset)).longValue();
+ }
+
+ private static <T> boolean oneofBooleanAt(T message, long offset) {
+ return ((Boolean) UnsafeUtil.getObject(message, offset)).booleanValue();
+ }
+
+ /** Returns true the field is present in both messages, or neither. */
+ private boolean arePresentForEquals(T message, T other, int pos) {
+ return isFieldPresent(message, pos) == isFieldPresent(other, pos);
+ }
+
+ private boolean isFieldPresent(T message, int pos, int presenceField, int presenceMask) {
+ if (proto3) {
+ return isFieldPresent(message, pos);
+ } else {
+ return (presenceField & presenceMask) != 0;
+ }
+ }
+
+ private boolean isFieldPresent(T message, int pos) {
+ if (proto3) {
+ final int typeAndOffset = typeAndOffsetAt(pos);
+ final long offset = offset(typeAndOffset);
+ switch (type(typeAndOffset)) {
+ case 0: // DOUBLE:
+ return UnsafeUtil.getDouble(message, offset) != 0D;
+ case 1: // FLOAT:
+ return UnsafeUtil.getFloat(message, offset) != 0F;
+ case 2: // INT64:
+ return UnsafeUtil.getLong(message, offset) != 0L;
+ case 3: // UINT64:
+ return UnsafeUtil.getLong(message, offset) != 0L;
+ case 4: // INT32:
+ return UnsafeUtil.getInt(message, offset) != 0;
+ case 5: // FIXED64:
+ return UnsafeUtil.getLong(message, offset) != 0L;
+ case 6: // FIXED32:
+ return UnsafeUtil.getInt(message, offset) != 0;
+ case 7: // BOOL:
+ return UnsafeUtil.getBoolean(message, offset);
+ case 8: // STRING:
+ Object value = UnsafeUtil.getObject(message, offset);
+ if (value instanceof String) {
+ return !((String) value).isEmpty();
+ } else if (value instanceof ByteString) {
+ return !ByteString.EMPTY.equals(value);
+ } else {
+ throw new IllegalArgumentException();
+ }
+ case 9: // MESSAGE:
+ return UnsafeUtil.getObject(message, offset) != null;
+ case 10: // BYTES:
+ return !ByteString.EMPTY.equals(UnsafeUtil.getObject(message, offset));
+ case 11: // UINT32:
+ return UnsafeUtil.getInt(message, offset) != 0;
+ case 12: // ENUM:
+ return UnsafeUtil.getInt(message, offset) != 0;
+ case 13: // SFIXED32:
+ return UnsafeUtil.getInt(message, offset) != 0;
+ case 14: // SFIXED64:
+ return UnsafeUtil.getLong(message, offset) != 0L;
+ case 15: // SINT32:
+ return UnsafeUtil.getInt(message, offset) != 0;
+ case 16: // SINT64:
+ return UnsafeUtil.getLong(message, offset) != 0L;
+ case 17: // GROUP:
+ return UnsafeUtil.getObject(message, offset) != null;
+ default:
+ throw new IllegalArgumentException();
+ }
+ } else {
+ int presenceMaskAndOffset = presenceMaskAndOffsetAt(pos);
+ final int presenceMask = 1 << (presenceMaskAndOffset >>> OFFSET_BITS);
+ return (UnsafeUtil.getInt(message, presenceMaskAndOffset & OFFSET_MASK) & presenceMask) != 0;
+ }
+ }
+
+ private void setFieldPresent(T message, int pos) {
+ if (proto3) {
+ // Proto3 doesn't have presence fields
+ return;
+ }
+ int presenceMaskAndOffset = presenceMaskAndOffsetAt(pos);
+ final int presenceMask = 1 << (presenceMaskAndOffset >>> OFFSET_BITS);
+ final long presenceFieldOffset = presenceMaskAndOffset & OFFSET_MASK;
+ UnsafeUtil.putInt(
+ message,
+ presenceFieldOffset,
+ UnsafeUtil.getInt(message, presenceFieldOffset) | presenceMask);
+ }
+
+ private boolean isOneofPresent(T message, int fieldNumber, int pos) {
+ int presenceMaskAndOffset = presenceMaskAndOffsetAt(pos);
+ return UnsafeUtil.getInt(message, presenceMaskAndOffset & OFFSET_MASK) == fieldNumber;
+ }
+
+ private boolean isOneofCaseEqual(T message, T other, int pos) {
+ int presenceMaskAndOffset = presenceMaskAndOffsetAt(pos);
+ return UnsafeUtil.getInt(message, presenceMaskAndOffset & OFFSET_MASK)
+ == UnsafeUtil.getInt(other, presenceMaskAndOffset & OFFSET_MASK);
+ }
+
+ private void setOneofPresent(T message, int fieldNumber, int pos) {
+ int presenceMaskAndOffset = presenceMaskAndOffsetAt(pos);
+ UnsafeUtil.putInt(message, presenceMaskAndOffset & OFFSET_MASK, fieldNumber);
+ }
+
+ private int positionForFieldNumber(final int number) {
+ if (number >= minFieldNumber && number <= maxFieldNumber) {
+ return slowPositionForFieldNumber(number, 0);
+ }
+ return -1;
+ }
+
+ private int positionForFieldNumber(final int number, final int min) {
+ if (number >= minFieldNumber && number <= maxFieldNumber) {
+ return slowPositionForFieldNumber(number, min);
+ }
+ return -1;
+ }
+
+ private int slowPositionForFieldNumber(final int number, int min) {
+ int max = buffer.length / INTS_PER_FIELD - 1;
+ while (min <= max) {
+ // Find the midpoint address.
+ final int mid = (max + min) >>> 1;
+ final int pos = mid * INTS_PER_FIELD;
+ final int midFieldNumber = numberAt(pos);
+ if (number == midFieldNumber) {
+ // Found the field.
+ return pos;
+ }
+ if (number < midFieldNumber) {
+ // Search the lower half.
+ max = mid - 1;
+ } else {
+ // Search the upper half.
+ min = mid + 1;
+ }
+ }
+ return -1;
+ }
+
+ int getSchemaSize() {
+ return buffer.length * 3;
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java b/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java
new file mode 100755
index 0000000..187dc8b
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java
@@ -0,0 +1,392 @@
+// 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.Iterator;
+import java.util.Map.Entry;
+
+/** Schema used for proto2 messages using message_set_wireformat. */
+final class MessageSetSchema<T> implements Schema<T> {
+ private final MessageLite defaultInstance;
+ private final UnknownFieldSchema<?, ?> unknownFieldSchema;
+ private final boolean hasExtensions;
+ private final ExtensionSchema<?> extensionSchema;
+
+ private MessageSetSchema(
+ UnknownFieldSchema<?, ?> unknownFieldSchema,
+ ExtensionSchema<?> extensionSchema,
+ MessageLite defaultInstance) {
+ this.unknownFieldSchema = unknownFieldSchema;
+ this.hasExtensions = extensionSchema.hasExtensions(defaultInstance);
+ this.extensionSchema = extensionSchema;
+ this.defaultInstance = defaultInstance;
+ }
+
+ static <T> MessageSetSchema<T> newSchema(
+ UnknownFieldSchema<?, ?> unknownFieldSchema,
+ ExtensionSchema<?> extensionSchema,
+ MessageLite defaultInstance) {
+ return new MessageSetSchema<T>(unknownFieldSchema, extensionSchema, defaultInstance);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public T newInstance() {
+ return (T) defaultInstance.newBuilderForType().buildPartial();
+ }
+
+ @Override
+ public boolean equals(T message, T other) {
+ Object messageUnknown = unknownFieldSchema.getFromMessage(message);
+ Object otherUnknown = unknownFieldSchema.getFromMessage(other);
+ if (!messageUnknown.equals(otherUnknown)) {
+ return false;
+ }
+ if (hasExtensions) {
+ FieldSet<?> messageExtensions = extensionSchema.getExtensions(message);
+ FieldSet<?> otherExtensions = extensionSchema.getExtensions(other);
+ return messageExtensions.equals(otherExtensions);
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode(T message) {
+ int hashCode = unknownFieldSchema.getFromMessage(message).hashCode();
+ if (hasExtensions) {
+ FieldSet<?> extensions = extensionSchema.getExtensions(message);
+ hashCode = (hashCode * 53) + extensions.hashCode();
+ }
+ return hashCode;
+ }
+
+ @Override
+ public void mergeFrom(T message, T other) {
+ SchemaUtil.mergeUnknownFields(unknownFieldSchema, message, other);
+ if (hasExtensions) {
+ SchemaUtil.mergeExtensions(extensionSchema, message, other);
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public void writeTo(T message, Writer writer) throws IOException {
+ FieldSet<?> extensions = extensionSchema.getExtensions(message);
+ Iterator<?> iterator = extensions.iterator();
+ while (iterator.hasNext()) {
+ Entry<?, ?> extension = (Entry<?, ?>) iterator.next();
+ FieldSet.FieldDescriptorLite<?> fd = (FieldSet.FieldDescriptorLite<?>) extension.getKey();
+ if (fd.getLiteJavaType() != WireFormat.JavaType.MESSAGE || fd.isRepeated() || fd.isPacked()) {
+ throw new IllegalStateException("Found invalid MessageSet item.");
+ }
+ if (extension instanceof LazyField.LazyEntry) {
+ writer.writeMessageSetItem(
+ fd.getNumber(), ((LazyField.LazyEntry) extension).getField().toByteString());
+ } else {
+ writer.writeMessageSetItem(fd.getNumber(), extension.getValue());
+ }
+ }
+ writeUnknownFieldsHelper(unknownFieldSchema, message, writer);
+ }
+
+ /**
+ * A helper method for wildcard capture of {@code unknownFieldSchema}. See:
+ * https://docs.oracle.com/javase/tutorial/java/generics/capture.html
+ */
+ private <UT, UB> void writeUnknownFieldsHelper(
+ UnknownFieldSchema<UT, UB> unknownFieldSchema, T message, Writer writer) throws IOException {
+ unknownFieldSchema.writeAsMessageSetTo(unknownFieldSchema.getFromMessage(message), writer);
+ }
+
+ @SuppressWarnings("ReferenceEquality")
+ @Override
+ public void mergeFrom(
+ T message, byte[] data, int position, int limit, ArrayDecoders.Registers registers)
+ throws IOException {
+ UnknownFieldSetLite unknownFields = ((GeneratedMessageLite) message).unknownFields;
+ if (unknownFields == UnknownFieldSetLite.getDefaultInstance()) {
+ unknownFields = UnknownFieldSetLite.newInstance();
+ ((GeneratedMessageLite) message).unknownFields = unknownFields;
+ }
+ final FieldSet<GeneratedMessageLite.ExtensionDescriptor> extensions =
+ ((GeneratedMessageLite.ExtendableMessage<?, ?>) message).ensureExtensionsAreMutable();
+ GeneratedMessageLite.GeneratedExtension<?, ?> extension = null;
+ while (position < limit) {
+ position = ArrayDecoders.decodeVarint32(data, position, registers);
+ final int startTag = registers.int1;
+ if (startTag != WireFormat.MESSAGE_SET_ITEM_TAG) {
+ if (WireFormat.getTagWireType(startTag) == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ extension =
+ (GeneratedMessageLite.GeneratedExtension<?, ?>) extensionSchema.findExtensionByNumber(
+ registers.extensionRegistry, defaultInstance,
+ WireFormat.getTagFieldNumber(startTag));
+ if (extension != null) {
+ position =
+ ArrayDecoders.decodeMessageField(
+ Protobuf.getInstance().schemaFor(
+ extension.getMessageDefaultInstance().getClass()),
+ data, position, limit, registers);
+ extensions.setField(extension.descriptor, registers.object1);
+ } else {
+ position =
+ ArrayDecoders.decodeUnknownField(
+ startTag, data, position, limit, unknownFields, registers);
+ }
+ } else {
+ position = ArrayDecoders.skipField(startTag, data, position, limit, registers);
+ }
+ continue;
+ }
+
+ int typeId = 0;
+ ByteString rawBytes = null;
+
+ while (position < limit) {
+ position = ArrayDecoders.decodeVarint32(data, position, registers);
+ final int tag = registers.int1;
+ final int number = WireFormat.getTagFieldNumber(tag);
+ final int wireType = WireFormat.getTagWireType(tag);
+ switch (number) {
+ case WireFormat.MESSAGE_SET_TYPE_ID:
+ if (wireType == WireFormat.WIRETYPE_VARINT) {
+ position = ArrayDecoders.decodeVarint32(data, position, registers);
+ typeId = registers.int1;
+ extension =
+ (GeneratedMessageLite.GeneratedExtension<?, ?>) extensionSchema
+ .findExtensionByNumber(registers.extensionRegistry, defaultInstance, typeId);
+ continue;
+ }
+ break;
+ case WireFormat.MESSAGE_SET_MESSAGE:
+ if (extension != null) {
+ position = ArrayDecoders.decodeMessageField(
+ Protobuf.getInstance().schemaFor(
+ extension.getMessageDefaultInstance().getClass()),
+ data, position, limit, registers);
+ extensions.setField(extension.descriptor, registers.object1);
+ continue;
+ } else {
+ if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ position = ArrayDecoders.decodeBytes(data, position, registers);
+ rawBytes = (ByteString) registers.object1;
+ continue;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ if (tag == WireFormat.MESSAGE_SET_ITEM_END_TAG) {
+ break;
+ }
+ position = ArrayDecoders.skipField(tag, data, position, limit, registers);
+ }
+
+ if (rawBytes != null) {
+ unknownFields.storeField(
+ WireFormat.makeTag(typeId, WireFormat.WIRETYPE_LENGTH_DELIMITED), rawBytes);
+ }
+ }
+ if (position != limit) {
+ throw InvalidProtocolBufferException.parseFailure();
+ }
+ }
+
+ @Override
+ public void mergeFrom(T message, Reader reader, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ mergeFromHelper(unknownFieldSchema, extensionSchema, message, reader, extensionRegistry);
+ }
+
+ /**
+ * A helper method for wildcard capture of {@code unknownFieldSchema}. See:
+ * https://docs.oracle.com/javase/tutorial/java/generics/capture.html
+ */
+ @SuppressWarnings("unchecked")
+ private <UT, UB, ET extends FieldSet.FieldDescriptorLite<ET>> void mergeFromHelper(
+ UnknownFieldSchema<UT, UB> unknownFieldSchema,
+ ExtensionSchema<ET> extensionSchema,
+ T message,
+ Reader reader,
+ ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ UB unknownFields = unknownFieldSchema.getBuilderFromMessage(message);
+ FieldSet<ET> extensions = extensionSchema.getMutableExtensions(message);
+ try {
+ while (true) {
+ final int number = reader.getFieldNumber();
+ if (number == Reader.READ_DONE) {
+ return;
+ }
+ if (parseMessageSetItemOrUnknownField(
+ reader,
+ extensionRegistry,
+ extensionSchema,
+ extensions,
+ unknownFieldSchema,
+ unknownFields)) {
+ continue;
+ }
+ // Done reading.
+ return;
+ }
+ } finally {
+ unknownFieldSchema.setBuilderToMessage(message, unknownFields);
+ }
+ }
+
+ @Override
+ public void makeImmutable(T message) {
+ unknownFieldSchema.makeImmutable(message);
+ extensionSchema.makeImmutable(message);
+ }
+
+ private <UT, UB, ET extends FieldSet.FieldDescriptorLite<ET>>
+ boolean parseMessageSetItemOrUnknownField(
+ Reader reader,
+ ExtensionRegistryLite extensionRegistry,
+ ExtensionSchema<ET> extensionSchema,
+ FieldSet<ET> extensions,
+ UnknownFieldSchema<UT, UB> unknownFieldSchema,
+ UB unknownFields)
+ throws IOException {
+ int startTag = reader.getTag();
+ if (startTag != WireFormat.MESSAGE_SET_ITEM_TAG) {
+ if (WireFormat.getTagWireType(startTag) == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ Object extension =
+ extensionSchema.findExtensionByNumber(
+ extensionRegistry, defaultInstance, WireFormat.getTagFieldNumber(startTag));
+ if (extension != null) {
+ extensionSchema.parseLengthPrefixedMessageSetItem(
+ reader, extension, extensionRegistry, extensions);
+ return true;
+ } else {
+ return unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader);
+ }
+ } else {
+ return reader.skipField();
+ }
+ }
+
+ // The wire format for MessageSet is:
+ // message MessageSet {
+ // repeated group Item = 1 {
+ // required int32 typeId = 2;
+ // required bytes message = 3;
+ // }
+ // }
+ // "typeId" is the extension's field number. The extension can only be
+ // a message type, where "message" contains the encoded bytes of that
+ // message.
+ //
+ // In practice, we will probably never see a MessageSet item in which
+ // the message appears before the type ID, or where either field does not
+ // appear exactly once. However, in theory such cases are valid, so we
+ // should be prepared to accept them.
+
+ int typeId = 0;
+ ByteString rawBytes = null; // If we encounter "message" before "typeId"
+ Object extension = null;
+
+ // Read bytes from input, if we get it's type first then parse it eagerly,
+ // otherwise we store the raw bytes in a local variable.
+ loop:
+ while (true) {
+ final int number = reader.getFieldNumber();
+ if (number == Reader.READ_DONE) {
+ break;
+ }
+
+ final int tag = reader.getTag();
+ if (tag == WireFormat.MESSAGE_SET_TYPE_ID_TAG) {
+ typeId = reader.readUInt32();
+ extension =
+ extensionSchema.findExtensionByNumber(extensionRegistry, defaultInstance, typeId);
+ continue;
+ } else if (tag == WireFormat.MESSAGE_SET_MESSAGE_TAG) {
+ if (extension != null) {
+ extensionSchema.parseLengthPrefixedMessageSetItem(
+ reader, extension, extensionRegistry, extensions);
+ continue;
+ }
+ // We haven't seen a type ID yet or we want parse message lazily.
+ rawBytes = reader.readBytes();
+ continue;
+ } else {
+ if (!reader.skipField()) {
+ break loop; // End of group
+ }
+ }
+ }
+
+ if (reader.getTag() != WireFormat.MESSAGE_SET_ITEM_END_TAG) {
+ throw InvalidProtocolBufferException.invalidEndTag();
+ }
+
+ // If there are any rawBytes left, it means the message content appears before the type ID.
+ if (rawBytes != null) {
+ if (extension != null) { // We known the type
+ // TODO(xiaofeng): Instead of reading into a temporary ByteString, maybe there is a way
+ // to read directly from Reader to the submessage?
+ extensionSchema.parseMessageSetItem(rawBytes, extension, extensionRegistry, extensions);
+ } else {
+ unknownFieldSchema.addLengthDelimited(unknownFields, typeId, rawBytes);
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public final boolean isInitialized(T message) {
+ FieldSet<?> extensions = extensionSchema.getExtensions(message);
+ return extensions.isInitialized();
+ }
+
+ @Override
+ public int getSerializedSize(T message) {
+ int size = 0;
+
+ size += getUnknownFieldsSerializedSize(unknownFieldSchema, message);
+
+ if (hasExtensions) {
+ size += extensionSchema.getExtensions(message).getMessageSetSerializedSize();
+ }
+
+ return size;
+ }
+
+ private <UT, UB> int getUnknownFieldsSerializedSize(
+ UnknownFieldSchema<UT, UB> schema, T message) {
+ UT unknowns = schema.getFromMessage(message);
+ return schema.getSerializedSizeAsMessageSet(unknowns);
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/NewInstanceSchema.java b/java/core/src/main/java/com/google/protobuf/NewInstanceSchema.java
new file mode 100755
index 0000000..f2dbb8e
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/NewInstanceSchema.java
@@ -0,0 +1,36 @@
+// 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;
+
+interface NewInstanceSchema {
+ /** Create a new message instance given the default instance of the message type. */
+ Object newInstance(Object defaultInstance);
+}
diff --git a/java/core/src/main/java/com/google/protobuf/NewInstanceSchemaFull.java b/java/core/src/main/java/com/google/protobuf/NewInstanceSchemaFull.java
new file mode 100755
index 0000000..3433b65
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/NewInstanceSchemaFull.java
@@ -0,0 +1,39 @@
+// 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;
+
+final class NewInstanceSchemaFull implements NewInstanceSchema {
+ @Override
+ public Object newInstance(Object defaultInstance) {
+ return ((GeneratedMessageV3) defaultInstance)
+ .newInstance(GeneratedMessageV3.UnusedPrivateParameter.INSTANCE);
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/NewInstanceSchemaLite.java b/java/core/src/main/java/com/google/protobuf/NewInstanceSchemaLite.java
new file mode 100755
index 0000000..9b92266
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/NewInstanceSchemaLite.java
@@ -0,0 +1,39 @@
+// 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;
+
+final class NewInstanceSchemaLite implements NewInstanceSchema {
+ @Override
+ public Object newInstance(Object defaultInstance) {
+ return ((GeneratedMessageLite) defaultInstance)
+ .dynamicMethod(GeneratedMessageLite.MethodToInvoke.NEW_MUTABLE_INSTANCE);
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/NewInstanceSchemas.java b/java/core/src/main/java/com/google/protobuf/NewInstanceSchemas.java
new file mode 100755
index 0000000..eff45f6
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/NewInstanceSchemas.java
@@ -0,0 +1,53 @@
+// 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;
+
+final class NewInstanceSchemas {
+ private static final NewInstanceSchema FULL_SCHEMA = loadSchemaForFullRuntime();
+ private static final NewInstanceSchema LITE_SCHEMA = new NewInstanceSchemaLite();
+
+ static NewInstanceSchema full() {
+ return FULL_SCHEMA;
+ }
+
+ static NewInstanceSchema lite() {
+ return LITE_SCHEMA;
+ }
+
+ private static NewInstanceSchema loadSchemaForFullRuntime() {
+ try {
+ Class<?> clazz = Class.forName("com.google.protobuf.NewInstanceSchemaFull");
+ return (NewInstanceSchema) clazz.getDeclaredConstructor().newInstance();
+ } catch (Exception e) {
+ return null;
+ }
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/OneofInfo.java b/java/core/src/main/java/com/google/protobuf/OneofInfo.java
new file mode 100755
index 0000000..bc518fc
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/OneofInfo.java
@@ -0,0 +1,66 @@
+// 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;
+
+/** Information for a oneof within a protobuf message. */
+// TODO(nathanmittler): make this private once all of experimental code is migrated to protobuf.
+@ExperimentalApi
+final class OneofInfo {
+ private final int id;
+ private final Field caseField;
+ private final Field valueField;
+
+ public OneofInfo(int id, Field caseField, Field valueField) {
+ this.id = id;
+ this.caseField = caseField;
+ this.valueField = valueField;
+ }
+
+ /**
+ * Returns the unique identifier of the oneof within the message. This is really just an index
+ * starting at zero.
+ */
+ public int getId() {
+ return id;
+ }
+
+ /** The {@code int} field containing the field number of the currently active member. */
+ public Field getCaseField() {
+ return caseField;
+ }
+
+ /** The {@link Object} field containing the value of the currently active member. */
+ public Field getValueField() {
+ return valueField;
+ }
+}
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 100755
index 0000000..851b839
--- /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 100755
index 0000000..adaa7fa
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/Protobuf.java
@@ -0,0 +1,152 @@
+// 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
+final class Protobuf {
+ private static final Protobuf INSTANCE = new Protobuf();
+
+ private final SchemaFactory schemaFactory;
+
+ // TODO(nathanmittler): Consider using ClassValue instead.
+ private final ConcurrentMap<Class<?>, Schema<?>> schemaCache =
+ new ConcurrentHashMap<Class<?>, 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 <T> void writeTo(T message, Writer writer) throws IOException {
+ schemaFor(message).writeTo(message, writer);
+ }
+
+ /** Reads fields from the given {@link Reader} and merges them into the message. */
+ public <T> void mergeFrom(T message, Reader reader) throws IOException {
+ mergeFrom(message, reader, ExtensionRegistryLite.getEmptyRegistry());
+ }
+
+ /** Reads fields from the given {@link Reader} and merges them into the message. */
+ public <T> void mergeFrom(T message, Reader reader, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ schemaFor(message).mergeFrom(message, reader, extensionRegistry);
+ }
+
+ /** Marks repeated/map/extension/unknown fields as immutable. */
+ public <T> void makeImmutable(T message) {
+ schemaFor(message).makeImmutable(message);
+ }
+
+ /**
+ * Checks if all required fields are set. TODO(xiaofeng): Make this package private when the tests
+ * are moved to protobuf package.
+ */
+ public <T> boolean isInitialized(T message) {
+ return schemaFor(message).isInitialized(message);
+ }
+
+ /** Gets the schema for the given message type. */
+ public <T> Schema<T> schemaFor(Class<T> messageType) {
+ checkNotNull(messageType, "messageType");
+ @SuppressWarnings("unchecked")
+ Schema<T> schema = (Schema<T>) schemaCache.get(messageType);
+ if (schema == null) {
+ schema = schemaFactory.createSchema(messageType);
+ @SuppressWarnings("unchecked")
+ Schema<T> previous = (Schema<T>) 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 <T> Schema<T> schemaFor(T message) {
+ return schemaFor((Class<T>) 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() {
+ schemaFactory = new ManifestSchemaFactory();
+ }
+
+ int getTotalSchemaSize() {
+ int result = 0;
+ for (Schema<?> schema : schemaCache.values()) {
+ if (schema instanceof MessageSchema) {
+ result += ((MessageSchema) schema).getSchemaSize();
+ }
+ }
+ return result;
+ }
+}
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 100755
index 0000000..271c849
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/ProtobufLists.java
@@ -0,0 +1,94 @@
+// 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
+final class ProtobufLists {
+ private ProtobufLists() {}
+
+ public static <E> ProtobufList<E> emptyProtobufList() {
+ return ProtobufArrayList.emptyList();
+ }
+
+ public static <E> ProtobufList<E> mutableCopy(ProtobufList<E> 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/RawMessageInfo.java b/java/core/src/main/java/com/google/protobuf/RawMessageInfo.java
new file mode 100755
index 0000000..b9a3d2b
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/RawMessageInfo.java
@@ -0,0 +1,220 @@
+// 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;
+
+/**
+ * RawMessageInfo stores the same amount of information as {@link MessageInfo} but in a more compact
+ * format.
+ */
+final class RawMessageInfo implements MessageInfo {
+
+ private final MessageLite defaultInstance;
+
+ /**
+ * The compact format packs everything in a String object and a Object[] array. The String object
+ * is encoded with field number, field type, hasbits offset, oneof index, etc., whereas the
+ * Object[] array contains field references, class references, instance references, etc.
+ *
+ * <p>The String object encodes a sequence of integers into UTF-16 characters. For each int, it
+ * will be encoding into 1 to 3 UTF-16 characters depending on its unsigned value:
+ *
+ * <ul>
+ * <li>1 char: [c1: 0x0000 - 0xD7FF] = int of the same value.
+ * <li>2 chars: [c1: 0xE000 - 0xFFFF], [c2: 0x0000 - 0xD7FF] = (c2 << 13) | (c1 & 0x1FFF)
+ * <li>3 chars: [c1: 0xE000 - 0xFFFF], [c2: 0xE000 - 0xFFFF], [c3: 0x0000 - 0xD7FF] = (c3 << 26)
+ * | ((c2 & 0x1FFF) << 13) | (c1 & 0x1FFF)
+ * </ul>
+ *
+ * <p>Note that we don't use UTF-16 surrogate pairs [0xD800 - 0xDFFF] because they have to come in
+ * pairs to form a valid UTF-16char sequence and don't help us encode values more efficiently.
+ *
+ * <p>The integer sequence encoded in the String object has the following layout:
+ *
+ * <ul>
+ * <li>[0]: flags, flags & 0x1 = is proto2?, flags & 0x2 = is message?.
+ * <li>[1]: field count, if 0, this is the end of the integer sequence and the corresponding
+ * Object[] array should be null.
+ * <li>[2]: oneof count
+ * <li>[3]: hasbits count, how many hasbits integers are generated.
+ * <li>[4]: min field number
+ * <li>[5]: max field number
+ * <li>[6]: total number of entries need to allocate
+ * <li>[7]: map field count
+ * <li>[8]: repeated field count, this doesn't include map fields.
+ * <li>[9]: size of checkInitialized array
+ * <li>[...]: field entries
+ * </ul>
+ *
+ * <p>Each field entry starts with a field number and the field type:
+ *
+ * <ul>
+ * <li>[0]: field number
+ * <li>[1]: field type with extra bits:
+ * <ul>
+ * <li>v & 0xFF = field type as defined in the FieldType class
+ * <li>v & 0x100 = is required?
+ * <li>v & 0x200 = is checkUtf8?
+ * <li>v & 0x400 = needs isInitialized check?
+ * <li>v & 0x800 = is map field with proto2 enum value?
+ * </ul>
+ * </ul>
+ *
+ * If the file is proto2 and this is a singular field:
+ *
+ * <ul>
+ * <li>[2]: hasbits offset
+ * </ul>
+ *
+ * If the field is in an oneof:
+ *
+ * <ul>
+ * <li>[2]: oenof index
+ * </ul>
+ *
+ * For other types, the field entry only has field number and field type.
+ *
+ * <p>The Object[] array has 3 sections:
+ *
+ * <ul>
+ * <li>---- oneof section ----
+ * <ul>
+ * <li>[0]: value field for oneof 1.
+ * <li>[1]: case field for oneof 1.
+ * <li>...
+ * <li>[.]: value field for oneof n.
+ * <li>[.]: case field for oneof n.
+ * </ul>
+ * <li>---- hasbits section ----
+ * <ul>
+ * <li>[.]: hasbits field 1
+ * <li>[.]: hasbits field 2
+ * <li>...
+ * <li>[.]: hasbits field n
+ * </ul>
+ * <li>---- field section ----
+ * <ul>
+ * <li>[...]: field entries
+ * </ul>
+ * </ul>
+ *
+ * <p>In the Object[] array, field entries are ordered in the same way as field entries in the
+ * String object. The size of each entry is determined by the field type.
+ *
+ * <ul>
+ * <li>Oneof field:
+ * <ul>
+ * <li>Oneof message field:
+ * <ul>
+ * <li>[0]: message class reference.
+ * </ul>
+ * <li>Oneof enum fieldin proto2:
+ * <ul>
+ * <li>[0]: EnumLiteMap
+ * </ul>
+ * <li>For all other oneof fields, field entry in the Object[] array is empty.
+ * </ul>
+ * <li>Repeated message field:
+ * <ul>
+ * <li>[0]: field reference
+ * <li>[1]: message class reference
+ * </ul>
+ * <li>Proto2 singular/repeated enum field:
+ * <ul>
+ * <li>[0]: field reference
+ * <li>[1]: EnumLiteMap
+ * </ul>
+ * <li>Map field with a proto2 enum value:
+ * <ul>
+ * <li>[0]: field reference
+ * <li>[1]: map default entry instance
+ * <li>[2]: EnumLiteMap
+ * </ul>
+ * <li>Map field with other value types:
+ * <ul>
+ * <li>[0]: field reference
+ * <li>[1]: map default entry instance
+ * </ul>
+ * <li>All other field type:
+ * <ul>
+ * <li>[0]: field reference
+ * </ul>
+ * </ul>
+ *
+ * <p>In order to read the field info from this compact format, a reader needs to progress through
+ * the String object and the Object[] array simultaneously.
+ */
+ private final String info;
+
+ private final Object[] objects;
+ private final int flags;
+
+ RawMessageInfo(MessageLite defaultInstance, String info, Object[] objects) {
+ this.defaultInstance = defaultInstance;
+ this.info = info;
+ this.objects = objects;
+ int position = 0;
+ int value = (int) info.charAt(position++);
+ if (value < 0xD800) {
+ flags = value;
+ } else {
+ int result = value & 0x1FFF;
+ int shift = 13;
+ while ((value = info.charAt(position++)) >= 0xD800) {
+ result |= (value & 0x1FFF) << shift;
+ shift += 13;
+ }
+ flags = result | (value << shift);
+ }
+ }
+
+ String getStringInfo() {
+ return info;
+ }
+
+ Object[] getObjects() {
+ return objects;
+ }
+
+ @Override
+ public MessageLite getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ @Override
+ public ProtoSyntax getSyntax() {
+ return (flags & 0x1) == 0x1 ? ProtoSyntax.PROTO2 : ProtoSyntax.PROTO3;
+ }
+
+ @Override
+ public boolean isMessageSetWireFormat() {
+ return (flags & 0x2) == 0x2;
+ }
+}
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 100755
index 0000000..705096f
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/Reader.java
@@ -0,0 +1,379 @@
+// 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;
+import java.util.Map;
+
+/** A reader of fields from a serialized protobuf message. */
+// TODO(nathanmittler): Refactor to allow the reader to allocate properly sized lists.
+@ExperimentalApi
+interface Reader {
+ /** Value used to indicate that the end of input has been reached. */
+ int READ_DONE = Integer.MAX_VALUE;
+
+ /** Value used to indicate that the reader does not know the tag about the field. */
+ int TAG_UNKNOWN = 0;
+
+ boolean shouldDiscardUnknownFields();
+
+ /**
+ * Gets the field number for the current field being read.
+ *
+ * <p>TODO(liujisi): Rename it to make it more explicit about the side effect on the underlying
+ * buffer.
+ *
+ * @return the current field number or {@link #READ_DONE} if the end of input has been reached.
+ */
+ int getFieldNumber() throws IOException;
+
+ /**
+ * Gets the wire tag of the current field.
+ *
+ * @return the current wire tag or {@link #TAG_UNKNOWN} if the reader does not know the tag of the
+ * current field.
+ */
+ int getTag();
+
+ /**
+ * Skips the current field and advances the reader to the next field.
+ *
+ * @return {@code true} if there are more fields or {@code false} 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. If the stream contains malformed UTF-8, replace the offending bytes with the standard
+ * UTF-8 replacement character.
+ */
+ String readString() throws IOException;
+
+ /**
+ * Reads and returns the next field of type {@code STRING} and advances the reader to the next
+ * field. If the stream contains malformed UTF-8, throw exception {@link
+ * InvalidProtocolBufferException}.
+ */
+ String readStringRequireUtf8() throws IOException;
+
+ // TODO(yilunchong): the lack of other opinions for whether to expose this on the interface
+ <T> T readMessageBySchemaWithCheck(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException;
+
+ /**
+ * Reads and returns the next field of type {@code MESSAGE} and advances the reader to the next
+ * field.
+ */
+ <T> T readMessage(Class<T> clazz, ExtensionRegistryLite extensionRegistry) 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> T readGroup(Class<T> clazz, ExtensionRegistryLite extensionRegistry) throws IOException;
+
+ // TODO(yilunchong): the lack of other opinions for whether to expose this on the interface
+ @Deprecated
+ <T> T readGroupBySchemaWithCheck(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ 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<Double> 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<Float> 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<Long> 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<Long> 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<Integer> 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<Long> 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<Integer> 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<Boolean> 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<String> target) throws IOException;
+
+ /**
+ * Reads the next field of type {@code STRING_LIST} and advances the reader to the next field. If
+ * the stream contains malformed UTF-8, throw exception {@link InvalidProtocolBufferException}.
+ *
+ * @param target the list that will receive the read values.
+ */
+ void readStringListRequireUtf8(List<String> 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.
+ */
+ <T> void readMessageList(
+ List<T> target, Schema<T> schema, ExtensionRegistryLite extensionRegistry) throws IOException;
+
+ <T> void readMessageList(
+ List<T> target, Class<T> targetType, ExtensionRegistryLite extensionRegistry)
+ 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
+ <T> void readGroupList(
+ List<T> target, Class<T> targetType, ExtensionRegistryLite extensionRegistry)
+ throws IOException;
+
+ @Deprecated
+ <T> void readGroupList(
+ List<T> target, Schema<T> targetType, ExtensionRegistryLite extensionRegistry)
+ 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<ByteString> 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<Integer> 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<Integer> 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<Integer> 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<Long> 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<Integer> 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<Long> target) throws IOException;
+
+ /**
+ * Reads the next field of type {@code MAP} and advances the reader to the next field.
+ *
+ * @param target the mutable map that will receive the read values.
+ * @param mapDefaultEntry the default entry of the map field.
+ * @param extensionRegistry the extension registry for parsing message value fields.
+ */
+ <K, V> void readMap(
+ Map<K, V> target,
+ MapEntryLite.Metadata<K, V> mapDefaultEntry,
+ ExtensionRegistryLite extensionRegistry)
+ 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 c3bec7b..f294df3 100644
--- a/java/core/src/main/java/com/google/protobuf/RopeByteString.java
+++ b/java/core/src/main/java/com/google/protobuf/RopeByteString.java
@@ -445,6 +445,11 @@
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 100755
index 0000000..d0e1e26
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/Schema.java
@@ -0,0 +1,85 @@
+// 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.ArrayDecoders.Registers;
+import java.io.IOException;
+
+/**
+ * A runtime schema for a single protobuf message. A schema provides operations on message instances
+ * such as serialization/deserialization.
+ */
+@ExperimentalApi
+interface Schema<T> {
+ /** Writes the given message to the target {@link Writer}. */
+ void writeTo(T message, Writer writer) throws IOException;
+
+ /**
+ * Reads fields from the given {@link Reader} and merges them into the message. It doesn't make
+ * the message immutable after parsing is done. To make the message immutable, use {@link
+ * #makeImmutable}.
+ */
+ void mergeFrom(T message, Reader reader, ExtensionRegistryLite extensionRegistry)
+ throws IOException;
+
+ /**
+ * Like the above but parses from a byte[] without extensions. Entry point of fast path. Note that
+ * this method may throw IndexOutOfBoundsException if the input data is not valid protobuf wire
+ * format. Protobuf public API methods should catch and convert that exception to
+ * InvalidProtocolBufferException.
+ */
+ void mergeFrom(T message, byte[] data, int position, int limit, Registers registers)
+ throws IOException;
+
+ /** Marks repeated/map/extension/unknown fields as immutable. */
+ void makeImmutable(T message);
+
+ /** Checks whether all required fields are set. */
+ boolean isInitialized(T message);
+
+ /** Creates a new instance of the message class. */
+ T newInstance();
+
+ /** Determine of the two messages are equal. */
+ boolean equals(T message, T other);
+
+ /** Compute a hashCode for the message. */
+ int hashCode(T message);
+
+ /**
+ * Merge values from {@code other} into {@code message}. This method doesn't make the message
+ * immutable. To make the message immutable after merging, use {@link #makeImmutable}.
+ */
+ void mergeFrom(T message, T other);
+
+ /** Compute the serialized size of the message. */
+ int getSerializedSize(T message);
+}
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 100755
index 0000000..cf38dd6
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/SchemaFactory.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 manufactures {@link Schema} instances for protobuf messages. */
+@ExperimentalApi
+interface SchemaFactory {
+ /** Creates a schema instance for the given protobuf message type. */
+ <T> Schema<T> createSchema(Class<T> 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 100755
index 0000000..50957fc
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/SchemaUtil.java
@@ -0,0 +1,991 @@
+// 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.FieldSet.FieldDescriptorLite;
+import com.google.protobuf.Internal.EnumLiteMap;
+import com.google.protobuf.Internal.EnumVerifier;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.Iterator;
+import java.util.List;
+import java.util.RandomAccess;
+
+/** Helper methods used by schemas. */
+@ExperimentalApi
+final class SchemaUtil {
+ private static final Class<?> GENERATED_MESSAGE_CLASS = getGeneratedMessageClass();
+ private static final UnknownFieldSchema<?, ?> PROTO2_UNKNOWN_FIELD_SET_SCHEMA =
+ getUnknownFieldSetSchema(false);
+ private static final UnknownFieldSchema<?, ?> PROTO3_UNKNOWN_FIELD_SET_SCHEMA =
+ getUnknownFieldSetSchema(true);
+ private static final UnknownFieldSchema<?, ?> UNKNOWN_FIELD_SET_LITE_SCHEMA =
+ new UnknownFieldSetLiteSchema();
+
+ private static final int DEFAULT_LOOK_UP_START_NUMBER = 40;
+
+ private SchemaUtil() {}
+
+ /**
+ * Requires that the given message extend {@link com.google.protobuf.GeneratedMessageV3} or {@link
+ * GeneratedMessageLite}.
+ */
+ public static void requireGeneratedMessage(Class<?> messageType) {
+ if (!GeneratedMessageLite.class.isAssignableFrom(messageType)
+ && GENERATED_MESSAGE_CLASS != null
+ && !GENERATED_MESSAGE_CLASS.isAssignableFrom(messageType)) {
+ throw new IllegalArgumentException(
+ "Message classes must extend GeneratedMessage or GeneratedMessageLite");
+ }
+ }
+
+ public static void writeDouble(int fieldNumber, double value, Writer writer) throws IOException {
+ if (Double.compare(value, 0.0) != 0) {
+ writer.writeDouble(fieldNumber, value);
+ }
+ }
+
+ public static void writeFloat(int fieldNumber, float value, Writer writer) throws IOException {
+ if (Float.compare(value, 0.0f) != 0) {
+ writer.writeFloat(fieldNumber, value);
+ }
+ }
+
+ public static void writeInt64(int fieldNumber, long value, Writer writer) throws IOException {
+ if (value != 0) {
+ writer.writeInt64(fieldNumber, value);
+ }
+ }
+
+ public static void writeUInt64(int fieldNumber, long value, Writer writer) throws IOException {
+ if (value != 0) {
+ writer.writeUInt64(fieldNumber, value);
+ }
+ }
+
+ public static void writeSInt64(int fieldNumber, long value, Writer writer) throws IOException {
+ if (value != 0) {
+ writer.writeSInt64(fieldNumber, value);
+ }
+ }
+
+ public static void writeFixed64(int fieldNumber, long value, Writer writer) throws IOException {
+ if (value != 0) {
+ writer.writeFixed64(fieldNumber, value);
+ }
+ }
+
+ public static void writeSFixed64(int fieldNumber, long value, Writer writer) throws IOException {
+ if (value != 0) {
+ writer.writeSFixed64(fieldNumber, value);
+ }
+ }
+
+ public static void writeInt32(int fieldNumber, int value, Writer writer) throws IOException {
+ if (value != 0) {
+ writer.writeInt32(fieldNumber, value);
+ }
+ }
+
+ public static void writeUInt32(int fieldNumber, int value, Writer writer) throws IOException {
+ if (value != 0) {
+ writer.writeUInt32(fieldNumber, value);
+ }
+ }
+
+ public static void writeSInt32(int fieldNumber, int value, Writer writer) throws IOException {
+ if (value != 0) {
+ writer.writeSInt32(fieldNumber, value);
+ }
+ }
+
+ public static void writeFixed32(int fieldNumber, int value, Writer writer) throws IOException {
+ if (value != 0) {
+ writer.writeFixed32(fieldNumber, value);
+ }
+ }
+
+ public static void writeSFixed32(int fieldNumber, int value, Writer writer) throws IOException {
+ if (value != 0) {
+ writer.writeSFixed32(fieldNumber, value);
+ }
+ }
+
+ public static void writeEnum(int fieldNumber, int value, Writer writer) throws IOException {
+ if (value != 0) {
+ writer.writeEnum(fieldNumber, value);
+ }
+ }
+
+ public static void writeBool(int fieldNumber, boolean value, Writer writer) throws IOException {
+ if (value) {
+ writer.writeBool(fieldNumber, true);
+ }
+ }
+
+ public static void writeString(int fieldNumber, Object value, Writer writer) throws IOException {
+ 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)
+ throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeString(fieldNumber, value);
+ }
+ }
+
+ public static void writeBytes(int fieldNumber, ByteString value, Writer writer)
+ throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeBytes(fieldNumber, value);
+ }
+ }
+
+ public static void writeMessage(int fieldNumber, Object value, Writer writer) throws IOException {
+ if (value != null) {
+ writer.writeMessage(fieldNumber, value);
+ }
+ }
+
+ public static void writeDoubleList(
+ int fieldNumber, List<Double> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeDoubleList(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeFloatList(
+ int fieldNumber, List<Float> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeFloatList(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeInt64List(
+ int fieldNumber, List<Long> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeInt64List(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeUInt64List(
+ int fieldNumber, List<Long> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeUInt64List(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeSInt64List(
+ int fieldNumber, List<Long> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeSInt64List(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeFixed64List(
+ int fieldNumber, List<Long> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeFixed64List(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeSFixed64List(
+ int fieldNumber, List<Long> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeSFixed64List(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeInt32List(
+ int fieldNumber, List<Integer> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeInt32List(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeUInt32List(
+ int fieldNumber, List<Integer> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeUInt32List(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeSInt32List(
+ int fieldNumber, List<Integer> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeSInt32List(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeFixed32List(
+ int fieldNumber, List<Integer> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeFixed32List(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeSFixed32List(
+ int fieldNumber, List<Integer> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeSFixed32List(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeEnumList(
+ int fieldNumber, List<Integer> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeEnumList(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeBoolList(
+ int fieldNumber, List<Boolean> value, Writer writer, boolean packed) throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeBoolList(fieldNumber, value, packed);
+ }
+ }
+
+ public static void writeStringList(int fieldNumber, List<String> value, Writer writer)
+ throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeStringList(fieldNumber, value);
+ }
+ }
+
+ public static void writeBytesList(int fieldNumber, List<ByteString> value, Writer writer)
+ throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeBytesList(fieldNumber, value);
+ }
+ }
+
+ public static void writeMessageList(int fieldNumber, List<?> value, Writer writer)
+ throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeMessageList(fieldNumber, value);
+ }
+ }
+
+ public static void writeMessageList(int fieldNumber, List<?> value, Writer writer, Schema schema)
+ throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeMessageList(fieldNumber, value, schema);
+ }
+ }
+
+ public static void writeLazyFieldList(int fieldNumber, List<?> value, Writer writer)
+ throws IOException {
+ if (value != null && !value.isEmpty()) {
+ for (Object item : value) {
+ ((LazyFieldLite) item).writeTo(writer, fieldNumber);
+ }
+ }
+ }
+
+ public static void writeGroupList(int fieldNumber, List<?> value, Writer writer)
+ throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeGroupList(fieldNumber, value);
+ }
+ }
+
+ public static void writeGroupList(int fieldNumber, List<?> value, Writer writer, Schema schema)
+ throws IOException {
+ if (value != null && !value.isEmpty()) {
+ writer.writeGroupList(fieldNumber, value, schema);
+ }
+ }
+
+ static int computeSizeInt64ListNoTag(List<Long> list) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+
+ int size = 0;
+
+ if (list instanceof LongArrayList) {
+ final LongArrayList primitiveList = (LongArrayList) list;
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeInt64SizeNoTag(primitiveList.getLong(i));
+ }
+ } else {
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeInt64SizeNoTag(list.get(i));
+ }
+ }
+ return size;
+ }
+
+ static int computeSizeInt64List(int fieldNumber, List<Long> list, boolean packed) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = computeSizeInt64ListNoTag(list);
+
+ if (packed) {
+ return CodedOutputStream.computeTagSize(fieldNumber)
+ + CodedOutputStream.computeLengthDelimitedFieldSize(size);
+ } else {
+ return size + (list.size() * CodedOutputStream.computeTagSize(fieldNumber));
+ }
+ }
+
+ static int computeSizeUInt64ListNoTag(List<Long> list) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+
+ int size = 0;
+
+ if (list instanceof LongArrayList) {
+ final LongArrayList primitiveList = (LongArrayList) list;
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeUInt64SizeNoTag(primitiveList.getLong(i));
+ }
+ } else {
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeUInt64SizeNoTag(list.get(i));
+ }
+ }
+ return size;
+ }
+
+ static int computeSizeUInt64List(int fieldNumber, List<Long> list, boolean packed) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = computeSizeUInt64ListNoTag(list);
+
+ if (packed) {
+ return CodedOutputStream.computeTagSize(fieldNumber)
+ + CodedOutputStream.computeLengthDelimitedFieldSize(size);
+ } else {
+ return size + (length * CodedOutputStream.computeTagSize(fieldNumber));
+ }
+ }
+
+ static int computeSizeSInt64ListNoTag(List<Long> list) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+
+ int size = 0;
+
+ if (list instanceof LongArrayList) {
+ final LongArrayList primitiveList = (LongArrayList) list;
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeSInt64SizeNoTag(primitiveList.getLong(i));
+ }
+ } else {
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeSInt64SizeNoTag(list.get(i));
+ }
+ }
+ return size;
+ }
+
+ static int computeSizeSInt64List(int fieldNumber, List<Long> list, boolean packed) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = computeSizeSInt64ListNoTag(list);
+
+ if (packed) {
+ return CodedOutputStream.computeTagSize(fieldNumber)
+ + CodedOutputStream.computeLengthDelimitedFieldSize(size);
+ } else {
+ return size + (length * CodedOutputStream.computeTagSize(fieldNumber));
+ }
+ }
+
+ static int computeSizeEnumListNoTag(List<Integer> list) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+
+ int size = 0;
+
+ if (list instanceof IntArrayList) {
+ final IntArrayList primitiveList = (IntArrayList) list;
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeEnumSizeNoTag(primitiveList.getInt(i));
+ }
+ } else {
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeEnumSizeNoTag(list.get(i));
+ }
+ }
+ return size;
+ }
+
+ static int computeSizeEnumList(int fieldNumber, List<Integer> list, boolean packed) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = computeSizeEnumListNoTag(list);
+
+ if (packed) {
+ return CodedOutputStream.computeTagSize(fieldNumber)
+ + CodedOutputStream.computeLengthDelimitedFieldSize(size);
+ } else {
+ return size + (length * CodedOutputStream.computeTagSize(fieldNumber));
+ }
+ }
+
+ static int computeSizeInt32ListNoTag(List<Integer> list) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+
+ int size = 0;
+
+ if (list instanceof IntArrayList) {
+ final IntArrayList primitiveList = (IntArrayList) list;
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeInt32SizeNoTag(primitiveList.getInt(i));
+ }
+ } else {
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeInt32SizeNoTag(list.get(i));
+ }
+ }
+ return size;
+ }
+
+ static int computeSizeInt32List(int fieldNumber, List<Integer> list, boolean packed) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = computeSizeInt32ListNoTag(list);
+
+ if (packed) {
+ return CodedOutputStream.computeTagSize(fieldNumber)
+ + CodedOutputStream.computeLengthDelimitedFieldSize(size);
+ } else {
+ return size + (length * CodedOutputStream.computeTagSize(fieldNumber));
+ }
+ }
+
+ static int computeSizeUInt32ListNoTag(List<Integer> list) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+
+ int size = 0;
+
+ if (list instanceof IntArrayList) {
+ final IntArrayList primitiveList = (IntArrayList) list;
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeUInt32SizeNoTag(primitiveList.getInt(i));
+ }
+ } else {
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeUInt32SizeNoTag(list.get(i));
+ }
+ }
+ return size;
+ }
+
+ static int computeSizeUInt32List(int fieldNumber, List<Integer> list, boolean packed) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = computeSizeUInt32ListNoTag(list);
+
+ if (packed) {
+ return CodedOutputStream.computeTagSize(fieldNumber)
+ + CodedOutputStream.computeLengthDelimitedFieldSize(size);
+ } else {
+ return size + (length * CodedOutputStream.computeTagSize(fieldNumber));
+ }
+ }
+
+ static int computeSizeSInt32ListNoTag(List<Integer> list) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+
+ int size = 0;
+
+ if (list instanceof IntArrayList) {
+ final IntArrayList primitiveList = (IntArrayList) list;
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeSInt32SizeNoTag(primitiveList.getInt(i));
+ }
+ } else {
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeSInt32SizeNoTag(list.get(i));
+ }
+ }
+ return size;
+ }
+
+ static int computeSizeSInt32List(int fieldNumber, List<Integer> list, boolean packed) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+
+ int size = computeSizeSInt32ListNoTag(list);
+
+ if (packed) {
+ return CodedOutputStream.computeTagSize(fieldNumber)
+ + CodedOutputStream.computeLengthDelimitedFieldSize(size);
+ } else {
+ return size + (length * CodedOutputStream.computeTagSize(fieldNumber));
+ }
+ }
+
+ static int computeSizeFixed32ListNoTag(List<?> list) {
+ return list.size() * WireFormat.FIXED32_SIZE;
+ }
+
+ static int computeSizeFixed32List(int fieldNumber, List<?> list, boolean packed) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ if (packed) {
+ int dataSize = length * WireFormat.FIXED32_SIZE;
+ return CodedOutputStream.computeTagSize(fieldNumber)
+ + CodedOutputStream.computeLengthDelimitedFieldSize(dataSize);
+ } else {
+ return length * CodedOutputStream.computeFixed32Size(fieldNumber, 0);
+ }
+ }
+
+ static int computeSizeFixed64ListNoTag(List<?> list) {
+ return list.size() * WireFormat.FIXED64_SIZE;
+ }
+
+ static int computeSizeFixed64List(int fieldNumber, List<?> list, boolean packed) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ if (packed) {
+ final int dataSize = length * WireFormat.FIXED64_SIZE;
+ return CodedOutputStream.computeTagSize(fieldNumber)
+ + CodedOutputStream.computeLengthDelimitedFieldSize(dataSize);
+ } else {
+ return length * CodedOutputStream.computeFixed64Size(fieldNumber, 0);
+ }
+ }
+
+ static int computeSizeBoolListNoTag(List<?> list) {
+ // bools are 1 byte varints
+ return list.size();
+ }
+
+ static int computeSizeBoolList(int fieldNumber, List<?> list, boolean packed) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ if (packed) {
+ // bools are 1 byte varints
+ return CodedOutputStream.computeTagSize(fieldNumber)
+ + CodedOutputStream.computeLengthDelimitedFieldSize(length);
+ } else {
+ return length * CodedOutputStream.computeBoolSize(fieldNumber, true);
+ }
+ }
+
+ static int computeSizeStringList(int fieldNumber, List<?> list) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = length * CodedOutputStream.computeTagSize(fieldNumber);
+ if (list instanceof LazyStringList) {
+ LazyStringList lazyList = ((LazyStringList) list);
+ for (int i = 0; i < length; i++) {
+ Object value = lazyList.getRaw(i);
+ if (value instanceof ByteString) {
+ size += CodedOutputStream.computeBytesSizeNoTag((ByteString) value);
+ } else {
+ size += CodedOutputStream.computeStringSizeNoTag((String) value);
+ }
+ }
+ } else {
+ for (int i = 0; i < length; i++) {
+ Object value = list.get(i);
+ if (value instanceof ByteString) {
+ size += CodedOutputStream.computeBytesSizeNoTag((ByteString) value);
+ } else {
+ size += CodedOutputStream.computeStringSizeNoTag((String) value);
+ }
+ }
+ }
+ return size;
+ }
+
+ static int computeSizeMessage(int fieldNumber, Object value, Schema schema) {
+ if (value instanceof LazyFieldLite) {
+ return CodedOutputStream.computeLazyFieldSize(fieldNumber, (LazyFieldLite) value);
+ } else {
+ return CodedOutputStream.computeMessageSize(fieldNumber, (MessageLite) value, schema);
+ }
+ }
+
+ static int computeSizeMessageList(int fieldNumber, List<?> list) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = length * CodedOutputStream.computeTagSize(fieldNumber);
+ for (int i = 0; i < length; i++) {
+ Object value = list.get(i);
+ if (value instanceof LazyFieldLite) {
+ size += CodedOutputStream.computeLazyFieldSizeNoTag((LazyFieldLite) value);
+ } else {
+ size += CodedOutputStream.computeMessageSizeNoTag((MessageLite) value);
+ }
+ }
+ return size;
+ }
+
+ static int computeSizeMessageList(int fieldNumber, List<?> list, Schema schema) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = length * CodedOutputStream.computeTagSize(fieldNumber);
+ for (int i = 0; i < length; i++) {
+ Object value = list.get(i);
+ if (value instanceof LazyFieldLite) {
+ size += CodedOutputStream.computeLazyFieldSizeNoTag((LazyFieldLite) value);
+ } else {
+ size += CodedOutputStream.computeMessageSizeNoTag((MessageLite) value, schema);
+ }
+ }
+ return size;
+ }
+
+ static int computeSizeByteStringList(int fieldNumber, List<ByteString> list) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = length * CodedOutputStream.computeTagSize(fieldNumber);
+ for (int i = 0; i < list.size(); i++) {
+ size += CodedOutputStream.computeBytesSizeNoTag(list.get(i));
+ }
+ return size;
+ }
+
+ static int computeSizeGroupList(int fieldNumber, List<MessageLite> list) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = 0;
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeGroupSize(fieldNumber, list.get(i));
+ }
+ return size;
+ }
+
+ static int computeSizeGroupList(int fieldNumber, List<MessageLite> list, Schema schema) {
+ final int length = list.size();
+ if (length == 0) {
+ return 0;
+ }
+ int size = 0;
+ for (int i = 0; i < length; i++) {
+ size += CodedOutputStream.computeGroupSize(fieldNumber, list.get(i), schema);
+ }
+ return size;
+ }
+
+ /**
+ * Determines whether to issue tableswitch or lookupswitch for the mergeFrom method.
+ *
+ * @see #shouldUseTableSwitch(int, int, int)
+ */
+ public static boolean shouldUseTableSwitch(FieldInfo[] fields) {
+ // Determine whether to issue a tableswitch or a lookupswitch
+ // instruction.
+ if (fields.length == 0) {
+ return false;
+ }
+
+ int lo = fields[0].getFieldNumber();
+ int hi = fields[fields.length - 1].getFieldNumber();
+ return shouldUseTableSwitch(lo, hi, fields.length);
+ }
+
+ /**
+ * Determines whether to issue tableswitch or lookupswitch for the mergeFrom method. This is based
+ * on the <a href=
+ * "http://hg.openjdk.java.net/jdk8/jdk8/langtools/file/30db5e0aaf83/src/share/classes/com/sun/tools/javac/jvm/Gen.java#l1159">
+ * logic in the JDK</a>.
+ *
+ * @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) {
+ if (hi < DEFAULT_LOOK_UP_START_NUMBER) {
+ return true;
+ }
+ long tableSpaceCost = ((long) hi - lo + 1); // words
+ long tableTimeCost = 3; // comparisons
+ long lookupSpaceCost = 3 + 2 * (long) numFields;
+ long lookupTimeCost = 3 + (long) numFields;
+ return tableSpaceCost + 3 * tableTimeCost <= lookupSpaceCost + 3 * lookupTimeCost;
+ }
+
+ public static UnknownFieldSchema<?, ?> proto2UnknownFieldSetSchema() {
+ return PROTO2_UNKNOWN_FIELD_SET_SCHEMA;
+ }
+
+ public static UnknownFieldSchema<?, ?> proto3UnknownFieldSetSchema() {
+ return PROTO3_UNKNOWN_FIELD_SET_SCHEMA;
+ }
+
+ public static UnknownFieldSchema<?, ?> unknownFieldSetLiteSchema() {
+ return UNKNOWN_FIELD_SET_LITE_SCHEMA;
+ }
+
+ private static UnknownFieldSchema<?, ?> getUnknownFieldSetSchema(boolean proto3) {
+ try {
+ Class<?> clz = getUnknownFieldSetSchemaClass();
+ if (clz == null) {
+ return null;
+ }
+ return (UnknownFieldSchema) clz.getConstructor(boolean.class).newInstance(proto3);
+ } catch (Throwable t) {
+ return null;
+ }
+ }
+
+ private static Class<?> getGeneratedMessageClass() {
+ try {
+ return Class.forName("com.google.protobuf.GeneratedMessageV3");
+ } catch (Throwable e) {
+ return null;
+ }
+ }
+
+ private static Class<?> getUnknownFieldSetSchemaClass() {
+ try {
+ return Class.forName("com.google.protobuf.UnknownFieldSetSchema");
+ } catch (Throwable e) {
+ return null;
+ }
+ }
+
+ static Object getMapDefaultEntry(Class<?> clazz, String name) {
+ try {
+ Class<?> holder =
+ Class.forName(clazz.getName() + "$" + toCamelCase(name, true) + "DefaultEntryHolder");
+ Field[] fields = holder.getDeclaredFields();
+ if (fields.length != 1) {
+ throw new IllegalStateException(
+ "Unable to look up map field default entry holder class for "
+ + name
+ + " in "
+ + clazz.getName());
+ }
+ return UnsafeUtil.getStaticObject(fields[0]);
+ } catch (Throwable t) {
+ throw new RuntimeException(t);
+ }
+ }
+
+ static String toCamelCase(String name, boolean capNext) {
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < name.length(); ++i) {
+ char c = name.charAt(i);
+ // Matches protoc field name function:
+ if ('a' <= c && c <= 'z') {
+ if (capNext) {
+ sb.append((char) (c + ('A' - 'a')));
+ } else {
+ sb.append(c);
+ }
+ capNext = false;
+ } else if ('A' <= c && c <= 'Z') {
+ if (i == 0 && !capNext) {
+ // Force first letter to lower-case unless explicitly told to capitalize it.
+ sb.append((char) (c - ('A' - 'a')));
+ } else {
+ sb.append(c);
+ }
+ capNext = false;
+ } else if ('0' <= c && c <= '9') {
+ sb.append(c);
+ capNext = true;
+ } else {
+ capNext = true;
+ }
+ }
+ return sb.toString();
+ }
+
+ /** Returns true if both are null or both are {@link Object#equals}. */
+ static boolean safeEquals(Object a, Object b) {
+ return a == b || (a != null && a.equals(b));
+ }
+
+ static <T> void mergeMap(MapFieldSchema mapFieldSchema, T message, T o, long offset) {
+ Object merged =
+ mapFieldSchema.mergeFrom(
+ UnsafeUtil.getObject(message, offset), UnsafeUtil.getObject(o, offset));
+ UnsafeUtil.putObject(message, offset, merged);
+ }
+
+ static <T, FT extends FieldDescriptorLite<FT>> void mergeExtensions(
+ ExtensionSchema<FT> schema, T message, T other) {
+ FieldSet<FT> otherExtensions = schema.getExtensions(other);
+ if (!otherExtensions.isEmpty()) {
+ FieldSet<FT> messageExtensions = schema.getMutableExtensions(message);
+ messageExtensions.mergeFrom(otherExtensions);
+ }
+ }
+
+ static <T, UT, UB> void mergeUnknownFields(
+ UnknownFieldSchema<UT, UB> schema, T message, T other) {
+ UT messageUnknowns = schema.getFromMessage(message);
+ UT otherUnknowns = schema.getFromMessage(other);
+ UT merged = schema.merge(messageUnknowns, otherUnknowns);
+ schema.setToMessage(message, merged);
+ }
+
+ /** Filters unrecognized enum values in a list. */
+ static <UT, UB> UB filterUnknownEnumList(
+ int number,
+ List<Integer> enumList,
+ EnumLiteMap<?> enumMap,
+ UB unknownFields,
+ UnknownFieldSchema<UT, UB> unknownFieldSchema) {
+ if (enumMap == null) {
+ return unknownFields;
+ }
+ // TODO(dweis): Specialize for IntArrayList to avoid boxing.
+ if (enumList instanceof RandomAccess) {
+ int writePos = 0;
+ int size = enumList.size();
+ for (int readPos = 0; readPos < size; ++readPos) {
+ int enumValue = enumList.get(readPos);
+ if (enumMap.findValueByNumber(enumValue) != null) {
+ if (readPos != writePos) {
+ enumList.set(writePos, enumValue);
+ }
+ ++writePos;
+ } else {
+ unknownFields = storeUnknownEnum(number, enumValue, unknownFields, unknownFieldSchema);
+ }
+ }
+ if (writePos != size) {
+ enumList.subList(writePos, size).clear();
+ }
+ } else {
+ for (Iterator<Integer> it = enumList.iterator(); it.hasNext(); ) {
+ int enumValue = it.next();
+ if (enumMap.findValueByNumber(enumValue) == null) {
+ unknownFields = storeUnknownEnum(number, enumValue, unknownFields, unknownFieldSchema);
+ it.remove();
+ }
+ }
+ }
+ return unknownFields;
+ }
+
+ /** Filters unrecognized enum values in a list. */
+ static <UT, UB> UB filterUnknownEnumList(
+ int number,
+ List<Integer> enumList,
+ EnumVerifier enumVerifier,
+ UB unknownFields,
+ UnknownFieldSchema<UT, UB> unknownFieldSchema) {
+ if (enumVerifier == null) {
+ return unknownFields;
+ }
+ // TODO(dweis): Specialize for IntArrayList to avoid boxing.
+ if (enumList instanceof RandomAccess) {
+ int writePos = 0;
+ int size = enumList.size();
+ for (int readPos = 0; readPos < size; ++readPos) {
+ int enumValue = enumList.get(readPos);
+ if (enumVerifier.isInRange(enumValue)) {
+ if (readPos != writePos) {
+ enumList.set(writePos, enumValue);
+ }
+ ++writePos;
+ } else {
+ unknownFields = storeUnknownEnum(number, enumValue, unknownFields, unknownFieldSchema);
+ }
+ }
+ if (writePos != size) {
+ enumList.subList(writePos, size).clear();
+ }
+ } else {
+ for (Iterator<Integer> it = enumList.iterator(); it.hasNext(); ) {
+ int enumValue = it.next();
+ if (!enumVerifier.isInRange(enumValue)) {
+ unknownFields = storeUnknownEnum(number, enumValue, unknownFields, unknownFieldSchema);
+ it.remove();
+ }
+ }
+ }
+ return unknownFields;
+ }
+
+ /** Stores an unrecognized enum value as an unknown value. */
+ static <UT, UB> UB storeUnknownEnum(
+ int number, int enumValue, UB unknownFields, UnknownFieldSchema<UT, UB> unknownFieldSchema) {
+ if (unknownFields == null) {
+ unknownFields = unknownFieldSchema.newBuilder();
+ }
+ unknownFieldSchema.addVarint(unknownFields, number, enumValue);
+ return unknownFields;
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/SmallSortedMap.java b/java/core/src/main/java/com/google/protobuf/SmallSortedMap.java
index 6bd65d6..546e56e 100644
--- a/java/core/src/main/java/com/google/protobuf/SmallSortedMap.java
+++ b/java/core/src/main/java/com/google/protobuf/SmallSortedMap.java
@@ -136,6 +136,8 @@
// The EntrySet is a stateless view of the Map. It's initialized the first
// time it is requested and reused henceforth.
private volatile EntrySet lazyEntrySet;
+ private Map<K, V> overflowEntriesDescending;
+ private volatile DescendingEntrySet lazyDescendingEntrySet;
/**
* @code arraySize Size of the array in which the lexicographically smallest mappings are stored.
@@ -145,6 +147,7 @@
this.maxArraySize = arraySize;
this.entryList = Collections.emptyList();
this.overflowEntries = Collections.emptyMap();
+ this.overflowEntriesDescending = Collections.emptyMap();
}
/** Make this map immutable from this point forward. */
@@ -158,6 +161,10 @@
overflowEntries.isEmpty()
? Collections.<K, V>emptyMap()
: Collections.unmodifiableMap(overflowEntries);
+ overflowEntriesDescending =
+ overflowEntriesDescending.isEmpty()
+ ? Collections.<K, V>emptyMap()
+ : Collections.unmodifiableMap(overflowEntriesDescending);
isImmutable = true;
}
}
@@ -189,6 +196,11 @@
: overflowEntries.entrySet();
}
+ Iterable<Map.Entry<K, V>> getOverflowEntriesDescending() {
+ return overflowEntriesDescending.isEmpty()
+ ? EmptySet.<Map.Entry<K, V>>iterable()
+ : overflowEntriesDescending.entrySet();
+ }
@Override
public int size() {
@@ -344,6 +356,12 @@
return lazyEntrySet;
}
+ Set<Map.Entry<K, V>> descendingEntrySet() {
+ if (lazyDescendingEntrySet == null) {
+ lazyDescendingEntrySet = new DescendingEntrySet();
+ }
+ return lazyDescendingEntrySet;
+ }
/** @throws UnsupportedOperationException if {@link #makeImmutable()} has has been called. */
private void checkMutable() {
@@ -361,6 +379,7 @@
checkMutable();
if (overflowEntries.isEmpty() && !(overflowEntries instanceof TreeMap)) {
overflowEntries = new TreeMap<K, V>();
+ overflowEntriesDescending = ((TreeMap<K, V>) overflowEntries).descendingMap();
}
return (SortedMap<K, V>) overflowEntries;
}
@@ -501,6 +520,12 @@
}
}
+ private class DescendingEntrySet extends EntrySet {
+ @Override
+ public Iterator<java.util.Map.Entry<K, V>> iterator() {
+ return new DescendingEntryIterator();
+ }
+ }
/**
* Iterator implementation that switches from the entry array to the overflow entries
@@ -558,6 +583,46 @@
}
/**
+ * Reverse Iterator implementation that switches from the entry array to the overflow entries
+ * appropriately.
+ */
+ private class DescendingEntryIterator implements Iterator<Map.Entry<K, V>> {
+
+ private int pos = entryList.size();
+ private Iterator<Map.Entry<K, V>> lazyOverflowIterator;
+
+ @Override
+ public boolean hasNext() {
+ return (pos > 0 && pos <= entryList.size()) || getOverflowIterator().hasNext();
+ }
+
+ @Override
+ public Map.Entry<K, V> next() {
+ if (getOverflowIterator().hasNext()) {
+ return getOverflowIterator().next();
+ }
+ return entryList.get(--pos);
+ }
+
+ @Override
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * It is important to create the overflow iterator only after the array entries have been
+ * iterated over because the overflow entry set changes when the client calls remove() on the
+ * array entries, which invalidates any existing iterators.
+ */
+ private Iterator<Map.Entry<K, V>> getOverflowIterator() {
+ if (lazyOverflowIterator == null) {
+ lazyOverflowIterator = overflowEntriesDescending.entrySet().iterator();
+ }
+ return lazyOverflowIterator;
+ }
+ }
+
+ /**
* Helper class that holds immutable instances of an Iterable/Iterator that we return when the
* overflow entries is empty. This eliminates the creation of an Iterator object when there is
* nothing to iterate over.
diff --git a/java/core/src/main/java/com/google/protobuf/StructuralMessageInfo.java b/java/core/src/main/java/com/google/protobuf/StructuralMessageInfo.java
new file mode 100755
index 0000000..a32b143
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/StructuralMessageInfo.java
@@ -0,0 +1,167 @@
+// 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
+final class StructuralMessageInfo implements MessageInfo {
+ private final ProtoSyntax syntax;
+ private final boolean messageSetWireFormat;
+ private final int[] checkInitialized;
+ private final FieldInfo[] fields;
+ private final MessageLite defaultInstance;
+
+ /**
+ * Constructor.
+ *
+ * @param checkInitialized fields to check in isInitialized().
+ * @param fields the set of fields for the message, in field number order.
+ */
+ StructuralMessageInfo(
+ ProtoSyntax syntax,
+ boolean messageSetWireFormat,
+ int[] checkInitialized,
+ FieldInfo[] fields,
+ Object defaultInstance) {
+ this.syntax = syntax;
+ this.messageSetWireFormat = messageSetWireFormat;
+ this.checkInitialized = checkInitialized;
+ this.fields = fields;
+ this.defaultInstance = (MessageLite) checkNotNull(defaultInstance, "defaultInstance");
+ }
+
+ /** Gets the syntax for the message (e.g. PROTO2, PROTO3). */
+ @Override
+ public ProtoSyntax getSyntax() {
+ return syntax;
+ }
+
+ /** Indicates whether or not the message should be represented with message set wire format. */
+ @Override
+ public boolean isMessageSetWireFormat() {
+ return messageSetWireFormat;
+ }
+
+ /** An array of field numbers that need to be checked for isInitialized(). */
+ public int[] getCheckInitialized() {
+ return checkInitialized;
+ }
+
+ /**
+ * Gets the information for all fields within this message, sorted in ascending order by their
+ * field number.
+ */
+ public FieldInfo[] getFields() {
+ return fields;
+ }
+
+ @Override
+ public MessageLite getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ /** 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 List<FieldInfo> fields;
+ private ProtoSyntax syntax;
+ private boolean wasBuilt;
+ private boolean messageSetWireFormat;
+ private int[] checkInitialized = null;
+ private Object defaultInstance;
+
+ public Builder() {
+ fields = new ArrayList<FieldInfo>();
+ }
+
+ public Builder(int numFields) {
+ fields = new ArrayList<FieldInfo>(numFields);
+ }
+
+ public void withDefaultInstance(Object defaultInstance) {
+ this.defaultInstance = defaultInstance;
+ }
+
+ public void withSyntax(ProtoSyntax syntax) {
+ this.syntax = checkNotNull(syntax, "syntax");
+ }
+
+ public void withMessageSetWireFormat(boolean messageSetWireFormat) {
+ this.messageSetWireFormat = messageSetWireFormat;
+ }
+
+ public void withCheckInitialized(int[] checkInitialized) {
+ this.checkInitialized = checkInitialized;
+ }
+
+ public void withField(FieldInfo field) {
+ if (wasBuilt) {
+ throw new IllegalStateException("Builder can only build once");
+ }
+ fields.add(field);
+ }
+
+ public StructuralMessageInfo 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 StructuralMessageInfo(
+ syntax,
+ messageSetWireFormat,
+ checkInitialized,
+ fields.toArray(new FieldInfo[0]),
+ defaultInstance);
+ }
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/TextFormat.java b/java/core/src/main/java/com/google/protobuf/TextFormat.java
index f00c812..2326a05 100644
--- a/java/core/src/main/java/com/google/protobuf/TextFormat.java
+++ b/java/core/src/main/java/com/google/protobuf/TextFormat.java
@@ -1247,6 +1247,18 @@
SingularOverwritePolicy.ALLOW_SINGULAR_OVERWRITES;
private TextFormatParseInfoTree.Builder parseInfoTreeBuilder = null;
+ /**
+ * Set whether this parser will allow unknown fields. By default, an exception is thrown if an
+ * unknown field is encountered. If this is set, the parser will only log a warning. Allow
+ * unknown fields will also allow unknown extensions.
+ *
+ * <p>Use of this parameter is discouraged which may hide some errors (e.g.
+ * spelling error on field name).
+ */
+ public Builder setAllowUnknownFields(boolean allowUnknownFields) {
+ this.allowUnknownFields = allowUnknownFields;
+ return this;
+ }
/**
* Set whether this parser will allow unknown extensions. By default, an
@@ -1448,14 +1460,15 @@
extension = target.findExtensionByName(extensionRegistry, name.toString());
if (extension == null) {
- String message = (tokenizer.getPreviousLine() + 1)
- + ":"
- + (tokenizer.getPreviousColumn() + 1)
- + ":\t"
- + type.getFullName()
- + ".["
- + name
- + "]";
+ String message =
+ (tokenizer.getPreviousLine() + 1)
+ + ":"
+ + (tokenizer.getPreviousColumn() + 1)
+ + ":\t"
+ + type.getFullName()
+ + ".["
+ + name
+ + "]";
unknownFields.add(new UnknownField(message, UnknownField.Type.EXTENSION));
} else {
if (extension.descriptor.getContainingType() != type) {
@@ -1653,24 +1666,18 @@
endToken = "}";
}
- Message defaultInstance = (extension == null) ? null : extension.defaultInstance;
- MessageReflection.MergeTarget subField =
- target.newMergeTargetForField(field, defaultInstance);
+ Message defaultInstance = (extension == null) ? null : extension.defaultInstance;
+ MessageReflection.MergeTarget subField =
+ target.newMergeTargetForField(field, defaultInstance);
- while (!tokenizer.tryConsume(endToken)) {
- if (tokenizer.atEnd()) {
- throw tokenizer.parseException("Expected \"" + endToken + "\".");
+ while (!tokenizer.tryConsume(endToken)) {
+ if (tokenizer.atEnd()) {
+ throw tokenizer.parseException("Expected \"" + endToken + "\".");
+ }
+ mergeField(tokenizer, extensionRegistry, subField, parseTreeBuilder, unknownFields);
}
- mergeField(
- tokenizer,
- extensionRegistry,
- subField,
- parseTreeBuilder,
- unknownFields);
- }
- value = subField.finish();
-
+ value = subField.finish();
} else {
switch (field.getType()) {
case INT32:
@@ -1776,6 +1783,7 @@
}
}
+
/** Skips the next field including the field's name and value. */
private void skipField(Tokenizer tokenizer) throws ParseException {
if (tokenizer.tryConsume("[")) {
diff --git a/java/core/src/main/java/com/google/protobuf/UnknownFieldSchema.java b/java/core/src/main/java/com/google/protobuf/UnknownFieldSchema.java
new file mode 100755
index 0000000..e736d5c
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/UnknownFieldSchema.java
@@ -0,0 +1,133 @@
+// 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;
+
+@ExperimentalApi
+abstract class UnknownFieldSchema<T, B> {
+
+ /** Whether unknown fields should be dropped. */
+ abstract boolean shouldDiscardUnknownFields(Reader reader);
+
+ /** Adds a varint value to the unknown fields. */
+ abstract void addVarint(B fields, int number, long value);
+
+ /** Adds a fixed32 value to the unknown fields. */
+ abstract void addFixed32(B fields, int number, int value);
+
+ /** Adds a fixed64 value to the unknown fields. */
+ abstract void addFixed64(B fields, int number, long value);
+
+ /** Adds a length delimited value to the unknown fields. */
+ abstract void addLengthDelimited(B fields, int number, ByteString value);
+
+ /** Adds a group value to the unknown fields. */
+ abstract void addGroup(B fields, int number, T subFieldSet);
+
+ /** Create a new builder for unknown fields. */
+ abstract B newBuilder();
+
+ /** Returns an immutable instance of the field container. */
+ abstract T toImmutable(B fields);
+
+ /**
+ * Sets the unknown fields into the message. Caller must take care of the mutability of the
+ * fields.
+ */
+ abstract void setToMessage(Object message, T fields);
+
+ /** Get the unknown fields from the message. */
+ abstract T getFromMessage(Object message);
+
+ /** Returns a builder for unknown fields in the message. */
+ abstract B getBuilderFromMessage(Object message);
+
+ /** Sets an unknown field builder into the message. */
+ abstract void setBuilderToMessage(Object message, B builder);
+
+ /** Marks unknown fields as immutable. */
+ abstract void makeImmutable(Object message);
+
+ /** Merges one field into the unknown fields. */
+ final boolean mergeOneFieldFrom(B unknownFields, Reader reader) throws IOException {
+ int tag = reader.getTag();
+ int fieldNumber = WireFormat.getTagFieldNumber(tag);
+ switch (WireFormat.getTagWireType(tag)) {
+ case WireFormat.WIRETYPE_VARINT:
+ addVarint(unknownFields, fieldNumber, reader.readInt64());
+ return true;
+ case WireFormat.WIRETYPE_FIXED32:
+ addFixed32(unknownFields, fieldNumber, reader.readFixed32());
+ return true;
+ case WireFormat.WIRETYPE_FIXED64:
+ addFixed64(unknownFields, fieldNumber, reader.readFixed64());
+ return true;
+ case WireFormat.WIRETYPE_LENGTH_DELIMITED:
+ addLengthDelimited(unknownFields, fieldNumber, reader.readBytes());
+ return true;
+ case WireFormat.WIRETYPE_START_GROUP:
+ final B subFields = newBuilder();
+ int endGroupTag = WireFormat.makeTag(fieldNumber, WireFormat.WIRETYPE_END_GROUP);
+ mergeFrom(subFields, reader);
+ if (endGroupTag != reader.getTag()) {
+ throw InvalidProtocolBufferException.invalidEndTag();
+ }
+ addGroup(unknownFields, fieldNumber, toImmutable(subFields));
+ return true;
+ case WireFormat.WIRETYPE_END_GROUP:
+ return false;
+ default:
+ throw InvalidProtocolBufferException.invalidWireType();
+ }
+ }
+
+ final void mergeFrom(B unknownFields, Reader reader) throws IOException {
+ while (true) {
+ if (reader.getFieldNumber() == Reader.READ_DONE
+ || !mergeOneFieldFrom(unknownFields, reader)) {
+ break;
+ }
+ }
+ }
+
+ abstract void writeTo(T unknownFields, Writer writer) throws IOException;
+
+ abstract void writeAsMessageSetTo(T unknownFields, Writer writer) throws IOException;
+
+ /** Merges {@code source} into {@code destination} and returns the merged instance. */
+ abstract T merge(T destination, T source);
+
+ /** Get the serialized size for message set serialization. */
+ abstract int getSerializedSizeAsMessageSet(T message);
+
+ abstract int getSerializedSize(T unknowns);
+}
diff --git a/java/core/src/main/java/com/google/protobuf/UnknownFieldSet.java b/java/core/src/main/java/com/google/protobuf/UnknownFieldSet.java
index 39deec0..bde1303 100644
--- a/java/core/src/main/java/com/google/protobuf/UnknownFieldSet.java
+++ b/java/core/src/main/java/com/google/protobuf/UnknownFieldSet.java
@@ -59,6 +59,7 @@
private UnknownFieldSet() {
fields = null;
+ fieldsDescending = null;
}
/** Create a new {@link Builder}. */
@@ -90,10 +91,14 @@
*/
UnknownFieldSet(final Map<Integer, Field> fields, final Map<Integer, Field> fieldsDescending) {
this.fields = fields;
+ this.fieldsDescending = fieldsDescending;
}
private final Map<Integer, Field> fields;
+ /** A copy of {@link #fields} who's iterator order is reversed. */
+ private final Map<Integer, Field> fieldsDescending;
+
@Override
public boolean equals(final Object other) {
@@ -212,6 +217,35 @@
}
}
+ /** Serializes the set and writes it to {@code writer}. */
+ void writeTo(Writer writer) throws IOException {
+ if (writer.fieldOrder() == Writer.FieldOrder.DESCENDING) {
+ // Write fields in descending order.
+ for (Map.Entry<Integer, Field> entry : fieldsDescending.entrySet()) {
+ entry.getValue().writeTo(entry.getKey(), writer);
+ }
+ } else {
+ // Write fields in ascending order.
+ for (Map.Entry<Integer, Field> entry : fields.entrySet()) {
+ entry.getValue().writeTo(entry.getKey(), writer);
+ }
+ }
+ }
+
+ /** Serializes the set and writes it to {@code writer} using {@code MessageSet} wire format. */
+ void writeAsMessageSetTo(final Writer writer) throws IOException {
+ if (writer.fieldOrder() == Writer.FieldOrder.DESCENDING) {
+ // Write fields in descending order.
+ for (final Map.Entry<Integer, Field> entry : fieldsDescending.entrySet()) {
+ entry.getValue().writeAsMessageSetExtensionTo(entry.getKey(), writer);
+ }
+ } else {
+ // Write fields in ascending order.
+ for (final Map.Entry<Integer, Field> entry : fields.entrySet()) {
+ entry.getValue().writeAsMessageSetExtensionTo(entry.getKey(), writer);
+ }
+ }
+ }
/** Get the number of bytes required to encode this set using {@code MessageSet} wire format. */
public int getSerializedSizeAsMessageSet() {
@@ -328,6 +362,8 @@
result = getDefaultInstance();
} else {
Map<Integer, Field> descendingFields = null;
+ descendingFields =
+ Collections.unmodifiableMap(((TreeMap<Integer, Field>) fields).descendingMap());
result = new UnknownFieldSet(Collections.unmodifiableMap(fields), descendingFields);
}
fields = null;
@@ -344,6 +380,8 @@
public Builder clone() {
getFieldBuilder(0); // Force lastField to be built.
Map<Integer, Field> descendingFields = null;
+ descendingFields =
+ Collections.unmodifiableMap(((TreeMap<Integer, Field>) fields).descendingMap());
return UnknownFieldSet.newBuilder().mergeFrom(new UnknownFieldSet(fields, descendingFields));
}
@@ -808,6 +846,47 @@
}
}
+ /** Serializes the field, including field number, and writes it to {@code writer}. */
+ void writeTo(final int fieldNumber, final Writer writer) throws IOException {
+ writer.writeInt64List(fieldNumber, varint, false);
+ writer.writeFixed32List(fieldNumber, fixed32, false);
+ writer.writeFixed64List(fieldNumber, fixed64, false);
+ writer.writeBytesList(fieldNumber, lengthDelimited);
+
+ if (writer.fieldOrder() == Writer.FieldOrder.ASCENDING) {
+ for (int i = 0; i < group.size(); i++) {
+ writer.writeStartGroup(fieldNumber);
+ group.get(i).writeTo(writer);
+ writer.writeEndGroup(fieldNumber);
+ }
+ } else {
+ for (int i = group.size() - 1; i >= 0; i--) {
+ writer.writeEndGroup(fieldNumber);
+ group.get(i).writeTo(writer);
+ writer.writeStartGroup(fieldNumber);
+ }
+ }
+ }
+
+ /**
+ * Serializes the field, including field number, and writes it to {@code writer}, using {@code
+ * MessageSet} wire format.
+ */
+ private void writeAsMessageSetExtensionTo(final int fieldNumber, final Writer writer)
+ throws IOException {
+ if (writer.fieldOrder() == Writer.FieldOrder.DESCENDING) {
+ // Write in descending field order.
+ ListIterator<ByteString> iter = lengthDelimited.listIterator(lengthDelimited.size());
+ while (iter.hasPrevious()) {
+ writer.writeMessageSetItem(fieldNumber, iter.previous());
+ }
+ } else {
+ // Write in ascending field order.
+ for (final ByteString value : lengthDelimited) {
+ writer.writeMessageSetItem(fieldNumber, value);
+ }
+ }
+ }
/**
* Get the number of bytes required to encode this field, including field number, using {@code
diff --git a/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLite.java b/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLite.java
index 7c5ec6e..2f6315c 100644
--- a/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLite.java
+++ b/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLite.java
@@ -168,6 +168,72 @@
}
}
+ /** Serializes the set and writes it to {@code writer} using {@code MessageSet} wire format. */
+ void writeAsMessageSetTo(Writer writer) throws IOException {
+ if (writer.fieldOrder() == Writer.FieldOrder.DESCENDING) {
+ // Write fields in descending order.
+ for (int i = count - 1; i >= 0; i--) {
+ int fieldNumber = WireFormat.getTagFieldNumber(tags[i]);
+ writer.writeMessageSetItem(fieldNumber, objects[i]);
+ }
+ } else {
+ // Write fields in ascending order.
+ for (int i = 0; i < count; i++) {
+ int fieldNumber = WireFormat.getTagFieldNumber(tags[i]);
+ writer.writeMessageSetItem(fieldNumber, objects[i]);
+ }
+ }
+ }
+
+ /** Serializes the set and writes it to {@code writer}. */
+ public void writeTo(Writer writer) throws IOException {
+ if (count == 0) {
+ return;
+ }
+
+ // TODO: tags are not sorted, so there's no write order guarantees
+ if (writer.fieldOrder() == Writer.FieldOrder.ASCENDING) {
+ for (int i = 0; i < count; ++i) {
+ writeField(tags[i], objects[i], writer);
+ }
+ } else {
+ for (int i = count - 1; i >= 0; --i) {
+ writeField(tags[i], objects[i], writer);
+ }
+ }
+ }
+
+ private static void writeField(int tag, Object object, Writer writer) throws IOException {
+ int fieldNumber = WireFormat.getTagFieldNumber(tag);
+ switch (WireFormat.getTagWireType(tag)) {
+ case WireFormat.WIRETYPE_VARINT:
+ writer.writeInt64(fieldNumber, (Long) object);
+ break;
+ case WireFormat.WIRETYPE_FIXED32:
+ writer.writeFixed32(fieldNumber, (Integer) object);
+ break;
+ case WireFormat.WIRETYPE_FIXED64:
+ writer.writeFixed64(fieldNumber, (Long) object);
+ break;
+ case WireFormat.WIRETYPE_LENGTH_DELIMITED:
+ writer.writeBytes(fieldNumber, (ByteString) object);
+ break;
+ case WireFormat.WIRETYPE_START_GROUP:
+ if (writer.fieldOrder() == Writer.FieldOrder.ASCENDING) {
+ writer.writeStartGroup(fieldNumber);
+ ((UnknownFieldSetLite) object).writeTo(writer);
+ writer.writeEndGroup(fieldNumber);
+ } else {
+ writer.writeEndGroup(fieldNumber);
+ ((UnknownFieldSetLite) object).writeTo(writer);
+ writer.writeStartGroup(fieldNumber);
+ }
+ break;
+ default:
+ // TODO(liujisi): Change writeTo to throw IOException?
+ throw new RuntimeException(InvalidProtocolBufferException.invalidWireType());
+ }
+ }
/**
* Get the number of bytes required to encode this field, including field number, using {@code
diff --git a/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLiteSchema.java b/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLiteSchema.java
new file mode 100755
index 0000000..ffd7232
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLiteSchema.java
@@ -0,0 +1,140 @@
+// 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;
+
+class UnknownFieldSetLiteSchema
+ extends UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite> {
+
+ UnknownFieldSetLiteSchema() {}
+
+ @Override
+ boolean shouldDiscardUnknownFields(Reader reader) {
+ // We never drop unknown fields in lite.
+ return false;
+ }
+
+ @Override
+ UnknownFieldSetLite newBuilder() {
+ return UnknownFieldSetLite.newInstance();
+ }
+
+ @Override
+ void addVarint(UnknownFieldSetLite fields, int number, long value) {
+ fields.storeField(WireFormat.makeTag(number, WireFormat.WIRETYPE_VARINT), value);
+ }
+
+ @Override
+ void addFixed32(UnknownFieldSetLite fields, int number, int value) {
+ fields.storeField(WireFormat.makeTag(number, WireFormat.WIRETYPE_FIXED32), value);
+ }
+
+ @Override
+ void addFixed64(UnknownFieldSetLite fields, int number, long value) {
+ fields.storeField(WireFormat.makeTag(number, WireFormat.WIRETYPE_FIXED64), value);
+ }
+
+ @Override
+ void addLengthDelimited(UnknownFieldSetLite fields, int number, ByteString value) {
+ fields.storeField(WireFormat.makeTag(number, WireFormat.WIRETYPE_LENGTH_DELIMITED), value);
+ }
+
+ @Override
+ void addGroup(UnknownFieldSetLite fields, int number, UnknownFieldSetLite subFieldSet) {
+ fields.storeField(WireFormat.makeTag(number, WireFormat.WIRETYPE_START_GROUP), subFieldSet);
+ }
+
+ @Override
+ UnknownFieldSetLite toImmutable(UnknownFieldSetLite fields) {
+ fields.makeImmutable();
+ return fields;
+ }
+
+ @Override
+ void setToMessage(Object message, UnknownFieldSetLite fields) {
+ ((GeneratedMessageLite<?, ?>) message).unknownFields = fields;
+ }
+
+ @Override
+ UnknownFieldSetLite getFromMessage(Object message) {
+ return ((GeneratedMessageLite<?, ?>) message).unknownFields;
+ }
+
+ @Override
+ UnknownFieldSetLite getBuilderFromMessage(Object message) {
+ UnknownFieldSetLite unknownFields = getFromMessage(message);
+ // When parsing into a lite message object, its UnknownFieldSet is either the default instance
+ // or mutable. It can't be in a state where it's immutable but not default instance.
+ if (unknownFields == UnknownFieldSetLite.getDefaultInstance()) {
+ unknownFields = UnknownFieldSetLite.newInstance();
+ setToMessage(message, unknownFields);
+ }
+ return unknownFields;
+ }
+
+ @Override
+ void setBuilderToMessage(Object message, UnknownFieldSetLite fields) {
+ setToMessage(message, fields);
+ }
+
+ @Override
+ void makeImmutable(Object message) {
+ getFromMessage(message).makeImmutable();
+ }
+
+ @Override
+ void writeTo(UnknownFieldSetLite fields, Writer writer) throws IOException {
+ fields.writeTo(writer);
+ }
+
+ @Override
+ void writeAsMessageSetTo(UnknownFieldSetLite fields, Writer writer) throws IOException {
+ fields.writeAsMessageSetTo(writer);
+ }
+
+ @Override
+ UnknownFieldSetLite merge(UnknownFieldSetLite message, UnknownFieldSetLite other) {
+ return other.equals(UnknownFieldSetLite.getDefaultInstance())
+ ? message
+ : UnknownFieldSetLite.mutableCopyOf(message, other);
+ }
+
+ @Override
+ int getSerializedSize(UnknownFieldSetLite unknowns) {
+ return unknowns.getSerializedSize();
+ }
+
+ @Override
+ int getSerializedSizeAsMessageSet(UnknownFieldSetLite unknowns) {
+ return unknowns.getSerializedSizeAsMessageSet();
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/UnknownFieldSetSchema.java b/java/core/src/main/java/com/google/protobuf/UnknownFieldSetSchema.java
new file mode 100755
index 0000000..b838c4b
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/UnknownFieldSetSchema.java
@@ -0,0 +1,132 @@
+// 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;
+
+class UnknownFieldSetSchema extends UnknownFieldSchema<UnknownFieldSet, UnknownFieldSet.Builder> {
+
+ private final boolean proto3;
+
+ public UnknownFieldSetSchema(boolean proto3) {
+ this.proto3 = proto3;
+ }
+
+ @Override
+ boolean shouldDiscardUnknownFields(Reader reader) {
+ return reader.shouldDiscardUnknownFields();
+ }
+
+ @Override
+ UnknownFieldSet.Builder newBuilder() {
+ return UnknownFieldSet.newBuilder();
+ }
+
+ @Override
+ void addVarint(UnknownFieldSet.Builder fields, int number, long value) {
+ fields.mergeField(number, UnknownFieldSet.Field.newBuilder().addVarint(value).build());
+ }
+
+ @Override
+ void addFixed32(UnknownFieldSet.Builder fields, int number, int value) {
+ fields.mergeField(number, UnknownFieldSet.Field.newBuilder().addFixed32(value).build());
+ }
+
+ @Override
+ void addFixed64(UnknownFieldSet.Builder fields, int number, long value) {
+ fields.mergeField(number, UnknownFieldSet.Field.newBuilder().addFixed64(value).build());
+ }
+
+ @Override
+ void addLengthDelimited(UnknownFieldSet.Builder fields, int number, ByteString value) {
+ fields.mergeField(number, UnknownFieldSet.Field.newBuilder().addLengthDelimited(value).build());
+ }
+
+ @Override
+ void addGroup(UnknownFieldSet.Builder fields, int number, UnknownFieldSet subFieldSet) {
+ fields.mergeField(number, UnknownFieldSet.Field.newBuilder().addGroup(subFieldSet).build());
+ }
+
+ @Override
+ UnknownFieldSet toImmutable(UnknownFieldSet.Builder fields) {
+ return fields.build();
+ }
+
+ @Override
+ void writeTo(UnknownFieldSet message, Writer writer) throws IOException {
+ message.writeTo(writer);
+ }
+
+ @Override
+ void writeAsMessageSetTo(UnknownFieldSet message, Writer writer) throws IOException {
+ message.writeAsMessageSetTo(writer);
+ }
+
+ @Override
+ UnknownFieldSet getFromMessage(Object message) {
+ return ((GeneratedMessageV3) message).unknownFields;
+ }
+
+ @Override
+ void setToMessage(Object message, UnknownFieldSet fields) {
+ ((GeneratedMessageV3) message).unknownFields = fields;
+ }
+
+ @Override
+ UnknownFieldSet.Builder getBuilderFromMessage(Object message) {
+ return ((GeneratedMessageV3) message).unknownFields.toBuilder();
+ }
+
+ @Override
+ void setBuilderToMessage(Object message, UnknownFieldSet.Builder builder) {
+ ((GeneratedMessageV3) message).unknownFields = builder.build();
+ }
+
+ @Override
+ void makeImmutable(Object message) {
+ // Already immutable.
+ }
+
+ @Override
+ UnknownFieldSet merge(UnknownFieldSet message, UnknownFieldSet other) {
+ return message.toBuilder().mergeFrom(other).build();
+ }
+
+ @Override
+ int getSerializedSize(UnknownFieldSet message) {
+ return message.getSerializedSize();
+ }
+
+ @Override
+ int getSerializedSizeAsMessageSet(UnknownFieldSet unknowns) {
+ return unknowns.getSerializedSizeAsMessageSet();
+ }
+}
diff --git a/java/core/src/main/java/com/google/protobuf/Utf8.java b/java/core/src/main/java/com/google/protobuf/Utf8.java
index 9fe1383..104ab09 100644
--- a/java/core/src/main/java/com/google/protobuf/Utf8.java
+++ b/java/core/src/main/java/com/google/protobuf/Utf8.java
@@ -794,7 +794,7 @@
// if it occurs.
try {
// Designed to take advantage of
- // https://wikis.oracle.com/display/HotSpotInternals/RangeCheckElimination
+ // https://wiki.openjdk.java.net/display/HotSpotInternals/RangeCheckElimination
for (char c; inIx < inLength && (c = in.charAt(inIx)) < 0x80; ++inIx) {
out.put(outIx + inIx, (byte) c);
}
@@ -1041,7 +1041,7 @@
int i = 0;
int limit = offset + length;
// Designed to take advantage of
- // https://wikis.oracle.com/display/HotSpotInternals/RangeCheckElimination
+ // https://wiki.openjdk.java.net/display/HotSpotInternals/RangeCheckElimination
for (char c; i < utf16Length && i + j < limit && (c = in.charAt(i)) < 0x80; i++) {
out[j + i] = (byte) c;
}
@@ -1527,7 +1527,7 @@
}
// Designed to take advantage of
- // https://wikis.oracle.com/display/HotSpotInternals/RangeCheckElimination
+ // https://wiki.openjdk.java.net/display/HotSpotInternals/RangeCheckElimination
int inIx = 0;
for (char c; inIx < inLimit && (c = in.charAt(inIx)) < 0x80; ++inIx) {
UnsafeUtil.putByte(out, outIx++, (byte) c);
@@ -1589,7 +1589,7 @@
}
// Designed to take advantage of
- // https://wikis.oracle.com/display/HotSpotInternals/RangeCheckElimination
+ // https://wiki.openjdk.java.net/display/HotSpotInternals/RangeCheckElimination
int inIx = 0;
for (char c; inIx < inLimit && (c = in.charAt(inIx)) < 0x80; ++inIx) {
UnsafeUtil.putByte(outIx++, (byte) c);
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 100755
index 0000000..3f95c32
--- /dev/null
+++ b/java/core/src/main/java/com/google/protobuf/Writer.java
@@ -0,0 +1,219 @@
+// 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;
+import java.util.Map;
+
+/** A writer that performs serialization of protobuf message fields. */
+@ExperimentalApi
+interface Writer {
+
+ /** The order in which the fields are written by a {@link Writer}. */
+ enum FieldOrder {
+ /** Fields are written in ascending order by field number. */
+ ASCENDING,
+
+ /** Fields are written in descending order by field number. */
+ DESCENDING
+ }
+
+ /** Indicates the order in which the fields are written by this {@link Writer}. */
+ FieldOrder fieldOrder();
+
+ /** Writes a field of type {@link FieldType#SFIXED32}. */
+ void writeSFixed32(int fieldNumber, int value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#INT64}. */
+ void writeInt64(int fieldNumber, long value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#SFIXED64}. */
+ void writeSFixed64(int fieldNumber, long value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#FLOAT}. */
+ void writeFloat(int fieldNumber, float value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#DOUBLE}. */
+ void writeDouble(int fieldNumber, double value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#ENUM}. */
+ void writeEnum(int fieldNumber, int value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#UINT64}. */
+ void writeUInt64(int fieldNumber, long value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#INT32}. */
+ void writeInt32(int fieldNumber, int value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#FIXED64}. */
+ void writeFixed64(int fieldNumber, long value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#FIXED32}. */
+ void writeFixed32(int fieldNumber, int value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#BOOL}. */
+ void writeBool(int fieldNumber, boolean value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#STRING}. */
+ void writeString(int fieldNumber, String value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#BYTES}. */
+ void writeBytes(int fieldNumber, ByteString value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#UINT32}. */
+ void writeUInt32(int fieldNumber, int value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#SINT32}. */
+ void writeSInt32(int fieldNumber, int value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#SINT64}. */
+ void writeSInt64(int fieldNumber, long value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#MESSAGE}. */
+ void writeMessage(int fieldNumber, Object value) throws IOException;
+
+ /** Writes a field of type {@link FieldType#MESSAGE}. */
+ void writeMessage(int fieldNumber, Object value, Schema schema) throws IOException;
+
+ /**
+ * Writes a field of type {@link FieldType#GROUP}.
+ *
+ * @deprecated groups fields are deprecated.
+ */
+ @Deprecated
+ void writeGroup(int fieldNumber, Object value) throws IOException;
+
+ /**
+ * Writes a field of type {@link FieldType#GROUP}.
+ *
+ * @deprecated groups fields are deprecated.
+ */
+ @Deprecated
+ void writeGroup(int fieldNumber, Object value, Schema schema) throws IOException;
+
+ /**
+ * Writes a single start group tag.
+ *
+ * @deprecated groups fields are deprecated.
+ */
+ @Deprecated
+ void writeStartGroup(int fieldNumber) throws IOException;
+
+ /**
+ * Writes a single end group tag.
+ *
+ * @deprecated groups fields are deprecated.
+ */
+ @Deprecated
+ void writeEndGroup(int fieldNumber) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#INT32}. */
+ void writeInt32List(int fieldNumber, List<Integer> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#FIXED32}. */
+ void writeFixed32List(int fieldNumber, List<Integer> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#INT64}. */
+ void writeInt64List(int fieldNumber, List<Long> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#UINT64}. */
+ void writeUInt64List(int fieldNumber, List<Long> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#FIXED64}. */
+ void writeFixed64List(int fieldNumber, List<Long> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#FLOAT}. */
+ void writeFloatList(int fieldNumber, List<Float> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#DOUBLE}. */
+ void writeDoubleList(int fieldNumber, List<Double> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#ENUM}. */
+ void writeEnumList(int fieldNumber, List<Integer> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#BOOL}. */
+ void writeBoolList(int fieldNumber, List<Boolean> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#STRING}. */
+ void writeStringList(int fieldNumber, List<String> value) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#BYTES}. */
+ void writeBytesList(int fieldNumber, List<ByteString> value) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#UINT32}. */
+ void writeUInt32List(int fieldNumber, List<Integer> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#SFIXED32}. */
+ void writeSFixed32List(int fieldNumber, List<Integer> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#SFIXED64}. */
+ void writeSFixed64List(int fieldNumber, List<Long> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#SINT32}. */
+ void writeSInt32List(int fieldNumber, List<Integer> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#SINT64}. */
+ void writeSInt64List(int fieldNumber, List<Long> value, boolean packed) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#MESSAGE}. */
+ void writeMessageList(int fieldNumber, List<?> value) throws IOException;
+
+ /** Writes a list field of type {@link FieldType#MESSAGE}. */
+ void writeMessageList(int fieldNumber, List<?> value, Schema schema) throws IOException;
+
+ /**
+ * Writes a list field of type {@link FieldType#GROUP}.
+ *
+ * @deprecated groups fields are deprecated.
+ */
+ @Deprecated
+ void writeGroupList(int fieldNumber, List<?> value) throws IOException;
+
+ /**
+ * Writes a list field of type {@link FieldType#GROUP}.
+ *
+ * @deprecated groups fields are deprecated.
+ */
+ @Deprecated
+ void writeGroupList(int fieldNumber, List<?> value, Schema schema) throws IOException;
+
+ /**
+ * Writes a message field in {@code MessageSet} wire-format.
+ *
+ * @param value A message instance or an opaque {@link ByteString} for an unknown field.
+ */
+ void writeMessageSetItem(int fieldNumber, Object value) throws IOException;
+
+ /** Writes a map field. */
+ <K, V> void writeMap(int fieldNumber, MapEntryLite.Metadata<K, V> metadata, Map<K, V> map)
+ throws IOException;
+}
diff --git a/java/core/src/test/java/com/google/protobuf/AbstractProto2LiteSchemaTest.java b/java/core/src/test/java/com/google/protobuf/AbstractProto2LiteSchemaTest.java
new file mode 100755
index 0000000..5d3fd3b
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/AbstractProto2LiteSchemaTest.java
@@ -0,0 +1,199 @@
+// 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 org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+
+import com.google.protobuf.testing.Proto2TestingLite.Proto2EmptyLite;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLite;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLite.TestEnum;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLiteWithMaps;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.List;
+import org.junit.Test;
+
+/** Base class for tests using {@link Proto2MessageLite}. */
+public abstract class AbstractProto2LiteSchemaTest extends AbstractSchemaTest<Proto2MessageLite> {
+
+ @Override
+ protected Proto2MessageLiteFactory messageFactory() {
+ return new Proto2MessageLiteFactory(10, 20, 2, 2);
+ }
+
+ @Test
+ public void mergeOptionalMessageFields() throws Exception {
+ Proto2MessageLite message1 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().setFieldInt643(123).clearFieldInt325().build())
+ .build();
+ Proto2MessageLite message2 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().clearFieldInt643().setFieldInt325(456).build())
+ .build();
+ Proto2MessageLite message3 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().setFieldInt643(789).clearFieldInt325().build())
+ .build();
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ message1.writeTo(output);
+ message2.writeTo(output);
+ message3.writeTo(output);
+ byte[] data = output.toByteArray();
+
+ Proto2MessageLite merged =
+ ExperimentalSerializationUtil.fromByteArray(data, Proto2MessageLite.class);
+ assertEquals(789, merged.getFieldMessage10().getFieldInt643());
+ assertEquals(456, merged.getFieldMessage10().getFieldInt325());
+ }
+
+ @Test
+ public void oneofFieldsShouldRoundtrip() throws IOException {
+ roundtrip("Field 53", newBuilder().setFieldDouble53(100).build());
+ roundtrip("Field 54", newBuilder().setFieldFloat54(100).build());
+ roundtrip("Field 55", newBuilder().setFieldInt6455(100).build());
+ roundtrip("Field 56", newBuilder().setFieldUint6456(100L).build());
+ roundtrip("Field 57", newBuilder().setFieldInt3257(100).build());
+ roundtrip("Field 58", newBuilder().setFieldFixed6458(100).build());
+ roundtrip("Field 59", newBuilder().setFieldFixed3259(100).build());
+ roundtrip("Field 60", newBuilder().setFieldBool60(true).build());
+ roundtrip("Field 61", newBuilder().setFieldString61(data().getString()).build());
+ roundtrip(
+ "Field 62", newBuilder().setFieldMessage62(newBuilder().setFieldDouble1(100)).build());
+ roundtrip("Field 63", newBuilder().setFieldBytes63(data().getBytes()).build());
+ roundtrip("Field 64", newBuilder().setFieldUint3264(100).build());
+ roundtrip("Field 65", newBuilder().setFieldSfixed3265(100).build());
+ roundtrip("Field 66", newBuilder().setFieldSfixed6466(100).build());
+ roundtrip("Field 67", newBuilder().setFieldSint3267(100).build());
+ roundtrip("Field 68", newBuilder().setFieldSint6468(100).build());
+ roundtrip(
+ "Field 69",
+ newBuilder()
+ .setFieldGroup69(
+ Proto2MessageLite.FieldGroup69.newBuilder().setFieldInt3270(data().getInt()))
+ .build());
+ }
+
+ private Proto2MessageLite.Builder newBuilder() {
+ return messageFactory().newMessage().toBuilder();
+ }
+
+ @Override
+ protected List<Proto2MessageLite> newMessagesMissingRequiredFields() {
+ return messageFactory().newMessagesMissingRequiredFields();
+ }
+
+ @Test
+ public void mapsShouldRoundtrip() throws IOException {
+ roundtrip(
+ "Proto2MessageLiteWithMaps",
+ new Proto2MessageLiteFactory(2, 10, 2, 2).newMessageWithMaps(),
+ Protobuf.getInstance().schemaFor(Proto2MessageLiteWithMaps.class));
+ }
+
+ @Test
+ public void unknownFieldsUnrecognized() throws Exception {
+ Proto2MessageLite expectedMessage = messageFactory().newMessage();
+ byte[] serializedBytes = expectedMessage.toByteArray();
+ Proto2EmptyLite empty =
+ ExperimentalSerializationUtil.fromByteArray(serializedBytes, Proto2EmptyLite.class);
+
+ // Merge serialized bytes into an empty message, then reserialize and merge it to a new
+ // Proto2Message. Make sure the two messages equal.
+ byte[] roundtripBytes = ExperimentalSerializationUtil.toByteArray(empty);
+ Proto2MessageLite roundtripMessage =
+ ExperimentalSerializationUtil.fromByteArray(roundtripBytes, Proto2MessageLite.class);
+ assertEquals(expectedMessage, roundtripMessage);
+ }
+
+ @Test
+ public void unknownEnum() throws IOException {
+ // Use unknown fields to hold invalid enum values.
+ UnknownFieldSetLite unknowns = UnknownFieldSetLite.newInstance();
+ final int outOfRange = 1000;
+ assertNull(TestEnum.forNumber(outOfRange));
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2MessageLite.FIELD_ENUM_13_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) outOfRange);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2MessageLite.FIELD_ENUM_LIST_30_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) TestEnum.ONE_VALUE);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2MessageLite.FIELD_ENUM_LIST_30_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) outOfRange);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2MessageLite.FIELD_ENUM_LIST_30_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) TestEnum.TWO_VALUE);
+
+ {
+ // Construct a packed enum list.
+ int packedSize =
+ CodedOutputStream.computeUInt32SizeNoTag(TestEnum.ONE_VALUE)
+ + CodedOutputStream.computeUInt32SizeNoTag(outOfRange)
+ + CodedOutputStream.computeUInt32SizeNoTag(TestEnum.ONE_VALUE);
+ ByteString.CodedBuilder packedBuilder = ByteString.newCodedBuilder(packedSize);
+ CodedOutputStream packedOut = packedBuilder.getCodedOutput();
+ packedOut.writeEnumNoTag(TestEnum.ONE_VALUE);
+ packedOut.writeEnumNoTag(outOfRange);
+ packedOut.writeEnumNoTag(TestEnum.TWO_VALUE);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2MessageLite.FIELD_ENUM_LIST_PACKED_44_FIELD_NUMBER,
+ WireFormat.WIRETYPE_LENGTH_DELIMITED),
+ packedBuilder.build());
+ }
+ int size = unknowns.getSerializedSize();
+ byte[] output = new byte[size];
+ CodedOutputStream codedOutput = CodedOutputStream.newInstance(output);
+ unknowns.writeTo(codedOutput);
+ codedOutput.flush();
+
+ Proto2MessageLite parsed =
+ ExperimentalSerializationUtil.fromByteArray(output, Proto2MessageLite.class);
+ assertFalse("out-of-range singular enum should not be in message", parsed.hasFieldEnum13());
+ assertEquals(
+ "out-of-range repeated enum should not be in message", 2, parsed.getFieldEnumList30Count());
+ assertEquals(TestEnum.ONE, parsed.getFieldEnumList30(0));
+ assertEquals(TestEnum.TWO, parsed.getFieldEnumList30(1));
+ assertEquals(
+ "out-of-range packed repeated enum should not be in message",
+ 2,
+ parsed.getFieldEnumListPacked44Count());
+ assertEquals(TestEnum.ONE, parsed.getFieldEnumListPacked44(0));
+ assertEquals(TestEnum.TWO, parsed.getFieldEnumListPacked44(1));
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/AbstractProto2SchemaTest.java b/java/core/src/test/java/com/google/protobuf/AbstractProto2SchemaTest.java
new file mode 100755
index 0000000..0c16818
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/AbstractProto2SchemaTest.java
@@ -0,0 +1,224 @@
+// 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 org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+
+import com.google.protobuf.testing.Proto2Testing.Proto2Empty;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message.TestEnum;
+import com.google.protobuf.testing.Proto2Testing.Proto2MessageWithMaps;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.List;
+import org.junit.Test;
+
+/** Base class for tests using {@link Proto2Message}. */
+public abstract class AbstractProto2SchemaTest extends AbstractSchemaTest<Proto2Message> {
+
+ @Override
+ protected Proto2MessageFactory messageFactory() {
+ return new Proto2MessageFactory(10, 20, 2, 2);
+ }
+
+ @Test
+ public void mergeOptionalMessageFields() throws Exception {
+ Proto2Message message1 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().setFieldInt643(123).clearFieldInt325().build())
+ .build();
+ Proto2Message message2 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().clearFieldInt643().setFieldInt325(456).build())
+ .build();
+ Proto2Message message3 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().setFieldInt643(789).clearFieldInt325().build())
+ .build();
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ message1.writeTo(output);
+ message2.writeTo(output);
+ message3.writeTo(output);
+ byte[] data = output.toByteArray();
+
+ Proto2Message merged = ExperimentalSerializationUtil.fromByteArray(data, Proto2Message.class);
+ assertEquals(789, merged.getFieldMessage10().getFieldInt643());
+ assertEquals(456, merged.getFieldMessage10().getFieldInt325());
+ }
+
+ @Test
+ public void oneofFieldsShouldRoundtrip() throws IOException {
+ roundtrip("Field 53", newBuilder().setFieldDouble53(100).build());
+ roundtrip("Field 54", newBuilder().setFieldFloat54(100).build());
+ roundtrip("Field 55", newBuilder().setFieldInt6455(100).build());
+ roundtrip("Field 56", newBuilder().setFieldUint6456(100L).build());
+ roundtrip("Field 57", newBuilder().setFieldInt3257(100).build());
+ roundtrip("Field 58", newBuilder().setFieldFixed6458(100).build());
+ roundtrip("Field 59", newBuilder().setFieldFixed3259(100).build());
+ roundtrip("Field 60", newBuilder().setFieldBool60(true).build());
+ roundtrip("Field 61", newBuilder().setFieldString61(data().getString()).build());
+ roundtrip(
+ "Field 62", newBuilder().setFieldMessage62(newBuilder().setFieldDouble1(100)).build());
+ roundtrip("Field 63", newBuilder().setFieldBytes63(data().getBytes()).build());
+ roundtrip("Field 64", newBuilder().setFieldUint3264(100).build());
+ roundtrip("Field 65", newBuilder().setFieldSfixed3265(100).build());
+ roundtrip("Field 66", newBuilder().setFieldSfixed6466(100).build());
+ roundtrip("Field 67", newBuilder().setFieldSint3267(100).build());
+ roundtrip("Field 68", newBuilder().setFieldSint6468(100).build());
+ roundtrip(
+ "Field 69",
+ newBuilder()
+ .setFieldGroup69(
+ Proto2Message.FieldGroup69.newBuilder().setFieldInt3270(data().getInt()))
+ .build());
+ }
+
+ private Proto2Message.Builder newBuilder() {
+ return messageFactory().newMessage().toBuilder();
+ }
+
+ @Test
+ public void mapsShouldRoundtrip() throws IOException {
+ roundtrip(
+ "Proto2MessageWithMaps",
+ new Proto2MessageFactory(2, 10, 2, 2).newMessageWithMaps(),
+ Protobuf.getInstance().schemaFor(Proto2MessageWithMaps.class));
+ }
+
+ @Test
+ public void unknownFieldsUnrecognized() throws Exception {
+ Proto2Message expectedMessage = messageFactory().newMessage();
+ byte[] serializedBytes = expectedMessage.toByteArray();
+ Proto2Empty empty =
+ ExperimentalSerializationUtil.fromByteArray(serializedBytes, Proto2Empty.class);
+
+ // Merge serialized bytes into an empty message, then reserialize and merge it to a new
+ // Proto2Message. Make sure the two messages equal.
+ byte[] roundtripBytes = ExperimentalSerializationUtil.toByteArray(empty);
+ assertEquals(serializedBytes.length, roundtripBytes.length);
+ Proto2Message roundtripMessage =
+ ExperimentalSerializationUtil.fromByteArray(roundtripBytes, Proto2Message.class);
+ assertEquals(expectedMessage, roundtripMessage);
+ }
+
+ @Test
+ public void unknownEnum() throws IOException {
+ // Use unknown fields to hold invalid enum values.
+ UnknownFieldSetLite unknowns = UnknownFieldSetLite.newInstance();
+ final int outOfRange = 1000;
+ assertNull(TestEnum.forNumber(outOfRange));
+ unknowns.storeField(
+ WireFormat.makeTag(Proto2Message.FIELD_ENUM_13_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) outOfRange);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2Message.FIELD_ENUM_LIST_30_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) TestEnum.ONE_VALUE);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2Message.FIELD_ENUM_LIST_30_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) outOfRange);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2Message.FIELD_ENUM_LIST_30_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) TestEnum.TWO_VALUE);
+
+ {
+ // Construct a packed enum list.
+ int packedSize =
+ CodedOutputStream.computeUInt32SizeNoTag(TestEnum.ONE_VALUE)
+ + CodedOutputStream.computeUInt32SizeNoTag(outOfRange)
+ + CodedOutputStream.computeUInt32SizeNoTag(TestEnum.ONE_VALUE);
+ ByteString.CodedBuilder packedBuilder = ByteString.newCodedBuilder(packedSize);
+ CodedOutputStream packedOut = packedBuilder.getCodedOutput();
+ packedOut.writeEnumNoTag(TestEnum.ONE_VALUE);
+ packedOut.writeEnumNoTag(outOfRange);
+ packedOut.writeEnumNoTag(TestEnum.TWO_VALUE);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2Message.FIELD_ENUM_LIST_PACKED_44_FIELD_NUMBER,
+ WireFormat.WIRETYPE_LENGTH_DELIMITED),
+ packedBuilder.build());
+ }
+ int size = unknowns.getSerializedSize();
+ byte[] output = new byte[size];
+ CodedOutputStream codedOutput = CodedOutputStream.newInstance(output);
+ unknowns.writeTo(codedOutput);
+ codedOutput.flush();
+
+ Proto2Message parsed = ExperimentalSerializationUtil.fromByteArray(output, Proto2Message.class);
+ assertFalse("out-of-range singular enum should not be in message", parsed.hasFieldEnum13());
+ {
+ List<Long> singularEnum =
+ parsed
+ .getUnknownFields()
+ .getField(Proto2Message.FIELD_ENUM_13_FIELD_NUMBER)
+ .getVarintList();
+ assertEquals(1, singularEnum.size());
+ assertEquals((Long) (long) outOfRange, singularEnum.get(0));
+ }
+ {
+ List<Long> repeatedEnum =
+ parsed
+ .getUnknownFields()
+ .getField(Proto2Message.FIELD_ENUM_LIST_30_FIELD_NUMBER)
+ .getVarintList();
+ assertEquals(1, repeatedEnum.size());
+ assertEquals((Long) (long) outOfRange, repeatedEnum.get(0));
+ }
+ {
+ List<Long> packedRepeatedEnum =
+ parsed
+ .getUnknownFields()
+ .getField(Proto2Message.FIELD_ENUM_LIST_PACKED_44_FIELD_NUMBER)
+ .getVarintList();
+ assertEquals(1, packedRepeatedEnum.size());
+ assertEquals((Long) (long) outOfRange, packedRepeatedEnum.get(0));
+ }
+ assertEquals(
+ "out-of-range repeated enum should not be in message", 2, parsed.getFieldEnumList30Count());
+ assertEquals(TestEnum.ONE, parsed.getFieldEnumList30(0));
+ assertEquals(TestEnum.TWO, parsed.getFieldEnumList30(1));
+ assertEquals(
+ "out-of-range packed repeated enum should not be in message",
+ 2,
+ parsed.getFieldEnumListPacked44Count());
+ assertEquals(TestEnum.ONE, parsed.getFieldEnumListPacked44(0));
+ assertEquals(TestEnum.TWO, parsed.getFieldEnumListPacked44(1));
+ }
+
+ @Override
+ protected List<Proto2Message> newMessagesMissingRequiredFields() {
+ return messageFactory().newMessagesMissingRequiredFields();
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/AbstractProto3LiteSchemaTest.java b/java/core/src/test/java/com/google/protobuf/AbstractProto3LiteSchemaTest.java
new file mode 100755
index 0000000..9cc04ec
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/AbstractProto3LiteSchemaTest.java
@@ -0,0 +1,143 @@
+// 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 org.junit.Assert.assertEquals;
+
+import com.google.protobuf.testing.Proto3TestingLite.Proto3EmptyLite;
+import com.google.protobuf.testing.Proto3TestingLite.Proto3MessageLite;
+import com.google.protobuf.testing.Proto3TestingLite.Proto3MessageLiteWithMaps;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/** Base class for tests using {@link Proto3MessageLite}. */
+public abstract class AbstractProto3LiteSchemaTest extends AbstractSchemaTest<Proto3MessageLite> {
+ @Override
+ protected Proto3MessageLiteFactory messageFactory() {
+ return new Proto3MessageLiteFactory(10, 20, 2, 2);
+ }
+
+ @Override
+ protected List<ByteBuffer> serializedBytesWithInvalidUtf8() throws IOException {
+ List<ByteBuffer> invalidBytes = new ArrayList<>();
+ byte[] invalid = new byte[] {(byte) 0x80};
+ {
+ ByteBuffer buffer = ByteBuffer.allocate(100);
+ CodedOutputStream codedOutput = CodedOutputStream.newInstance(buffer);
+ codedOutput.writeByteArray(Proto3MessageLite.FIELD_STRING_9_FIELD_NUMBER, invalid);
+ codedOutput.flush();
+ buffer.flip();
+ invalidBytes.add(buffer);
+ }
+ {
+ ByteBuffer buffer = ByteBuffer.allocate(100);
+ CodedOutputStream codedOutput = CodedOutputStream.newInstance(buffer);
+ codedOutput.writeByteArray(Proto3MessageLite.FIELD_STRING_LIST_26_FIELD_NUMBER, invalid);
+ codedOutput.flush();
+ buffer.flip();
+ invalidBytes.add(buffer);
+ }
+ return invalidBytes;
+ }
+
+ @Test
+ public void mergeOptionalMessageFields() throws Exception {
+ Proto3MessageLite message1 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().setFieldInt643(123).clearFieldInt325().build())
+ .build();
+ Proto3MessageLite message2 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().clearFieldInt643().setFieldInt325(456).build())
+ .build();
+ Proto3MessageLite message3 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().setFieldInt643(789).clearFieldInt325().build())
+ .build();
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ message1.writeTo(output);
+ message2.writeTo(output);
+ message3.writeTo(output);
+ byte[] data = output.toByteArray();
+
+ Proto3MessageLite merged =
+ ExperimentalSerializationUtil.fromByteArray(data, Proto3MessageLite.class);
+ assertEquals(789, merged.getFieldMessage10().getFieldInt643());
+ assertEquals(456, merged.getFieldMessage10().getFieldInt325());
+ }
+
+ @Test
+ public void oneofFieldsShouldRoundtrip() throws IOException {
+ roundtrip("Field 53", newBuilder().setFieldDouble53(100).build());
+ roundtrip("Field 54", newBuilder().setFieldFloat54(100).build());
+ roundtrip("Field 55", newBuilder().setFieldInt6455(100).build());
+ roundtrip("Field 56", newBuilder().setFieldUint6456(100L).build());
+ roundtrip("Field 57", newBuilder().setFieldInt3257(100).build());
+ roundtrip("Field 58", newBuilder().setFieldFixed6458(100).build());
+ roundtrip("Field 59", newBuilder().setFieldFixed3259(100).build());
+ roundtrip("Field 60", newBuilder().setFieldBool60(true).build());
+ roundtrip("Field 61", newBuilder().setFieldString61(data().getString()).build());
+ roundtrip(
+ "Field 62", newBuilder().setFieldMessage62(newBuilder().setFieldDouble1(100)).build());
+ roundtrip("Field 63", newBuilder().setFieldBytes63(data().getBytes()).build());
+ roundtrip("Field 64", newBuilder().setFieldUint3264(100).build());
+ roundtrip("Field 65", newBuilder().setFieldSfixed3265(100).build());
+ roundtrip("Field 66", newBuilder().setFieldSfixed6466(100).build());
+ roundtrip("Field 67", newBuilder().setFieldSint3267(100).build());
+ roundtrip("Field 68", newBuilder().setFieldSint6468(100).build());
+ }
+
+ @Test
+ public void retainUnknownFields() {
+ // Unknown fields are retained in lite runtime.
+ Proto3MessageLite expectedMessage = messageFactory().newMessage();
+ Proto3EmptyLite empty =
+ ExperimentalSerializationUtil.fromByteArray(
+ expectedMessage.toByteArray(), Proto3EmptyLite.class);
+ assertEquals(expectedMessage.getSerializedSize(), empty.getSerializedSize());
+ }
+
+ @Test
+ public void mapsShouldRoundtrip() throws IOException {
+ roundtrip(
+ "Proto3MessageLiteWithMaps",
+ new Proto3MessageLiteFactory(2, 10, 2, 2).newMessageWithMaps(),
+ Protobuf.getInstance().schemaFor(Proto3MessageLiteWithMaps.class));
+ }
+
+ private static Proto3MessageLite.Builder newBuilder() {
+ return Proto3MessageLite.newBuilder();
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/AbstractProto3SchemaTest.java b/java/core/src/test/java/com/google/protobuf/AbstractProto3SchemaTest.java
new file mode 100755
index 0000000..358f1e3
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/AbstractProto3SchemaTest.java
@@ -0,0 +1,151 @@
+// 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 org.junit.Assert.assertEquals;
+
+import com.google.protobuf.testing.Proto3Testing.Proto3Empty;
+import com.google.protobuf.testing.Proto3Testing.Proto3Message;
+import com.google.protobuf.testing.Proto3Testing.Proto3MessageWithMaps;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/** Base class for tests using {@link Proto3Message}. */
+public abstract class AbstractProto3SchemaTest extends AbstractSchemaTest<Proto3Message> {
+ @Override
+ protected Proto3MessageFactory messageFactory() {
+ return new Proto3MessageFactory(10, 20, 2, 2);
+ }
+
+ @Override
+ protected List<ByteBuffer> serializedBytesWithInvalidUtf8() throws IOException {
+ List<ByteBuffer> invalidBytes = new ArrayList<>();
+ byte[] invalid = new byte[] {(byte) 0x80};
+ {
+ ByteBuffer buffer = ByteBuffer.allocate(100);
+ CodedOutputStream codedOutput = CodedOutputStream.newInstance(buffer);
+ codedOutput.writeByteArray(Proto3Message.FIELD_STRING_9_FIELD_NUMBER, invalid);
+ codedOutput.flush();
+ buffer.flip();
+ invalidBytes.add(buffer);
+ }
+ {
+ ByteBuffer buffer = ByteBuffer.allocate(100);
+ CodedOutputStream codedOutput = CodedOutputStream.newInstance(buffer);
+ codedOutput.writeByteArray(Proto3Message.FIELD_STRING_LIST_26_FIELD_NUMBER, invalid);
+ codedOutput.flush();
+ buffer.flip();
+ invalidBytes.add(buffer);
+ }
+ return invalidBytes;
+ }
+
+ @Test
+ public void mergeOptionalMessageFields() throws Exception {
+ Proto3Message message1 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().setFieldInt643(123).clearFieldInt325().build())
+ .build();
+ Proto3Message message2 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().clearFieldInt643().setFieldInt325(456).build())
+ .build();
+ Proto3Message message3 =
+ newBuilder()
+ .setFieldMessage10(newBuilder().setFieldInt643(789).clearFieldInt325().build())
+ .build();
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ message1.writeTo(output);
+ message2.writeTo(output);
+ message3.writeTo(output);
+ byte[] data = output.toByteArray();
+
+ Proto3Message merged = ExperimentalSerializationUtil.fromByteArray(data, Proto3Message.class);
+ assertEquals(789, merged.getFieldMessage10().getFieldInt643());
+ assertEquals(456, merged.getFieldMessage10().getFieldInt325());
+ }
+
+ @Test
+ public void oneofFieldsShouldRoundtrip() throws IOException {
+ roundtrip("Field 53", newBuilder().setFieldDouble53(100).build());
+ roundtrip("Field 54", newBuilder().setFieldFloat54(100).build());
+ roundtrip("Field 55", newBuilder().setFieldInt6455(100).build());
+ roundtrip("Field 56", newBuilder().setFieldUint6456(100L).build());
+ roundtrip("Field 57", newBuilder().setFieldInt3257(100).build());
+ roundtrip("Field 58", newBuilder().setFieldFixed6458(100).build());
+ roundtrip("Field 59", newBuilder().setFieldFixed3259(100).build());
+ roundtrip("Field 60", newBuilder().setFieldBool60(true).build());
+ roundtrip("Field 61", newBuilder().setFieldString61(data().getString()).build());
+ roundtrip(
+ "Field 62", newBuilder().setFieldMessage62(newBuilder().setFieldDouble1(100)).build());
+ roundtrip("Field 63", newBuilder().setFieldBytes63(data().getBytes()).build());
+ roundtrip("Field 64", newBuilder().setFieldUint3264(100).build());
+ roundtrip("Field 65", newBuilder().setFieldSfixed3265(100).build());
+ roundtrip("Field 66", newBuilder().setFieldSfixed6466(100).build());
+ roundtrip("Field 67", newBuilder().setFieldSint3267(100).build());
+ roundtrip("Field 68", newBuilder().setFieldSint6468(100).build());
+ }
+
+ @Test
+ public void preserveUnknownFields() {
+ Proto3Message expectedMessage = messageFactory().newMessage();
+ Proto3Empty empty =
+ ExperimentalSerializationUtil.fromByteArray(
+ expectedMessage.toByteArray(), Proto3Empty.class);
+ assertEquals(expectedMessage.getSerializedSize(), empty.getSerializedSize());
+ assertEquals(expectedMessage.toByteString(), empty.toByteString());
+ }
+
+ @Test
+ public void preserveUnknownFieldsProto2() {
+ // Make sure we will be able to preserve valid proto2 wireformat, including those that are not
+ // supported in proto3, e.g. groups.
+ byte[] payload = new Proto2MessageFactory(10, 20, 2, 2).newMessage().toByteArray();
+ Proto3Empty empty = ExperimentalSerializationUtil.fromByteArray(payload, Proto3Empty.class);
+ assertEquals(payload.length, empty.getSerializedSize());
+ }
+
+ @Test
+ public void mapsShouldRoundtrip() throws IOException {
+ roundtrip(
+ "Proto3MessageWithMaps",
+ new Proto3MessageFactory(2, 10, 2, 2).newMessageWithMaps(),
+ Protobuf.getInstance().schemaFor(Proto3MessageWithMaps.class));
+ }
+
+ private static Proto3Message.Builder newBuilder() {
+ return Proto3Message.newBuilder();
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/AbstractSchemaTest.java b/java/core/src/test/java/com/google/protobuf/AbstractSchemaTest.java
new file mode 100755
index 0000000..c69a4fd
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/AbstractSchemaTest.java
@@ -0,0 +1,157 @@
+// 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 org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+
+public abstract class AbstractSchemaTest<T extends MessageLite> {
+ private Schema<T> schema;
+
+ @Before
+ public void setup() {
+ schema = schema();
+ registerSchemas();
+ }
+
+ // Subclass should override this method if it needs to register more than one schemas.
+ protected void registerSchemas() {
+ // Register this schema with the runtime to support processing of nested messages.
+ Protobuf.getInstance().registerSchemaOverride(schema.newInstance().getClass(), schema);
+ }
+
+ protected abstract Schema<T> schema();
+
+ protected abstract ExperimentalMessageFactory<? extends T> messageFactory();
+
+ @SuppressWarnings("unused")
+ protected List<ByteBuffer> serializedBytesWithInvalidUtf8() throws IOException {
+ return Collections.emptyList();
+ }
+
+ @Test
+ public void randomMessageShouldRoundtrip() throws IOException {
+ roundtrip("", messageFactory().newMessage());
+ }
+
+ @Test
+ public void invalidUtf8StringParsing() throws IOException {
+ for (ByteBuffer invalidUtf8Bytes : serializedBytesWithInvalidUtf8()) {
+ Reader reader = BinaryReader.newInstance(invalidUtf8Bytes, /* bufferIsImmutable= */ true);
+
+ T newMsg = schema.newInstance();
+ try {
+ schema.mergeFrom(newMsg, reader, ExtensionRegistryLite.getEmptyRegistry());
+ fail("should throw invalid ");
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+ }
+
+ @Test
+ public void mergeFromByteArrayFastPathMayThrowIndexOutOfBoundsException() throws IOException {
+ if (!Android.isOnAndroidDevice()) {
+ // Skip this test if not on Android.
+ return;
+ }
+ byte[] data = messageFactory().newMessage().toByteArray();
+ int exceptionCount = 0;
+ for (int i = 0; i <= data.length; i++) {
+ byte[] truncatedData = Arrays.copyOf(data, i);
+ try {
+ T message = schema.newInstance();
+ // Test that this method throws the expected exceptions.
+ schema.mergeFrom(message, truncatedData, 0, i, new ArrayDecoders.Registers());
+ } catch (InvalidProtocolBufferException e) {
+ // Ignore expected exceptions.
+ } catch (IndexOutOfBoundsException e) {
+ exceptionCount += 1;
+ }
+ }
+ assertNotEquals(0, exceptionCount);
+ }
+
+ protected static final <M extends MessageLite> void roundtrip(
+ String failureMessage, M msg, Schema<M> schema) throws IOException {
+ byte[] serializedBytes = ExperimentalSerializationUtil.toByteArray(msg, schema);
+ assertEquals(failureMessage, msg.getSerializedSize(), serializedBytes.length);
+
+ // Now read it back in and verify it matches the original.
+ if (Android.isOnAndroidDevice()) {
+ // Test the fast path on Android.
+ M newMsg = schema.newInstance();
+ schema.mergeFrom(
+ newMsg, serializedBytes, 0, serializedBytes.length, new ArrayDecoders.Registers());
+ schema.makeImmutable(newMsg);
+ assertEquals(failureMessage, msg, newMsg);
+ }
+ M newMsg = schema.newInstance();
+ Reader reader = BinaryReader.newInstance(ByteBuffer.wrap(serializedBytes), true);
+ schema.mergeFrom(newMsg, reader, ExtensionRegistryLite.getEmptyRegistry());
+ schema.makeImmutable(newMsg);
+
+ assertEquals(failureMessage, msg, newMsg);
+ }
+
+ protected final void roundtrip(String failureMessage, T msg) throws IOException {
+ roundtrip(failureMessage, msg, schema);
+ }
+
+ protected final ExperimentalTestDataProvider data() {
+ return messageFactory().dataProvider();
+ }
+
+ protected List<T> newMessagesMissingRequiredFields() {
+ return Collections.emptyList();
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testRequiredFields() throws Exception {
+ for (T msg : newMessagesMissingRequiredFields()) {
+ if (schema.isInitialized(msg)) {
+ assertEquals("", msg.toString());
+ msg = (T) msg.toBuilder().build();
+ }
+ assertFalse(schema.isInitialized(msg));
+ }
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/ArrayDecodersTest.java b/java/core/src/test/java/com/google/protobuf/ArrayDecodersTest.java
new file mode 100755
index 0000000..037173b
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/ArrayDecodersTest.java
@@ -0,0 +1,236 @@
+// 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.ArrayDecoders.Registers;
+import java.io.IOException;
+import junit.framework.TestCase;
+
+public class ArrayDecodersTest extends TestCase {
+
+ private static final int TAG = WireFormat.makeTag(1, WireFormat.WIRETYPE_LENGTH_DELIMITED);
+ private static final ByteString NEGATIVE_SIZE_0 = generateNegativeLength(0);
+ private static final ByteString NEGATIVE_SIZE_1 = generateNegativeLength(1);
+
+ private Registers registers;
+
+ @Override
+ public void setUp() {
+ registers = new Registers();
+ registers.int1 = TAG;
+ }
+
+ public void testException_decodeString() {
+ try {
+ ArrayDecoders.decodeString(NEGATIVE_SIZE_0.toByteArray(), 0, registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
+ public void testException_decodeStringRequireUtf8() {
+ try {
+ ArrayDecoders.decodeStringRequireUtf8(NEGATIVE_SIZE_0.toByteArray(), 0, registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
+ public void testException_decodeBytes() {
+ try {
+ ArrayDecoders.decodeBytes(NEGATIVE_SIZE_0.toByteArray(), 0, registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
+ public void testException_decodeStringList_first() {
+ try {
+ ArrayDecoders.decodeStringList(
+ TAG,
+ NEGATIVE_SIZE_0.toByteArray(),
+ 0,
+ NEGATIVE_SIZE_0.size(),
+ new ProtobufArrayList<Object>(),
+ registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
+ public void testException_decodeStringList_second() {
+ try {
+ ArrayDecoders.decodeStringList(
+ TAG,
+ NEGATIVE_SIZE_1.toByteArray(),
+ 0,
+ NEGATIVE_SIZE_1.size(),
+ new ProtobufArrayList<Object>(),
+ registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
+ public void testException_decodeStringListRequireUtf8_first() {
+ try {
+ ArrayDecoders.decodeStringListRequireUtf8(
+ TAG,
+ NEGATIVE_SIZE_0.toByteArray(),
+ 0,
+ NEGATIVE_SIZE_0.size(),
+ new ProtobufArrayList<Object>(),
+ registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
+ public void testException_decodeStringListRequireUtf8_second() {
+ try {
+ ArrayDecoders.decodeStringListRequireUtf8(
+ TAG,
+ NEGATIVE_SIZE_1.toByteArray(),
+ 0,
+ NEGATIVE_SIZE_1.size(),
+ new ProtobufArrayList<Object>(),
+ registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
+ public void testException_decodeBytesList_first() {
+ try {
+ ArrayDecoders.decodeBytesList(
+ TAG,
+ NEGATIVE_SIZE_0.toByteArray(),
+ 0,
+ NEGATIVE_SIZE_0.size(),
+ new ProtobufArrayList<Object>(),
+ registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
+ public void testException_decodeBytesList_second() {
+ try {
+ ArrayDecoders.decodeBytesList(
+ TAG,
+ NEGATIVE_SIZE_1.toByteArray(),
+ 0,
+ NEGATIVE_SIZE_1.size(),
+ new ProtobufArrayList<Object>(),
+ registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
+ public void testException_decodeUnknownField() {
+ try {
+ ArrayDecoders.decodeUnknownField(
+ TAG,
+ NEGATIVE_SIZE_0.toByteArray(),
+ 0,
+ NEGATIVE_SIZE_0.size(),
+ UnknownFieldSetLite.newInstance(),
+ registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
+ public void testException_decodeHugeField() {
+ byte[] badBytes =
+ new byte[] {
+ (byte) 0x80, (byte) 0xFF, (byte) 0xFF, (byte) 0xEF, 0x73, 0x74, 0x69, 0x6E, 0x67
+ };
+ try {
+ ArrayDecoders.decodeUnknownField(
+ TAG, badBytes, 0, badBytes.length, UnknownFieldSetLite.newInstance(), registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+
+ try {
+ ArrayDecoders.decodeBytes(badBytes, 0, registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+
+ byte[] badBytesList =
+ new byte[] {
+ 0x01,
+ 0x77,
+ 0x0A,
+ (byte) 0x80,
+ (byte) 0xFF,
+ (byte) 0xFF,
+ (byte) 0xEF,
+ 0x73,
+ 0x74,
+ 0x69,
+ 0x6E,
+ 0x67
+ };
+ try {
+ ArrayDecoders.decodeBytesList(
+ TAG, badBytesList, 0, badBytes.length, new ProtobufArrayList<>(), registers);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
+ private static ByteString generateNegativeLength(int count) {
+ try {
+ ByteString.Output byteStringOutput = ByteString.newOutput();
+ CodedOutputStream codedOutput = CodedOutputStream.newInstance(byteStringOutput);
+
+ // Write out count - 1 valid 0 length fields; we only write out tags after the field since
+ // ArrayDecoders expects the first tag to already have been parsed.
+ for (int i = 0; i < count; i++) {
+ codedOutput.writeInt32NoTag(0);
+ codedOutput.writeInt32NoTag(TAG);
+ }
+
+ // Write out a negative length
+ codedOutput.writeInt32NoTag(-1);
+
+ codedOutput.flush();
+
+ return byteStringOutput.toByteString();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/BinaryProtocolTest.java b/java/core/src/test/java/com/google/protobuf/BinaryProtocolTest.java
new file mode 100755
index 0000000..cda2998
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/BinaryProtocolTest.java
@@ -0,0 +1,90 @@
+// 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 org.junit.Assert.assertEquals;
+
+import com.google.protobuf.testing.Proto2Testing.Proto2Message;
+import com.google.protobuf.testing.Proto3Testing.Proto3Message;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class BinaryProtocolTest {
+ @Before
+ public void setup() {
+ TestSchemas.registerGenericProto2Schemas();
+
+ Protobuf.getInstance()
+ .registerSchemaOverride(Proto3Message.class, TestSchemas.genericProto3Schema);
+ }
+
+ @Test
+ public void proto3Roundtrip() throws Exception {
+ Proto3Message expected = new Proto3MessageFactory(5, 10, 2, 2).newMessage();
+ byte[] expectedBytes = expected.toByteArray();
+
+ // Deserialize with BinaryReader and verify that the message matches the original.
+ Proto3Message result =
+ ExperimentalSerializationUtil.fromByteArray(expectedBytes, Proto3Message.class);
+ assertEquals(expected, result);
+
+ // Now write it back out using BinaryWriter and verify the output length.
+ byte[] actualBytes = ExperimentalSerializationUtil.toByteArray(result);
+ Assert.assertEquals(expectedBytes.length, actualBytes.length);
+
+ // Read back in the bytes and verify that it matches the original message.
+ Proto3Message actual = Proto3Message.parseFrom(actualBytes);
+ assertEquals(expected, actual);
+ }
+
+ @Test
+ public void proto2Roundtrip() throws Exception {
+ Proto2Message expected = new Proto2MessageFactory(5, 10, 2, 2).newMessage();
+ byte[] expectedBytes = expected.toByteArray();
+
+ // Deserialize with BinaryReader and verify that the message matches the original.
+ Proto2Message result =
+ ExperimentalSerializationUtil.fromByteArray(expectedBytes, Proto2Message.class);
+ assertEquals(expected, result);
+
+ // Now write it back out using BinaryWriter and verify the output length.
+ byte[] actualBytes = ExperimentalSerializationUtil.toByteArray(result);
+ Assert.assertEquals(expectedBytes.length, actualBytes.length);
+
+ // Read back in the bytes and verify that it matches the original message.
+ Proto2Message actual = Proto2Message.parseFrom(actualBytes);
+ assertEquals(expected, actual);
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/CachedFieldSizeTest.java b/java/core/src/test/java/com/google/protobuf/CachedFieldSizeTest.java
new file mode 100755
index 0000000..96319d9
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/CachedFieldSizeTest.java
@@ -0,0 +1,65 @@
+// 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 org.junit.Assert.assertEquals;
+
+import protobuf_unittest.UnittestProto.TestPackedTypes;
+import proto3_unittest.UnittestProto3;
+import protobuf_unittest.TestCachedFieldSizeMessage;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class CachedFieldSizeTest {
+ // Regression test for b/74087933
+ @Test
+ public void testCachedFieldSize() throws Exception {
+ TestCachedFieldSizeMessage.Builder builder = TestCachedFieldSizeMessage.newBuilder();
+ builder.setProto2Child(TestUtil.getPackedSet());
+ builder.setProto3Child(
+ UnittestProto3.TestPackedTypes.parseFrom(TestUtil.getPackedSet().toByteArray()));
+ TestCachedFieldSizeMessage message = builder.build();
+
+ // Serialize once to cache all field sizes. This will use the experimental runtime because
+ // the proto has optimize_for = CODE_SIZE.
+ message.toByteArray();
+ // Serialize individual submessages. This will use the generated implementation. If the
+ // experimental runtime hasn't set the correct cached size, this will throw an exception.
+ byte[] data2 = message.getProto2Child().toByteArray();
+ byte[] data3 = message.getProto3Child().toByteArray();
+
+ // Make sure the serialized data is correct.
+ assertEquals(message.getProto2Child(), TestPackedTypes.parseFrom(data2));
+ assertEquals(message.getProto3Child(), UnittestProto3.TestPackedTypes.parseFrom(data3));
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/CodedAdapterTest.java b/java/core/src/test/java/com/google/protobuf/CodedAdapterTest.java
new file mode 100755
index 0000000..a24b48b
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/CodedAdapterTest.java
@@ -0,0 +1,110 @@
+// 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 org.junit.Assert.assertEquals;
+
+import com.google.protobuf.testing.Proto2Testing.Proto2Message;
+import com.google.protobuf.testing.Proto3Testing.Proto3Message;
+import java.io.IOException;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class CodedAdapterTest {
+ @Before
+ public void setup() {
+ TestSchemas.registerGenericProto2Schemas();
+
+ Protobuf.getInstance()
+ .registerSchemaOverride(Proto3Message.class, TestSchemas.genericProto3Schema);
+ }
+
+ @Test
+ public void proto3Roundtrip() throws Exception {
+ Proto3Message expected = new Proto3MessageFactory(5, 10, 2, 2).newMessage();
+ byte[] expectedBytes = expected.toByteArray();
+
+ // Deserialize with BinaryReader and verify that the message matches the original.
+ Proto3Message result = fromByteArray(expectedBytes, Proto3Message.class);
+ assertEquals(expected, result);
+
+ // Now write it back out using BinaryWriter and verify the output length.
+ byte[] actualBytes = toByteArray(result, expectedBytes.length);
+
+ // Read back in the bytes and verify that it matches the original message.
+ Proto3Message actual = Proto3Message.parseFrom(actualBytes);
+ assertEquals(expected, actual);
+ }
+
+ @Test
+ public void proto2Roundtrip() throws Exception {
+ Proto2Message expected = new Proto2MessageFactory(5, 10, 2, 2).newMessage();
+ byte[] expectedBytes = expected.toByteArray();
+
+ // Deserialize with BinaryReader and verify that the message matches the original.
+ Proto2Message result = fromByteArray(expectedBytes, Proto2Message.class);
+ assertEquals(expected, result);
+
+ // Now write it back out using BinaryWriter and verify the output length.
+ byte[] actualBytes = toByteArray(result, expectedBytes.length);
+
+ // Read back in the bytes and verify that it matches the original message.
+ Proto2Message actual = Proto2Message.parseFrom(actualBytes);
+ assertEquals(expected, actual);
+ }
+
+ public static <T> byte[] toByteArray(T msg, int size) throws Exception {
+ Schema<T> schema = Protobuf.getInstance().schemaFor(msg);
+ byte[] out = new byte[size];
+ CodedOutputStreamWriter writer =
+ CodedOutputStreamWriter.forCodedOutput(CodedOutputStream.newInstance(out));
+ schema.writeTo(msg, writer);
+ assertEquals(out.length, writer.getTotalBytesWritten());
+ return out;
+ }
+
+ public static <T> T fromByteArray(byte[] data, Class<T> messageType) {
+ Schema<T> schema = Protobuf.getInstance().schemaFor(messageType);
+ try {
+ T msg = schema.newInstance();
+ schema.mergeFrom(
+ msg,
+ CodedInputStreamReader.forCodedInput(CodedInputStream.newInstance(data)),
+ ExtensionRegistryLite.EMPTY_REGISTRY_LITE);
+ return msg;
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java b/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java
index 9c5d6da..532052c 100644
--- a/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java
+++ b/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java
@@ -44,6 +44,7 @@
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.List;
import junit.framework.TestCase;
/**
@@ -1195,4 +1196,59 @@
// Expected
}
}
+
+ public void testMaliciousInputStream() throws Exception {
+ ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+ CodedOutputStream codedOutputStream = CodedOutputStream.newInstance(outputStream);
+ codedOutputStream.writeByteArrayNoTag(new byte[] { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5 });
+ codedOutputStream.flush();
+ final List<byte[]> maliciousCapture = new ArrayList<>();
+ InputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray()) {
+ @Override
+ public synchronized int read(byte[] b, int off, int len) {
+ maliciousCapture.add(b);
+ return super.read(b, off, len);
+ }
+ };
+
+ // test ByteString
+
+ CodedInputStream codedInputStream = CodedInputStream.newInstance(inputStream, 1);
+ ByteString byteString = codedInputStream.readBytes();
+ assertEquals(0x0, byteString.byteAt(0));
+ maliciousCapture.get(1)[0] = 0x9;
+ assertEquals(0x0, byteString.byteAt(0));
+
+ // test ByteBuffer
+
+ inputStream.reset();
+ maliciousCapture.clear();
+ codedInputStream = CodedInputStream.newInstance(inputStream, 1);
+ ByteBuffer byteBuffer = codedInputStream.readByteBuffer();
+ assertEquals(0x0, byteBuffer.get(0));
+ maliciousCapture.get(1)[0] = 0x9;
+ assertEquals(0x0, byteBuffer.get(0));
+
+
+ // test byte[]
+
+ inputStream.reset();
+ maliciousCapture.clear();
+ codedInputStream = CodedInputStream.newInstance(inputStream, 1);
+ byte[] byteArray = codedInputStream.readByteArray();
+ assertEquals(0x0, byteArray[0]);
+ maliciousCapture.get(1)[0] = 0x9;
+ assertEquals(0x9, byteArray[0]); // MODIFICATION! Should we fix?
+
+ // test rawBytes
+
+ inputStream.reset();
+ maliciousCapture.clear();
+ codedInputStream = CodedInputStream.newInstance(inputStream, 1);
+ int length = codedInputStream.readRawVarint32();
+ byteArray = codedInputStream.readRawBytes(length);
+ assertEquals(0x0, byteArray[0]);
+ maliciousCapture.get(1)[0] = 0x9;
+ assertEquals(0x9, byteArray[0]); // MODIFICATION! Should we fix?
+ }
}
diff --git a/java/core/src/test/java/com/google/protobuf/DescriptorsTest.java b/java/core/src/test/java/com/google/protobuf/DescriptorsTest.java
index 5f91324..c222ff3 100644
--- a/java/core/src/test/java/com/google/protobuf/DescriptorsTest.java
+++ b/java/core/src/test/java/com/google/protobuf/DescriptorsTest.java
@@ -30,6 +30,8 @@
package com.google.protobuf;
+import protobuf_unittest.NestedExtension;
+import protobuf_unittest.NonNestedExtension;
import com.google.protobuf.DescriptorProtos.DescriptorProto;
import com.google.protobuf.DescriptorProtos.EnumDescriptorProto;
import com.google.protobuf.DescriptorProtos.EnumValueDescriptorProto;
@@ -779,4 +781,23 @@
assertEquals("FIELDNAME5", d.getFields().get(4).getJsonName());
assertEquals("@type", d.getFields().get(5).getJsonName());
}
+
+ public void testExtensionRenamesKeywords() {
+ assertTrue(NonNestedExtension.if_ instanceof GeneratedMessage.GeneratedExtension);
+ assertTrue(
+ NestedExtension.MyNestedExtension.default_
+ instanceof GeneratedMessage.GeneratedExtension);
+
+ NonNestedExtension.MessageToBeExtended msg =
+ NonNestedExtension.MessageToBeExtended.newBuilder()
+ .setExtension(NonNestedExtension.if_, "!fi")
+ .build();
+ assertEquals("!fi", msg.getExtension(NonNestedExtension.if_));
+
+ msg =
+ NonNestedExtension.MessageToBeExtended.newBuilder()
+ .setExtension(NestedExtension.MyNestedExtension.default_, 8)
+ .build();
+ assertEquals(8, msg.getExtension(NestedExtension.MyNestedExtension.default_).intValue());
+ }
}
diff --git a/java/core/src/test/java/com/google/protobuf/ExperimentalMessageFactory.java b/java/core/src/test/java/com/google/protobuf/ExperimentalMessageFactory.java
new file mode 100755
index 0000000..60c8609
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/ExperimentalMessageFactory.java
@@ -0,0 +1,40 @@
+// 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;
+
+/** Interface for a test factory for messages. */
+public interface ExperimentalMessageFactory<T extends MessageLite> {
+ /** Creates a new random message instance. */
+ T newMessage();
+
+ /** Gets the underlying data provider. */
+ ExperimentalTestDataProvider dataProvider();
+}
diff --git a/java/core/src/test/java/com/google/protobuf/ExperimentalSerializationUtil.java b/java/core/src/test/java/com/google/protobuf/ExperimentalSerializationUtil.java
new file mode 100755
index 0000000..05aaa67
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/ExperimentalSerializationUtil.java
@@ -0,0 +1,113 @@
+// 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.nio.ByteBuffer;
+import java.util.Queue;
+
+/** Utilities for serialization. */
+public class ExperimentalSerializationUtil {
+
+ /**
+ * Serializes the given message to a byte array using {@link com.google.protobuf.BinaryWriter}.
+ */
+ public static <T> byte[] toByteArray(T msg) throws IOException {
+ return toByteArray(msg, Protobuf.getInstance().schemaFor(msg));
+ }
+
+ /**
+ * Serializes the given message to a byte array using {@link com.google.protobuf.BinaryWriter}
+ * with a customized Schema.
+ */
+ public static <T> byte[] toByteArray(T msg, Schema<T> schema) throws IOException {
+ BinaryWriter writer = BinaryWriter.newHeapInstance(BufferAllocator.unpooled());
+ schema.writeTo(msg, writer);
+
+ byte[] out = new byte[writer.getTotalBytesWritten()];
+ int outPos = 0;
+ Queue<AllocatedBuffer> buffers = writer.complete();
+ while (true) {
+ AllocatedBuffer buffer = buffers.poll();
+ if (buffer == null) {
+ break;
+ }
+ int length = buffer.limit() - buffer.position();
+ System.arraycopy(
+ buffer.array(), buffer.arrayOffset() + buffer.position(), out, outPos, length);
+ outPos += length;
+ }
+ if (out.length != outPos) {
+ throw new IllegalArgumentException("Failed to serialize test message");
+ }
+ return out;
+ }
+
+ /** Deserializes a message from the given byte array. */
+ public static <T> T fromByteArray(byte[] data, Class<T> messageType) {
+ if (Android.isOnAndroidDevice()) {
+ return fromByteArrayFastPath(data, messageType);
+ } else {
+ return fromByteArray(data, messageType, ExtensionRegistryLite.getEmptyRegistry());
+ }
+ }
+
+ /**
+ * Deserializes a message from the given byte array using {@link com.google.protobuf.BinaryReader}
+ * with an extension registry and a customized Schema.
+ */
+ public static <T> T fromByteArray(
+ byte[] data, Class<T> messageType, ExtensionRegistryLite extensionRegistry) {
+ try {
+ Schema<T> schema = Protobuf.getInstance().schemaFor(messageType);
+ T msg = schema.newInstance();
+ schema.mergeFrom(
+ msg, BinaryReader.newInstance(ByteBuffer.wrap(data), true), extensionRegistry);
+ schema.makeImmutable(msg);
+ return msg;
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /** Deserializes a lite message from the given byte array using fast path. */
+ private static <T> T fromByteArrayFastPath(byte[] data, Class<T> messageType) {
+ try {
+ Schema<T> schema = Protobuf.getInstance().schemaFor(messageType);
+ T msg = schema.newInstance();
+ schema.mergeFrom(msg, data, 0, data.length, new ArrayDecoders.Registers());
+ schema.makeImmutable(msg);
+ return msg;
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/ExperimentalTestDataProvider.java b/java/core/src/test/java/com/google/protobuf/ExperimentalTestDataProvider.java
new file mode 100755
index 0000000..3ef93ac
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/ExperimentalTestDataProvider.java
@@ -0,0 +1,189 @@
+// 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.Random;
+
+/** Utility class that provides data primitives for filling out protobuf messages. */
+public final class ExperimentalTestDataProvider {
+ private static final Random RANDOM = new Random(100);
+
+ private final Varint32Provider varint32s = new Varint32Provider();
+ private final Varint64Provider varint64s = new Varint64Provider();
+ private final int stringLength;
+
+ public ExperimentalTestDataProvider(int stringLength) {
+ this.stringLength = stringLength;
+ }
+
+ public double getDouble() {
+ double value = 0.0;
+ while (Double.compare(0.0, value) == 0) {
+ value = RANDOM.nextDouble();
+ }
+ return value;
+ }
+
+ public float getFloat() {
+ float value = 0.0f;
+ while (Float.compare(0.0f, value) == 0) {
+ value = RANDOM.nextFloat();
+ }
+ return value;
+ }
+
+ public long getLong() {
+ return varint64s.getLong();
+ }
+
+ public int getInt() {
+ return varint32s.getInt();
+ }
+
+ public boolean getBool() {
+ return true;
+ }
+
+ public int getEnum() {
+ return Math.abs(getInt()) % 3;
+ }
+
+ public String getString() {
+ StringBuilder builder = new StringBuilder(stringLength);
+ for (int i = 0; i < stringLength; ++i) {
+ builder.append((char) (RANDOM.nextInt('z' - 'a') + 'a'));
+ }
+ return builder.toString();
+ }
+
+ public ByteString getBytes() {
+ return ByteString.copyFromUtf8(getString());
+ }
+
+ /**
+ * Iterator over integer values. Uses a simple distribution over 32-bit varints (generally
+ * favoring smaller values).
+ */
+ private static final class Varint32Provider {
+ private static final int[][] VALUES = {
+ new int[] {1, 50, 100, 127}, // 1 byte values
+ new int[] {128, 500, 10000, 16383}, // 2 bytes values
+ new int[] {16384, 50000, 1000000, 2097151}, // 3 bytes values
+ new int[] {2097152, 10000000, 200000000, 268435455}, // 4 bytes values
+ new int[] {268435456, 0x30000000, 0x7FFFFFFF, 0xFFFFFFFF} // 5 bytes values
+ };
+
+ /** Number of samples that should be taken from each value array. */
+ private static final int[] NUM_SAMPLES = {3, 2, 1, 1, 2};
+
+ /**
+ * The index into the {@link #VALUES} array that identifies the list of samples currently being
+ * iterated over.
+ */
+ private int listIndex;
+
+ /** The index of the next sample within a list. */
+ private int sampleIndex;
+
+ /** The number of successive samples that have been taken from the current list. */
+ private int samplesTaken;
+
+ public int getInt() {
+ if (samplesTaken++ > NUM_SAMPLES[listIndex]) {
+ // Done taking samples from this list. Go to the next one.
+ listIndex = (listIndex + 1) % VALUES.length;
+ sampleIndex = 0;
+ samplesTaken = 0;
+ }
+
+ int value = VALUES[listIndex][sampleIndex];
+
+ // All lists are exactly 4 long (i.e. power of 2), so we can optimize the mod operation
+ // with masking.
+ sampleIndex = (sampleIndex + 1) & 3;
+
+ return value;
+ }
+ }
+
+ /**
+ * Iterator over integer values. Uses a simple distribution over 64-bit varints (generally
+ * favoring smaller values).
+ */
+ private static final class Varint64Provider {
+ private static final long[][] VALUES = {
+ new long[] {1, 50, 100, 127},
+ new long[] {128, 500, 10000, 16383},
+ new long[] {16384, 50000, 1000000, 2097151},
+ new long[] {2097152, 10000000, 200000000, 268435455},
+ new long[] {268435456, 0x30000000, 0x7FFFFFFF, 34359738367L},
+ new long[] {34359738368L, 2000000000000L, 4000000000000L, 4398046511103L},
+ new long[] {4398046511104L, 200000000000000L, 500000000000000L, 562949953421311L},
+ new long[] {0x4000000000000L, 0x5000000000000L, 0x6000000000000L, 0x0FFFFFFFFFFFFFFL},
+ new long[] {0x100000000000000L, 0x3FFFFFFFFFFFFFFFL, 0x5FFFFFFFFFFFFFFL, 0x7FFFFFFFFFFFFFFFL},
+ new long[] {
+ 0xFFFFFFFFFFFFFFFFL, 0xFFFFFFFFFFFFFFFFL, 0xFFFFFFFFFFFFFFFFL, 0xFFFFFFFFFFFFFFFFL
+ }
+ };
+
+ /** Number of samples that should be taken from each value array. */
+ private static final int[] NUM_SAMPLES = {4, 2, 2, 1, 1, 1, 1, 2, 2, 4};
+
+ /**
+ * The index into the {@link #VALUES} array that identifies the list of samples currently being
+ * iterated over.
+ */
+ private int listIndex;
+
+ /** The index of the next sample within a list. */
+ private int sampleIndex;
+
+ /** The number of successive samples that have been taken from the current list. */
+ private int samplesTaken;
+
+ public long getLong() {
+ if (samplesTaken++ > NUM_SAMPLES[listIndex]) {
+ // Done taking samples from this list. Go to the next one.
+ listIndex = (listIndex + 1) % VALUES.length;
+ sampleIndex = 0;
+ samplesTaken = 0;
+ }
+
+ long value = VALUES[listIndex][sampleIndex];
+
+ // All lists are exactly 4 long (i.e. power of 2), so we can optimize the mod operation
+ // with masking.
+ sampleIndex = (sampleIndex + 1) & 3;
+
+ return value;
+ }
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/ExtensionRegistryFactoryTest.java b/java/core/src/test/java/com/google/protobuf/ExtensionRegistryFactoryTest.java
index 30fd147..3eb0ced 100644
--- a/java/core/src/test/java/com/google/protobuf/ExtensionRegistryFactoryTest.java
+++ b/java/core/src/test/java/com/google/protobuf/ExtensionRegistryFactoryTest.java
@@ -30,8 +30,6 @@
package com.google.protobuf;
-import protobuf_unittest.NestedExtension;
-import protobuf_unittest.NestedExtensionLite;
import protobuf_unittest.NonNestedExtension;
import protobuf_unittest.NonNestedExtensionLite;
import java.lang.reflect.Method;
@@ -71,8 +69,6 @@
void testAdd();
void testAdd_immutable();
-
- void testExtensionRenamesKeywords();
}
/** Test implementations for the non-Lite usage of ExtensionRegistryFactory. */
@@ -160,23 +156,6 @@
} catch (IllegalArgumentException expected) {
}
}
-
- @Override
- public void testExtensionRenamesKeywords() {
- assertTrue(NonNestedExtension.if_ instanceof GeneratedMessage.GeneratedExtension);
- assertTrue(NestedExtension.MyNestedExtension.default_ instanceof GeneratedMessage.GeneratedExtension);
-
- NonNestedExtension.MessageToBeExtended msg =
- NonNestedExtension.MessageToBeExtended.newBuilder()
- .setExtension(NonNestedExtension.if_, "!fi")
- .build();
- assertEquals("!fi", msg.getExtension(NonNestedExtension.if_));
-
- msg = NonNestedExtension.MessageToBeExtended.newBuilder()
- .setExtension(NestedExtension.MyNestedExtension.default_, 8)
- .build();
- assertEquals(8, msg.getExtension(NestedExtension.MyNestedExtension.default_).intValue());
- }
}
/** Test implementations for the Lite usage of ExtensionRegistryFactory. */
@@ -223,23 +202,6 @@
} catch (UnsupportedOperationException expected) {
}
}
-
- @Override
- public void testExtensionRenamesKeywords() {
- assertTrue(NonNestedExtensionLite.package_ instanceof GeneratedMessageLite.GeneratedExtension);
- assertTrue(NestedExtensionLite.MyNestedExtensionLite.private_ instanceof GeneratedMessageLite.GeneratedExtension);
-
- NonNestedExtensionLite.MessageLiteToBeExtended msg =
- NonNestedExtensionLite.MessageLiteToBeExtended.newBuilder()
- .setExtension(NonNestedExtensionLite.package_, true)
- .build();
- assertTrue(msg.getExtension(NonNestedExtensionLite.package_));
-
- msg = NonNestedExtensionLite.MessageLiteToBeExtended.newBuilder()
- .setExtension(NestedExtensionLite.MyNestedExtensionLite.private_, 2.4)
- .build();
- assertEquals(2.4, msg.getExtension(NestedExtensionLite.MyNestedExtensionLite.private_), 0.001);
- }
}
/** Defines a suite of tests which the JUnit3 runner retrieves by reflection. */
@@ -311,7 +273,10 @@
resolveClass(loadedClass);
}
}
- } catch (ClassNotFoundException e) {
+ } catch (ClassNotFoundException | SecurityException e) {
+ // Java 8+ would throw a SecurityException if we attempt to find a loaded class from
+ // java.lang.* package. We don't really care about those anyway, so just delegate to the
+ // parent class loader.
loadedClass = super.loadClass(name, resolve);
}
return loadedClass;
diff --git a/java/core/src/test/java/com/google/protobuf/MapLiteTest.java b/java/core/src/test/java/com/google/protobuf/MapLiteTest.java
new file mode 100755
index 0000000..d18fd13
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/MapLiteTest.java
@@ -0,0 +1,894 @@
+// 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 org.junit.Assert.assertArrayEquals;
+
+import map_lite_test.MapTestProto.BizarroTestMap;
+import map_lite_test.MapTestProto.TestMap;
+import map_lite_test.MapTestProto.TestMap.MessageValue;
+import map_lite_test.MapTestProto.TestMapOrBuilder;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import junit.framework.TestCase;
+
+/** Unit tests for map fields. */
+public final class MapLiteTest extends TestCase {
+
+ private void setMapValues(TestMap.Builder builder) {
+ builder
+ .putInt32ToInt32Field(1, 11)
+ .putInt32ToInt32Field(2, 22)
+ .putInt32ToInt32Field(3, 33)
+ .putInt32ToStringField(1, "11")
+ .putInt32ToStringField(2, "22")
+ .putInt32ToStringField(3, "33")
+ .putInt32ToBytesField(1, TestUtil.toBytes("11"))
+ .putInt32ToBytesField(2, TestUtil.toBytes("22"))
+ .putInt32ToBytesField(3, TestUtil.toBytes("33"))
+ .putInt32ToEnumField(1, TestMap.EnumValue.FOO)
+ .putInt32ToEnumField(2, TestMap.EnumValue.BAR)
+ .putInt32ToEnumField(3, TestMap.EnumValue.BAZ)
+ .putInt32ToMessageField(1, MessageValue.newBuilder().setValue(11).build())
+ .putInt32ToMessageField(2, MessageValue.newBuilder().setValue(22).build())
+ .putInt32ToMessageField(3, MessageValue.newBuilder().setValue(33).build())
+ .putStringToInt32Field("1", 11)
+ .putStringToInt32Field("2", 22)
+ .putStringToInt32Field("3", 33);
+ }
+
+ public void testSetMapValues() {
+ TestMap.Builder usingMutableMapBuilder = TestMap.newBuilder();
+ setMapValues(usingMutableMapBuilder);
+ TestMap usingMutableMap = usingMutableMapBuilder.build();
+ assertMapValuesSet(usingMutableMap);
+
+ TestMap.Builder usingAccessorsBuilder = TestMap.newBuilder();
+ setMapValues(usingAccessorsBuilder);
+ TestMap usingAccessors = usingAccessorsBuilder.build();
+ assertMapValuesSet(usingAccessors);
+ assertEquals(usingAccessors, usingMutableMap);
+ }
+
+ private void copyMapValues(TestMap source, TestMap.Builder destination) {
+ destination
+ .putAllInt32ToInt32Field(source.getInt32ToInt32Field())
+ .putAllInt32ToStringField(source.getInt32ToStringField())
+ .putAllInt32ToBytesField(source.getInt32ToBytesField())
+ .putAllInt32ToEnumField(source.getInt32ToEnumField())
+ .putAllInt32ToMessageField(source.getInt32ToMessageField())
+ .putAllStringToInt32Field(source.getStringToInt32Field());
+ }
+
+ private void assertMapValuesSet(TestMap message) {
+ assertEquals(3, message.getInt32ToInt32Field().size());
+ assertEquals(11, message.getInt32ToInt32Field().get(1).intValue());
+ assertEquals(22, message.getInt32ToInt32Field().get(2).intValue());
+ assertEquals(33, message.getInt32ToInt32Field().get(3).intValue());
+
+ assertEquals(3, message.getInt32ToStringField().size());
+ assertEquals("11", message.getInt32ToStringField().get(1));
+ assertEquals("22", message.getInt32ToStringField().get(2));
+ assertEquals("33", message.getInt32ToStringField().get(3));
+
+ assertEquals(3, message.getInt32ToBytesField().size());
+ assertEquals(TestUtil.toBytes("11"), message.getInt32ToBytesField().get(1));
+ assertEquals(TestUtil.toBytes("22"), message.getInt32ToBytesField().get(2));
+ assertEquals(TestUtil.toBytes("33"), message.getInt32ToBytesField().get(3));
+
+ assertEquals(3, message.getInt32ToEnumField().size());
+ assertEquals(TestMap.EnumValue.FOO, message.getInt32ToEnumField().get(1));
+ assertEquals(TestMap.EnumValue.BAR, message.getInt32ToEnumField().get(2));
+ assertEquals(TestMap.EnumValue.BAZ, message.getInt32ToEnumField().get(3));
+
+ assertEquals(3, message.getInt32ToMessageField().size());
+ assertEquals(11, message.getInt32ToMessageField().get(1).getValue());
+ assertEquals(22, message.getInt32ToMessageField().get(2).getValue());
+ assertEquals(33, message.getInt32ToMessageField().get(3).getValue());
+
+ assertEquals(3, message.getStringToInt32Field().size());
+ assertEquals(11, message.getStringToInt32Field().get("1").intValue());
+ assertEquals(22, message.getStringToInt32Field().get("2").intValue());
+ assertEquals(33, message.getStringToInt32Field().get("3").intValue());
+ }
+
+ private void updateMapValues(TestMap.Builder builder) {
+ builder
+ .putInt32ToInt32Field(1, 111)
+ .removeInt32ToInt32Field(2)
+ .putInt32ToInt32Field(4, 44)
+ .putInt32ToStringField(1, "111")
+ .removeInt32ToStringField(2)
+ .putInt32ToStringField(4, "44")
+ .putInt32ToBytesField(1, TestUtil.toBytes("111"))
+ .removeInt32ToBytesField(2)
+ .putInt32ToBytesField(4, TestUtil.toBytes("44"))
+ .putInt32ToEnumField(1, TestMap.EnumValue.BAR)
+ .removeInt32ToEnumField(2)
+ .putInt32ToEnumField(4, TestMap.EnumValue.QUX)
+ .putInt32ToMessageField(1, MessageValue.newBuilder().setValue(111).build())
+ .removeInt32ToMessageField(2)
+ .putInt32ToMessageField(4, MessageValue.newBuilder().setValue(44).build())
+ .putStringToInt32Field("1", 111)
+ .removeStringToInt32Field("2")
+ .putStringToInt32Field("4", 44);
+ }
+
+ public void testUpdateMapValues() {
+ TestMap.Builder mapBuilder = TestMap.newBuilder();
+ setMapValues(mapBuilder);
+ TestMap map = mapBuilder.build();
+ assertMapValuesSet(map);
+
+ mapBuilder = map.toBuilder();
+ updateMapValues(mapBuilder);
+ map = mapBuilder.build();
+ assertMapValuesUpdated(map);
+ }
+
+ private void assertMapValuesUpdated(TestMap message) {
+ assertEquals(3, message.getInt32ToInt32Field().size());
+ assertEquals(111, message.getInt32ToInt32Field().get(1).intValue());
+ assertEquals(33, message.getInt32ToInt32Field().get(3).intValue());
+ assertEquals(44, message.getInt32ToInt32Field().get(4).intValue());
+
+ assertEquals(3, message.getInt32ToStringField().size());
+ assertEquals("111", message.getInt32ToStringField().get(1));
+ assertEquals("33", message.getInt32ToStringField().get(3));
+ assertEquals("44", message.getInt32ToStringField().get(4));
+
+ assertEquals(3, message.getInt32ToBytesField().size());
+ assertEquals(TestUtil.toBytes("111"), message.getInt32ToBytesField().get(1));
+ assertEquals(TestUtil.toBytes("33"), message.getInt32ToBytesField().get(3));
+ assertEquals(TestUtil.toBytes("44"), message.getInt32ToBytesField().get(4));
+
+ assertEquals(3, message.getInt32ToEnumField().size());
+ assertEquals(TestMap.EnumValue.BAR, message.getInt32ToEnumField().get(1));
+ assertEquals(TestMap.EnumValue.BAZ, message.getInt32ToEnumField().get(3));
+ assertEquals(TestMap.EnumValue.QUX, message.getInt32ToEnumField().get(4));
+
+ assertEquals(3, message.getInt32ToMessageField().size());
+ assertEquals(111, message.getInt32ToMessageField().get(1).getValue());
+ assertEquals(33, message.getInt32ToMessageField().get(3).getValue());
+ assertEquals(44, message.getInt32ToMessageField().get(4).getValue());
+
+ assertEquals(3, message.getStringToInt32Field().size());
+ assertEquals(111, message.getStringToInt32Field().get("1").intValue());
+ assertEquals(33, message.getStringToInt32Field().get("3").intValue());
+ assertEquals(44, message.getStringToInt32Field().get("4").intValue());
+ }
+
+ private void assertMapValuesCleared(TestMapOrBuilder testMapOrBuilder) {
+ assertEquals(0, testMapOrBuilder.getInt32ToInt32Field().size());
+ assertEquals(0, testMapOrBuilder.getInt32ToInt32FieldCount());
+ assertEquals(0, testMapOrBuilder.getInt32ToStringField().size());
+ assertEquals(0, testMapOrBuilder.getInt32ToStringFieldCount());
+ assertEquals(0, testMapOrBuilder.getInt32ToBytesField().size());
+ assertEquals(0, testMapOrBuilder.getInt32ToBytesFieldCount());
+ assertEquals(0, testMapOrBuilder.getInt32ToEnumField().size());
+ assertEquals(0, testMapOrBuilder.getInt32ToEnumFieldCount());
+ assertEquals(0, testMapOrBuilder.getInt32ToMessageField().size());
+ assertEquals(0, testMapOrBuilder.getInt32ToMessageFieldCount());
+ assertEquals(0, testMapOrBuilder.getStringToInt32Field().size());
+ assertEquals(0, testMapOrBuilder.getStringToInt32FieldCount());
+ }
+
+ public void testSanityCopyOnWrite() throws InvalidProtocolBufferException {
+ // Since builders are implemented as a thin wrapper around a message
+ // instance, we attempt to verify that we can't cause the builder to modify
+ // a produced message.
+
+ TestMap.Builder builder = TestMap.newBuilder();
+ TestMap message = builder.build();
+ builder.putInt32ToInt32Field(1, 2);
+ assertTrue(message.getInt32ToInt32Field().isEmpty());
+ assertEquals(newMap(1, 2), builder.getInt32ToInt32Field());
+ message = builder.build();
+ builder.putInt32ToInt32Field(2, 3);
+ assertEquals(newMap(1, 2), message.getInt32ToInt32Field());
+ assertEquals(newMap(1, 2, 2, 3), builder.getInt32ToInt32Field());
+ }
+
+ public void testGetMapIsImmutable() {
+ TestMap.Builder builder = TestMap.newBuilder();
+ assertMapsAreImmutable(builder);
+ assertMapsAreImmutable(builder.build());
+
+ setMapValues(builder);
+ assertMapsAreImmutable(builder);
+ assertMapsAreImmutable(builder.build());
+ }
+
+ private void assertMapsAreImmutable(TestMapOrBuilder testMapOrBuilder) {
+ assertImmutable(testMapOrBuilder.getInt32ToInt32Field(), 1, 2);
+ assertImmutable(testMapOrBuilder.getInt32ToStringField(), 1, "2");
+ assertImmutable(testMapOrBuilder.getInt32ToBytesField(), 1, TestUtil.toBytes("2"));
+ assertImmutable(testMapOrBuilder.getInt32ToEnumField(), 1, TestMap.EnumValue.FOO);
+ assertImmutable(
+ testMapOrBuilder.getInt32ToMessageField(), 1, MessageValue.getDefaultInstance());
+ assertImmutable(testMapOrBuilder.getStringToInt32Field(), "1", 2);
+ }
+
+ private <K, V> void assertImmutable(Map<K, V> map, K key, V value) {
+ try {
+ map.put(key, value);
+ fail();
+ } catch (UnsupportedOperationException e) {
+ // expected
+ }
+ if (!map.isEmpty()) {
+ try {
+ map.entrySet().remove(map.entrySet().iterator().next());
+ fail();
+ } catch (UnsupportedOperationException e) {
+ // expected
+ }
+ }
+ }
+
+ public void testMapFieldClear() {
+ TestMap.Builder builder = TestMap.newBuilder().putInt32ToInt32Field(1, 2);
+ builder.clearInt32ToInt32Field();
+ assertEquals(0, builder.getInt32ToInt32FieldCount());
+ }
+
+ public void testMutableMapLifecycle() {
+ TestMap.Builder builder = TestMap.newBuilder().putInt32ToInt32Field(1, 2);
+ assertEquals(newMap(1, 2), builder.build().getInt32ToInt32Field());
+ assertEquals(newMap(1, 2), builder.getInt32ToInt32Field());
+ builder.putInt32ToInt32Field(2, 3);
+ assertEquals(newMap(1, 2, 2, 3), builder.getInt32ToInt32Field());
+
+ builder.putInt32ToEnumField(1, TestMap.EnumValue.BAR);
+ assertEquals(newMap(1, TestMap.EnumValue.BAR), builder.build().getInt32ToEnumField());
+ assertEquals(newMap(1, TestMap.EnumValue.BAR), builder.getInt32ToEnumField());
+ builder.putInt32ToEnumField(2, TestMap.EnumValue.FOO);
+ assertEquals(
+ newMap(1, TestMap.EnumValue.BAR, 2, TestMap.EnumValue.FOO), builder.getInt32ToEnumField());
+
+ builder.putInt32ToStringField(1, "1");
+ assertEquals(newMap(1, "1"), builder.build().getInt32ToStringField());
+ assertEquals(newMap(1, "1"), builder.getInt32ToStringField());
+ builder.putInt32ToStringField(2, "2");
+ assertEquals(newMap(1, "1", 2, "2"), builder.getInt32ToStringField());
+
+ builder.putInt32ToMessageField(1, TestMap.MessageValue.getDefaultInstance());
+ assertEquals(
+ newMap(1, TestMap.MessageValue.getDefaultInstance()),
+ builder.build().getInt32ToMessageField());
+ assertEquals(
+ newMap(1, TestMap.MessageValue.getDefaultInstance()), builder.getInt32ToMessageField());
+ builder.putInt32ToMessageField(2, TestMap.MessageValue.getDefaultInstance());
+ assertEquals(
+ newMap(
+ 1,
+ TestMap.MessageValue.getDefaultInstance(),
+ 2,
+ TestMap.MessageValue.getDefaultInstance()),
+ builder.getInt32ToMessageField());
+ }
+
+ public void testGettersAndSetters() throws Exception {
+ TestMap.Builder builder = TestMap.newBuilder();
+ TestMap message = builder.build();
+ assertMapValuesCleared(message);
+
+ builder = message.toBuilder();
+ setMapValues(builder);
+ message = builder.build();
+ assertMapValuesSet(message);
+
+ builder = message.toBuilder();
+ updateMapValues(builder);
+ message = builder.build();
+ assertMapValuesUpdated(message);
+
+ builder = message.toBuilder();
+ builder.clear();
+ assertMapValuesCleared(builder);
+ message = builder.build();
+ assertMapValuesCleared(message);
+ }
+
+ public void testPutAll() throws Exception {
+ TestMap.Builder sourceBuilder = TestMap.newBuilder();
+ setMapValues(sourceBuilder);
+ TestMap source = sourceBuilder.build();
+ assertMapValuesSet(source);
+
+ TestMap.Builder destination = TestMap.newBuilder();
+ copyMapValues(source, destination);
+ assertMapValuesSet(destination.build());
+ }
+
+ public void testPutAllForUnknownEnumValues() throws Exception {
+ TestMap.Builder sourceBuilder =
+ TestMap.newBuilder()
+ .putInt32ToEnumFieldValue(0, 0)
+ .putInt32ToEnumFieldValue(1, 1)
+ .putAllInt32ToEnumFieldValue(newMap(2, 1000)); // unknown value.
+ TestMap source = sourceBuilder.build();
+
+ TestMap.Builder destinationBuilder = TestMap.newBuilder();
+ destinationBuilder.putAllInt32ToEnumFieldValue(source.getInt32ToEnumFieldValue());
+ TestMap destination = destinationBuilder.build();
+
+ assertEquals(0, destination.getInt32ToEnumFieldValue().get(0).intValue());
+ assertEquals(1, destination.getInt32ToEnumFieldValue().get(1).intValue());
+ assertEquals(1000, destination.getInt32ToEnumFieldValue().get(2).intValue());
+ assertEquals(3, destination.getInt32ToEnumFieldCount());
+ }
+
+ public void testPutForUnknownEnumValues() throws Exception {
+ TestMap.Builder builder =
+ TestMap.newBuilder()
+ .putInt32ToEnumFieldValue(0, 0)
+ .putInt32ToEnumFieldValue(1, 1)
+ .putInt32ToEnumFieldValue(2, 1000); // unknown value.
+ TestMap message = builder.build();
+
+ assertEquals(0, message.getInt32ToEnumFieldValueOrThrow(0));
+ assertEquals(1, message.getInt32ToEnumFieldValueOrThrow(1));
+ assertEquals(1000, message.getInt32ToEnumFieldValueOrThrow(2));
+ assertEquals(3, message.getInt32ToEnumFieldCount());
+ }
+
+ public void testPutChecksNullKeysAndValues() throws Exception {
+ TestMap.Builder builder = TestMap.newBuilder();
+
+ try {
+ builder.putInt32ToStringField(1, null);
+ fail();
+ } catch (NullPointerException e) {
+ // expected.
+ }
+
+ try {
+ builder.putInt32ToBytesField(1, null);
+ fail();
+ } catch (NullPointerException e) {
+ // expected.
+ }
+
+ try {
+ builder.putInt32ToEnumField(1, null);
+ fail();
+ } catch (NullPointerException e) {
+ // expected.
+ }
+
+ try {
+ builder.putInt32ToMessageField(1, null);
+ fail();
+ } catch (NullPointerException e) {
+ // expected.
+ }
+
+ try {
+ builder.putStringToInt32Field(null, 1);
+ fail();
+ } catch (NullPointerException e) {
+ // expected.
+ }
+ }
+
+ public void testSerializeAndParse() throws Exception {
+ TestMap.Builder builder = TestMap.newBuilder();
+ setMapValues(builder);
+ TestMap message = builder.build();
+ assertEquals(message.getSerializedSize(), message.toByteString().size());
+ message = TestMap.parser().parseFrom(message.toByteString());
+ assertMapValuesSet(message);
+
+ builder = message.toBuilder();
+ updateMapValues(builder);
+ message = builder.build();
+ assertEquals(message.getSerializedSize(), message.toByteString().size());
+ message = TestMap.parser().parseFrom(message.toByteString());
+ assertMapValuesUpdated(message);
+
+ builder = message.toBuilder();
+ builder.clear();
+ message = builder.build();
+ assertEquals(message.getSerializedSize(), message.toByteString().size());
+ message = TestMap.parser().parseFrom(message.toByteString());
+ assertMapValuesCleared(message);
+ }
+
+ private TestMap tryParseTestMap(BizarroTestMap bizarroMap) throws IOException {
+ ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+ CodedOutputStream output = CodedOutputStream.newInstance(byteArrayOutputStream);
+ bizarroMap.writeTo(output);
+ output.flush();
+ return TestMap.parser().parseFrom(ByteString.copyFrom(byteArrayOutputStream.toByteArray()));
+ }
+
+ public void testParseError() throws Exception {
+ ByteString bytes = TestUtil.toBytes("SOME BYTES");
+ String stringKey = "a string key";
+
+ TestMap map =
+ tryParseTestMap(BizarroTestMap.newBuilder().putInt32ToInt32Field(5, bytes).build());
+ assertEquals(0, map.getInt32ToInt32FieldOrDefault(5, -1));
+
+ map = tryParseTestMap(BizarroTestMap.newBuilder().putInt32ToStringField(stringKey, 5).build());
+ assertEquals("", map.getInt32ToStringFieldOrDefault(0, null));
+
+ map = tryParseTestMap(BizarroTestMap.newBuilder().putInt32ToBytesField(stringKey, 5).build());
+ assertEquals(map.getInt32ToBytesFieldOrDefault(0, null), ByteString.EMPTY);
+
+ map =
+ tryParseTestMap(BizarroTestMap.newBuilder().putInt32ToEnumField(stringKey, bytes).build());
+ assertEquals(TestMap.EnumValue.FOO, map.getInt32ToEnumFieldOrDefault(0, null));
+
+ try {
+ tryParseTestMap(BizarroTestMap.newBuilder().putInt32ToMessageField(stringKey, bytes).build());
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ assertTrue(expected.getUnfinishedMessage() instanceof TestMap);
+ map = (TestMap) expected.getUnfinishedMessage();
+ assertTrue(map.getInt32ToMessageField().isEmpty());
+ }
+
+ map =
+ tryParseTestMap(
+ BizarroTestMap.newBuilder().putStringToInt32Field(stringKey, bytes).build());
+ assertEquals(0, map.getStringToInt32FieldOrDefault(stringKey, -1));
+ }
+
+ public void testMergeFrom() throws Exception {
+ TestMap.Builder builder = TestMap.newBuilder();
+ setMapValues(builder);
+ TestMap message = builder.build();
+
+ TestMap.Builder other = TestMap.newBuilder();
+ other.mergeFrom(message);
+ assertMapValuesSet(other.build());
+ }
+
+ public void testEqualsAndHashCode() throws Exception {
+ // Test that generated equals() and hashCode() will disregard the order
+ // of map entries when comparing/hashing map fields.
+
+ // We can't control the order of elements in a HashMap. The best we can do
+ // here is to add elements in different order.
+ TestMap.Builder b1 =
+ TestMap.newBuilder()
+ .putInt32ToInt32Field(1, 2)
+ .putInt32ToInt32Field(3, 4)
+ .putInt32ToInt32Field(5, 6);
+ TestMap m1 = b1.build();
+
+ TestMap.Builder b2 =
+ TestMap.newBuilder()
+ .putInt32ToInt32Field(5, 6)
+ .putInt32ToInt32Field(1, 2)
+ .putInt32ToInt32Field(3, 4);
+ TestMap m2 = b2.build();
+
+ assertEquals(m1, m2);
+ assertEquals(m1.hashCode(), m2.hashCode());
+
+ // Make sure we did compare map fields.
+ b2.putInt32ToInt32Field(1, 0);
+ m2 = b2.build();
+ assertFalse(m1.equals(m2));
+ // Don't check m1.hashCode() != m2.hashCode() because it's not guaranteed
+ // to be different.
+
+ // Regression test for b/18549190: if a map is a subset of the other map,
+ // equals() should return false.
+ b2.removeInt32ToInt32Field(1);
+ m2 = b2.build();
+ assertFalse(m1.equals(m2));
+ assertFalse(m2.equals(m1));
+ }
+
+ public void testUnknownEnumValues() throws Exception {
+ TestMap.Builder builder =
+ TestMap.newBuilder()
+ .putInt32ToEnumFieldValue(0, 0)
+ .putInt32ToEnumFieldValue(1, 1)
+ .putInt32ToEnumFieldValue(2, 1000); // unknown value.
+ TestMap message = builder.build();
+
+ assertEquals(TestMap.EnumValue.FOO, message.getInt32ToEnumField().get(0));
+ assertEquals(TestMap.EnumValue.BAR, message.getInt32ToEnumField().get(1));
+ assertEquals(TestMap.EnumValue.UNRECOGNIZED, message.getInt32ToEnumField().get(2));
+
+ builder.putAllInt32ToEnumFieldValue(newMap(2, 1000)); // unknown value.
+ message = builder.build();
+ assertEquals(TestMap.EnumValue.UNRECOGNIZED, message.getInt32ToEnumField().get(2));
+
+ // Unknown enum values should be preserved after:
+ // 1. Serialization and parsing.
+ // 2. toBuild().
+ // 3. mergeFrom().
+ message = TestMap.parseFrom(message.toByteString());
+ assertEquals(1000, message.getInt32ToEnumFieldValue().get(2).intValue());
+ builder = message.toBuilder();
+ assertEquals(1000, builder.getInt32ToEnumFieldValue().get(2).intValue());
+ builder = TestMap.newBuilder().mergeFrom(message);
+ assertEquals(1000, builder.getInt32ToEnumFieldValue().get(2).intValue());
+
+ // hashCode()/equals() should take unknown enum values into account.
+ builder.putAllInt32ToEnumFieldValue(newMap(2, 1001));
+ TestMap message2 = builder.build();
+ assertFalse(message.hashCode() == message2.hashCode());
+ assertFalse(message.equals(message2));
+ // Unknown values will be converted to UNRECOGNIZED so the resulted enum map
+ // should be the same.
+ assertEquals(message2.getInt32ToEnumField(), message.getInt32ToEnumField());
+ }
+
+ public void testIterationOrder() throws Exception {
+ TestMap.Builder builder = TestMap.newBuilder();
+ setMapValues(builder);
+ TestMap message = builder.build();
+
+ assertEquals(
+ Arrays.asList("1", "2", "3"), new ArrayList<>(message.getStringToInt32Field().keySet()));
+ }
+
+ public void testGetMap() {
+ TestMap.Builder builder = TestMap.newBuilder();
+ setMapValues(builder);
+ TestMap message = builder.build();
+ assertEquals(message.getStringToInt32Field(), message.getStringToInt32FieldMap());
+ assertEquals(message.getInt32ToBytesField(), message.getInt32ToBytesFieldMap());
+ assertEquals(message.getInt32ToEnumField(), message.getInt32ToEnumFieldMap());
+ assertEquals(message.getInt32ToEnumFieldValue(), message.getInt32ToEnumFieldValueMap());
+ assertEquals(message.getInt32ToMessageField(), message.getInt32ToMessageFieldMap());
+ }
+
+ public void testContains() {
+ TestMap.Builder builder = TestMap.newBuilder();
+ setMapValues(builder);
+ assertMapContainsSetValues(builder);
+ assertMapContainsSetValues(builder.build());
+ }
+
+ private void assertMapContainsSetValues(TestMapOrBuilder testMapOrBuilder) {
+ assertTrue(testMapOrBuilder.containsInt32ToInt32Field(1));
+ assertTrue(testMapOrBuilder.containsInt32ToInt32Field(2));
+ assertTrue(testMapOrBuilder.containsInt32ToInt32Field(3));
+ assertFalse(testMapOrBuilder.containsInt32ToInt32Field(-1));
+
+ assertTrue(testMapOrBuilder.containsInt32ToStringField(1));
+ assertTrue(testMapOrBuilder.containsInt32ToStringField(2));
+ assertTrue(testMapOrBuilder.containsInt32ToStringField(3));
+ assertFalse(testMapOrBuilder.containsInt32ToStringField(-1));
+
+ assertTrue(testMapOrBuilder.containsInt32ToBytesField(1));
+ assertTrue(testMapOrBuilder.containsInt32ToBytesField(2));
+ assertTrue(testMapOrBuilder.containsInt32ToBytesField(3));
+ assertFalse(testMapOrBuilder.containsInt32ToBytesField(-1));
+
+ assertTrue(testMapOrBuilder.containsInt32ToEnumField(1));
+ assertTrue(testMapOrBuilder.containsInt32ToEnumField(2));
+ assertTrue(testMapOrBuilder.containsInt32ToEnumField(3));
+ assertFalse(testMapOrBuilder.containsInt32ToEnumField(-1));
+
+ assertTrue(testMapOrBuilder.containsInt32ToMessageField(1));
+ assertTrue(testMapOrBuilder.containsInt32ToMessageField(2));
+ assertTrue(testMapOrBuilder.containsInt32ToMessageField(3));
+ assertFalse(testMapOrBuilder.containsInt32ToMessageField(-1));
+
+ assertTrue(testMapOrBuilder.containsStringToInt32Field("1"));
+ assertTrue(testMapOrBuilder.containsStringToInt32Field("2"));
+ assertTrue(testMapOrBuilder.containsStringToInt32Field("3"));
+ assertFalse(testMapOrBuilder.containsStringToInt32Field("-1"));
+ }
+
+ public void testCount() {
+ TestMap.Builder builder = TestMap.newBuilder();
+ assertMapCounts(0, builder);
+
+ setMapValues(builder);
+ assertMapCounts(3, builder);
+
+ TestMap message = builder.build();
+ assertMapCounts(3, message);
+
+ builder = message.toBuilder().putInt32ToInt32Field(4, 44);
+ assertEquals(4, builder.getInt32ToInt32FieldCount());
+ assertEquals(4, builder.build().getInt32ToInt32FieldCount());
+
+ // already present - should be unchanged
+ builder.putInt32ToInt32Field(4, 44);
+ assertEquals(4, builder.getInt32ToInt32FieldCount());
+ }
+
+ private void assertMapCounts(int expectedCount, TestMapOrBuilder testMapOrBuilder) {
+ assertEquals(expectedCount, testMapOrBuilder.getInt32ToInt32FieldCount());
+ assertEquals(expectedCount, testMapOrBuilder.getInt32ToStringFieldCount());
+ assertEquals(expectedCount, testMapOrBuilder.getInt32ToBytesFieldCount());
+ assertEquals(expectedCount, testMapOrBuilder.getInt32ToEnumFieldCount());
+ assertEquals(expectedCount, testMapOrBuilder.getInt32ToMessageFieldCount());
+ assertEquals(expectedCount, testMapOrBuilder.getStringToInt32FieldCount());
+ }
+
+ public void testGetOrDefault() {
+ TestMap.Builder builder = TestMap.newBuilder();
+ assertMapCounts(0, builder);
+ setMapValues(builder);
+ doTestGetOrDefault(builder);
+ doTestGetOrDefault(builder.build());
+ }
+
+ public void doTestGetOrDefault(TestMapOrBuilder testMapOrBuilder) {
+ assertEquals(11, testMapOrBuilder.getInt32ToInt32FieldOrDefault(1, -11));
+ assertEquals(-11, testMapOrBuilder.getInt32ToInt32FieldOrDefault(-1, -11));
+
+ assertEquals("11", testMapOrBuilder.getInt32ToStringFieldOrDefault(1, "-11"));
+ assertNull("-11", testMapOrBuilder.getInt32ToStringFieldOrDefault(-1, null));
+
+ assertEquals(TestUtil.toBytes("11"), testMapOrBuilder.getInt32ToBytesFieldOrDefault(1, null));
+ assertNull(testMapOrBuilder.getInt32ToBytesFieldOrDefault(-1, null));
+
+ assertEquals(TestMap.EnumValue.FOO, testMapOrBuilder.getInt32ToEnumFieldOrDefault(1, null));
+ assertNull(testMapOrBuilder.getInt32ToEnumFieldOrDefault(-1, null));
+
+ assertEquals(
+ TestMap.EnumValue.BAR.getNumber(),
+ testMapOrBuilder.getInt32ToEnumFieldValueOrDefault(2, -1));
+ assertEquals(-1, testMapOrBuilder.getInt32ToEnumFieldValueOrDefault(-1000, -1));
+
+ assertEquals(
+ MessageValue.newBuilder().setValue(11).build(),
+ testMapOrBuilder.getInt32ToMessageFieldOrDefault(1, null));
+ assertNull(testMapOrBuilder.getInt32ToMessageFieldOrDefault(-1, null));
+
+ assertEquals(11, testMapOrBuilder.getStringToInt32FieldOrDefault("1", -11));
+ assertEquals(-11, testMapOrBuilder.getStringToInt32FieldOrDefault("-1", -11));
+
+ try {
+ testMapOrBuilder.getStringToInt32FieldOrDefault(null, -11);
+ fail();
+ } catch (NullPointerException e) {
+ // expected
+ }
+ }
+
+ public void testGetOrThrow() {
+ TestMap.Builder builder = TestMap.newBuilder();
+ assertMapCounts(0, builder);
+ setMapValues(builder);
+ doTestGetOrDefault(builder);
+ doTestGetOrDefault(builder.build());
+ }
+
+ public void doTestGetOrThrow(TestMapOrBuilder testMapOrBuilder) {
+ assertEquals(11, testMapOrBuilder.getInt32ToInt32FieldOrThrow(1));
+ try {
+ testMapOrBuilder.getInt32ToInt32FieldOrThrow(-1);
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected
+ }
+
+ assertEquals("11", testMapOrBuilder.getInt32ToStringFieldOrThrow(1));
+
+ try {
+ testMapOrBuilder.getInt32ToStringFieldOrThrow(-1);
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected
+ }
+
+ assertEquals(TestUtil.toBytes("11"), testMapOrBuilder.getInt32ToBytesFieldOrThrow(1));
+
+ try {
+ testMapOrBuilder.getInt32ToBytesFieldOrThrow(-1);
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected
+ }
+
+ assertEquals(TestMap.EnumValue.FOO, testMapOrBuilder.getInt32ToEnumFieldOrThrow(1));
+ try {
+ testMapOrBuilder.getInt32ToEnumFieldOrThrow(-1);
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected
+ }
+
+ assertEquals(
+ TestMap.EnumValue.BAR.getNumber(), testMapOrBuilder.getInt32ToEnumFieldValueOrThrow(2));
+ try {
+ testMapOrBuilder.getInt32ToEnumFieldValueOrThrow(-1);
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected
+ }
+
+ assertEquals(
+ MessageValue.newBuilder().setValue(11).build(),
+ testMapOrBuilder.getInt32ToMessageFieldOrThrow(1));
+ try {
+ testMapOrBuilder.getInt32ToMessageFieldOrThrow(-1);
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected
+ }
+
+ assertEquals(11, testMapOrBuilder.getStringToInt32FieldOrThrow("1"));
+ try {
+ testMapOrBuilder.getStringToInt32FieldOrThrow("-1");
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected
+ }
+
+ try {
+ testMapOrBuilder.getStringToInt32FieldOrThrow(null);
+ fail();
+ } catch (NullPointerException e) {
+ // expected
+ }
+ }
+
+ public void testPut() {
+ TestMap.Builder builder = TestMap.newBuilder();
+ builder.putInt32ToInt32Field(1, 11);
+ assertEquals(11, builder.getInt32ToInt32FieldOrThrow(1));
+
+ builder.putInt32ToStringField(1, "a");
+ assertEquals("a", builder.getInt32ToStringFieldOrThrow(1));
+ try {
+ builder.putInt32ToStringField(1, null);
+ fail();
+ } catch (NullPointerException e) {
+ // expected
+ }
+
+ builder.putInt32ToBytesField(1, TestUtil.toBytes("11"));
+ assertEquals(TestUtil.toBytes("11"), builder.getInt32ToBytesFieldOrThrow(1));
+ try {
+ builder.putInt32ToBytesField(1, null);
+ fail();
+ } catch (NullPointerException e) {
+ // expected
+ }
+
+ builder.putInt32ToEnumField(1, TestMap.EnumValue.FOO);
+ assertEquals(TestMap.EnumValue.FOO, builder.getInt32ToEnumFieldOrThrow(1));
+ try {
+ builder.putInt32ToEnumField(1, null);
+ fail();
+ } catch (NullPointerException e) {
+ // expected
+ }
+
+ builder.putStringToInt32Field("a", 1);
+ assertEquals(1, builder.getStringToInt32FieldOrThrow("a"));
+ try {
+ builder.putStringToInt32Field(null, -1);
+ } catch (NullPointerException e) {
+ // expected
+ }
+ }
+
+ public void testRemove() {
+ TestMap.Builder builder = TestMap.newBuilder();
+ setMapValues(builder);
+ assertEquals(11, builder.getInt32ToInt32FieldOrThrow(1));
+ for (int times = 0; times < 2; times++) {
+ builder.removeInt32ToInt32Field(1);
+ assertEquals(-1, builder.getInt32ToInt32FieldOrDefault(1, -1));
+ }
+
+ assertEquals("11", builder.getInt32ToStringFieldOrThrow(1));
+ for (int times = 0; times < 2; times++) {
+ builder.removeInt32ToStringField(1);
+ assertNull(builder.getInt32ToStringFieldOrDefault(1, null));
+ }
+
+ assertEquals(TestUtil.toBytes("11"), builder.getInt32ToBytesFieldOrThrow(1));
+ for (int times = 0; times < 2; times++) {
+ builder.removeInt32ToBytesField(1);
+ assertNull(builder.getInt32ToBytesFieldOrDefault(1, null));
+ }
+
+ assertEquals(TestMap.EnumValue.FOO, builder.getInt32ToEnumFieldOrThrow(1));
+ for (int times = 0; times < 2; times++) {
+ builder.removeInt32ToEnumField(1);
+ assertNull(builder.getInt32ToEnumFieldOrDefault(1, null));
+ }
+
+ assertEquals(11, builder.getStringToInt32FieldOrThrow("1"));
+ for (int times = 0; times < 2; times++) {
+ builder.removeStringToInt32Field("1");
+ assertEquals(-1, builder.getStringToInt32FieldOrDefault("1", -1));
+ }
+
+ try {
+ builder.removeStringToInt32Field(null);
+ fail();
+ } catch (NullPointerException e) {
+ // expected
+ }
+ }
+
+ private static <K, V> Map<K, V> newMap(K key1, V value1) {
+ Map<K, V> map = new HashMap<>();
+ map.put(key1, value1);
+ return map;
+ }
+
+ private static <K, V> Map<K, V> newMap(K key1, V value1, K key2, V value2) {
+ Map<K, V> map = new HashMap<>();
+ map.put(key1, value1);
+ map.put(key2, value2);
+ return map;
+ }
+
+ public void testMap_withNulls() {
+ TestMap.Builder builder = TestMap.newBuilder();
+
+ try {
+ builder.putStringToInt32Field(null, 3);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+
+ try {
+ builder.putAllStringToInt32Field(newMap(null, 3, "hi", 4));
+ fail();
+ } catch (NullPointerException expected) {
+ }
+
+ try {
+ builder.putInt32ToMessageField(3, null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+
+ try {
+ builder.putAllInt32ToMessageField(
+ MapLiteTest.<Integer, MessageValue>newMap(4, null, 5, null));
+ fail();
+ } catch (NullPointerException expected) {
+ }
+
+ try {
+ builder.putAllInt32ToMessageField(null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+
+ assertArrayEquals(new byte[0], builder.build().toByteArray());
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/PackedFieldTest.java b/java/core/src/test/java/com/google/protobuf/PackedFieldTest.java
new file mode 100755
index 0000000..2397d2e
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/PackedFieldTest.java
@@ -0,0 +1,232 @@
+// 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.PackedFieldTestProto.TestAllTypes;
+import com.google.protobuf.PackedFieldTestProto.TestAllTypes.NestedEnum;
+import com.google.protobuf.PackedFieldTestProto.TestUnpackedTypes;
+import junit.framework.TestCase;
+
+/** Tests primitive repeated fields in proto3 are packed in wire format. */
+public class PackedFieldTest extends TestCase {
+ static final ByteString expectedPackedRawBytes =
+ ByteString.copyFrom(
+ new byte[] {
+ (byte) 0xFA,
+ 0x01,
+ 0x01,
+ 0x01, // repeated int32
+ (byte) 0x82,
+ 0x02,
+ 0x01,
+ 0x01, // repeated int64
+ (byte) 0x8A,
+ 0x02,
+ 0x01,
+ 0x01, // repeated uint32
+ (byte) 0x92,
+ 0x02,
+ 0x01,
+ 0x01, // repeated uint64
+ (byte) 0x9A,
+ 0x02,
+ 0x01,
+ 0x02, // repeated sint32
+ (byte) 0xA2,
+ 0x02,
+ 0x01,
+ 0x02, // repeated sint64
+ (byte) 0xAA,
+ 0x02,
+ 0x04,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00, // repeated fixed32
+ (byte) 0xB2,
+ 0x02,
+ 0x08,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00, // repeated fixed64
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ (byte) 0xBA,
+ 0x02,
+ 0x04,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00, // repeated sfixed32
+ (byte) 0xC2,
+ 0x02,
+ 0x08,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00, // repeated sfixed64
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ (byte) 0xCA,
+ 0x02,
+ 0x04,
+ 0x00,
+ 0x00,
+ (byte) 0x80,
+ 0x3f, // repeated float
+ (byte) 0xD2,
+ 0x02,
+ 0x08,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00, // repeated double
+ 0x00,
+ 0x00,
+ (byte) 0xf0,
+ 0x3f,
+ (byte) 0xDA,
+ 0x02,
+ 0x01,
+ 0x01, // repeated bool
+ (byte) 0x9A,
+ 0x03,
+ 0x01,
+ 0x01 // repeated nested enum
+ });
+
+ static final ByteString expectedUnpackedRawBytes =
+ ByteString.copyFrom(
+ new byte[] {
+ 0x08,
+ 0x01, // repeated int32
+ 0x10,
+ 0x01, // repeated int64
+ 0x18,
+ 0x01, // repeated uint32
+ 0x20,
+ 0x01, // repeated uint64
+ 0x28,
+ 0x02, // repeated sint32
+ 0x30,
+ 0x02, // repeated sint64
+ 0x3D,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00, // repeated fixed32
+ 0x41,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00, // repeated fixed64
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x4D,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00, // repeated sfixed32
+ 0x51,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00, // repeated sfixed64
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x5D,
+ 0x00,
+ 0x00,
+ (byte) 0x80,
+ 0x3f, // repeated float
+ 0x61,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00, // repeated double
+ 0x00,
+ 0x00,
+ (byte) 0xf0,
+ 0x3f,
+ 0x68,
+ 0x01, // repeated bool
+ 0x70,
+ 0x01, // repeated nested enum
+ });
+
+ public void testPackedGeneratedMessage() throws Exception {
+ TestAllTypes message = TestAllTypes.parseFrom(expectedPackedRawBytes);
+ assertEquals(expectedPackedRawBytes, message.toByteString());
+ }
+
+ public void testPackedDynamicMessageSerialize() throws Exception {
+ DynamicMessage message =
+ DynamicMessage.parseFrom(TestAllTypes.getDescriptor(), expectedPackedRawBytes);
+ assertEquals(expectedPackedRawBytes, message.toByteString());
+ }
+
+ public void testUnpackedGeneratedMessage() throws Exception {
+ TestUnpackedTypes message = TestUnpackedTypes.parseFrom(expectedUnpackedRawBytes);
+ assertEquals(expectedUnpackedRawBytes, message.toByteString());
+ }
+
+ public void testUnPackedDynamicMessageSerialize() throws Exception {
+ DynamicMessage message =
+ DynamicMessage.parseFrom(TestUnpackedTypes.getDescriptor(), expectedUnpackedRawBytes);
+ assertEquals(expectedUnpackedRawBytes, message.toByteString());
+ }
+
+ // Make sure we haven't screwed up the code generation for packing fields by default.
+ public void testPackedSerialization() throws Exception {
+ TestAllTypes message =
+ TestAllTypes.newBuilder()
+ .addRepeatedInt32(1234)
+ .addRepeatedNestedEnum(NestedEnum.BAR)
+ .build();
+
+ CodedInputStream in = CodedInputStream.newInstance(message.toByteArray());
+
+ while (!in.isAtEnd()) {
+ int tag = in.readTag();
+ assertEquals(WireFormat.WIRETYPE_LENGTH_DELIMITED, WireFormat.getTagWireType(tag));
+ in.skipField(tag);
+ }
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/ParserLiteTest.java b/java/core/src/test/java/com/google/protobuf/ParserLiteTest.java
new file mode 100755
index 0000000..eb2dc3d
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/ParserLiteTest.java
@@ -0,0 +1,191 @@
+// 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.UnittestLite.TestAllTypesLite;
+import com.google.protobuf.UnittestLite.TestPackedExtensionsLite;
+import com.google.protobuf.UnittestLite.TestParsingMergeLite;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import junit.framework.TestCase;
+
+public class ParserLiteTest extends TestCase {
+ private void assertRoundTripEquals(MessageLite message, ExtensionRegistryLite registry)
+ throws Exception {
+ final byte[] data = message.toByteArray();
+ final int offset = 20;
+ final int length = data.length;
+ final int padding = 30;
+ Parser<? extends MessageLite> parser = message.getParserForType();
+ assertEquals(message, parser.parseFrom(data, registry));
+ assertEquals(
+ message,
+ parser.parseFrom(generatePaddingArray(data, offset, padding), offset, length, registry));
+ assertEquals(message, parser.parseFrom(message.toByteString(), registry));
+ assertEquals(message, parser.parseFrom(new ByteArrayInputStream(data), registry));
+ assertEquals(message, parser.parseFrom(CodedInputStream.newInstance(data), registry));
+ assertEquals(
+ message, parser.parseFrom(message.toByteString().asReadOnlyByteBuffer(), registry));
+ }
+
+ @SuppressWarnings("unchecked")
+ private void assertRoundTripEquals(MessageLite message) throws Exception {
+ final byte[] data = message.toByteArray();
+ final int offset = 20;
+ final int length = data.length;
+ final int padding = 30;
+
+ Parser<MessageLite> parser = (Parser<MessageLite>) message.getParserForType();
+ assertEquals(message, parser.parseFrom(data));
+ assertEquals(
+ message, parser.parseFrom(generatePaddingArray(data, offset, padding), offset, length));
+ assertEquals(message, parser.parseFrom(message.toByteString()));
+ assertEquals(message, parser.parseFrom(new ByteArrayInputStream(data)));
+ assertEquals(message, parser.parseFrom(CodedInputStream.newInstance(data)));
+ assertEquals(message, parser.parseFrom(message.toByteString().asReadOnlyByteBuffer()));
+ }
+
+ private byte[] generatePaddingArray(byte[] data, int offset, int padding) {
+ byte[] result = new byte[offset + data.length + padding];
+ System.arraycopy(data, 0, result, offset, data.length);
+ return result;
+ }
+
+ public void testParseExtensionsLite() throws Exception {
+ assertRoundTripEquals(
+ TestUtilLite.getAllLiteExtensionsSet(), TestUtilLite.getExtensionRegistryLite());
+ }
+
+ public void testParsePacked() throws Exception {
+ assertRoundTripEquals(TestUtil.getPackedSet());
+ assertRoundTripEquals(TestUtil.getPackedExtensionsSet(), TestUtil.getExtensionRegistry());
+ }
+
+ public void testParsePackedLite() throws Exception {
+ assertRoundTripEquals(
+ TestUtilLite.getLitePackedExtensionsSet(), TestUtilLite.getExtensionRegistryLite());
+ }
+
+ public void testParseDelimitedToLite() throws Exception {
+ // Write MessageLite with packed extension fields.
+ TestPackedExtensionsLite packedMessage = TestUtilLite.getLitePackedExtensionsSet();
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ packedMessage.writeDelimitedTo(output);
+ packedMessage.writeDelimitedTo(output);
+
+ InputStream input = new ByteArrayInputStream(output.toByteArray());
+ assertEquals(
+ packedMessage,
+ packedMessage
+ .getParserForType()
+ .parseDelimitedFrom(input, TestUtilLite.getExtensionRegistryLite()));
+ assertEquals(
+ packedMessage,
+ packedMessage
+ .getParserForType()
+ .parseDelimitedFrom(input, TestUtilLite.getExtensionRegistryLite()));
+ }
+
+ /** Helper method for {@link #testParsingMergeLite()}. */
+ private void assertMessageMerged(TestAllTypesLite allTypes) throws Exception {
+ assertEquals(3, allTypes.getOptionalInt32());
+ assertEquals(2, allTypes.getOptionalInt64());
+ assertEquals("hello", allTypes.getOptionalString());
+ }
+
+ public void testParsingMergeLite() throws Exception {
+ // Build messages.
+ TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder();
+ TestAllTypesLite msg1 = builder.setOptionalInt32(1).build();
+ builder.clear();
+ TestAllTypesLite msg2 = builder.setOptionalInt64(2).build();
+ builder.clear();
+ TestAllTypesLite msg3 = builder.setOptionalInt32(3).setOptionalString("hello").build();
+
+ // Build groups.
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group1 optionalG1 =
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group1.newBuilder().setField1(msg1).build();
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group1 optionalG2 =
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group1.newBuilder().setField1(msg2).build();
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group1 optionalG3 =
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group1.newBuilder().setField1(msg3).build();
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group2 repeatedG1 =
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group2.newBuilder().setField1(msg1).build();
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group2 repeatedG2 =
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group2.newBuilder().setField1(msg2).build();
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group2 repeatedG3 =
+ TestParsingMergeLite.RepeatedFieldsGenerator.Group2.newBuilder().setField1(msg3).build();
+
+ // Assign and serialize RepeatedFieldsGenerator.
+ ByteString data =
+ TestParsingMergeLite.RepeatedFieldsGenerator.newBuilder()
+ .addField1(msg1)
+ .addField1(msg2)
+ .addField1(msg3)
+ .addField2(msg1)
+ .addField2(msg2)
+ .addField2(msg3)
+ .addField3(msg1)
+ .addField3(msg2)
+ .addField3(msg3)
+ .addGroup1(optionalG1)
+ .addGroup1(optionalG2)
+ .addGroup1(optionalG3)
+ .addGroup2(repeatedG1)
+ .addGroup2(repeatedG2)
+ .addGroup2(repeatedG3)
+ .addExt1(msg1)
+ .addExt1(msg2)
+ .addExt1(msg3)
+ .addExt2(msg1)
+ .addExt2(msg2)
+ .addExt2(msg3)
+ .build()
+ .toByteString();
+
+ // Parse TestParsingMergeLite.
+ ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
+ UnittestLite.registerAllExtensions(registry);
+ TestParsingMergeLite parsingMerge = TestParsingMergeLite.parser().parseFrom(data, registry);
+
+ // Required and optional fields should be merged.
+ assertMessageMerged(parsingMerge.getRequiredAllTypes());
+ assertMessageMerged(parsingMerge.getOptionalAllTypes());
+ assertMessageMerged(parsingMerge.getOptionalGroup().getOptionalGroupAllTypes());
+ assertMessageMerged(parsingMerge.getExtension(TestParsingMergeLite.optionalExt));
+
+ // Repeated fields should not be merged.
+ assertEquals(3, parsingMerge.getRepeatedAllTypesCount());
+ assertEquals(3, parsingMerge.getRepeatedGroupCount());
+ assertEquals(3, parsingMerge.getExtensionCount(TestParsingMergeLite.repeatedExt));
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto2ExtensionLookupSchemaTest.java b/java/core/src/test/java/com/google/protobuf/Proto2ExtensionLookupSchemaTest.java
new file mode 100755
index 0000000..dfda4b3
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto2ExtensionLookupSchemaTest.java
@@ -0,0 +1,171 @@
+// 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 org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+
+import com.google.protobuf.testing.Proto2Testing;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message.TestEnum;
+import com.google.protobuf.testing.Proto2Testing.Proto2MessageWithExtensions;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class Proto2ExtensionLookupSchemaTest {
+ private byte[] data;
+ private ExtensionRegistry extensionRegistry;
+
+ @Before
+ public void setup() {
+ TestSchemas.registerGenericProto2Schemas();
+
+ Protobuf.getInstance().schemaFor(Proto2MessageWithExtensions.class);
+ data = new Proto2MessageFactory(10, 20, 1, 1).newMessage().toByteArray();
+ extensionRegistry = ExtensionRegistry.newInstance();
+ Proto2Testing.registerAllExtensions(extensionRegistry);
+ }
+
+ @Test
+ public void testExtensions() throws Exception {
+ Proto2MessageWithExtensions base =
+ Proto2MessageWithExtensions.parseFrom(data, extensionRegistry);
+
+ Proto2MessageWithExtensions message =
+ ExperimentalSerializationUtil.fromByteArray(
+ data, Proto2MessageWithExtensions.class, extensionRegistry);
+ assertEquals(base, message);
+
+ Proto2MessageWithExtensions roundtripMessage =
+ ExperimentalSerializationUtil.fromByteArray(
+ ExperimentalSerializationUtil.toByteArray(message),
+ Proto2MessageWithExtensions.class,
+ extensionRegistry);
+ assertEquals(base, roundtripMessage);
+ }
+
+ @Test
+ public void testUnknownEnum() throws Exception {
+ // Use unknown fields to hold invalid enum values.
+ UnknownFieldSetLite unknowns = UnknownFieldSetLite.newInstance();
+ final int outOfRange = 1000;
+ assertNull(TestEnum.forNumber(outOfRange));
+ unknowns.storeField(
+ WireFormat.makeTag(Proto2Message.FIELD_ENUM_13_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) outOfRange);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2Message.FIELD_ENUM_LIST_30_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) TestEnum.ONE_VALUE);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2Message.FIELD_ENUM_LIST_30_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) outOfRange);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2Message.FIELD_ENUM_LIST_30_FIELD_NUMBER, WireFormat.WIRETYPE_VARINT),
+ (long) TestEnum.TWO_VALUE);
+
+ {
+ // Construct a packed enum list.
+ int packedSize =
+ CodedOutputStream.computeUInt32SizeNoTag(TestEnum.ONE_VALUE)
+ + CodedOutputStream.computeUInt32SizeNoTag(outOfRange)
+ + CodedOutputStream.computeUInt32SizeNoTag(TestEnum.ONE_VALUE);
+ ByteString.CodedBuilder packedBuilder = ByteString.newCodedBuilder(packedSize);
+ CodedOutputStream packedOut = packedBuilder.getCodedOutput();
+ packedOut.writeEnumNoTag(TestEnum.ONE_VALUE);
+ packedOut.writeEnumNoTag(outOfRange);
+ packedOut.writeEnumNoTag(TestEnum.TWO_VALUE);
+ unknowns.storeField(
+ WireFormat.makeTag(
+ Proto2Message.FIELD_ENUM_LIST_PACKED_44_FIELD_NUMBER,
+ WireFormat.WIRETYPE_LENGTH_DELIMITED),
+ packedBuilder.build());
+ }
+ int size = unknowns.getSerializedSize();
+ byte[] output = new byte[size];
+ CodedOutputStream codedOutput = CodedOutputStream.newInstance(output);
+ unknowns.writeTo(codedOutput);
+ codedOutput.flush();
+
+ Proto2MessageWithExtensions parsed =
+ ExperimentalSerializationUtil.fromByteArray(
+ output, Proto2MessageWithExtensions.class, extensionRegistry);
+ assertFalse(
+ "out-of-range singular enum should not be in message",
+ parsed.hasExtension(Proto2Testing.fieldEnum13));
+ {
+ List<Long> singularEnum =
+ parsed
+ .getUnknownFields()
+ .getField(Proto2Message.FIELD_ENUM_13_FIELD_NUMBER)
+ .getVarintList();
+ assertEquals(1, singularEnum.size());
+ assertEquals((Long) (long) outOfRange, singularEnum.get(0));
+ }
+ {
+ List<Long> repeatedEnum =
+ parsed
+ .getUnknownFields()
+ .getField(Proto2Message.FIELD_ENUM_LIST_30_FIELD_NUMBER)
+ .getVarintList();
+ assertEquals(1, repeatedEnum.size());
+ assertEquals((Long) (long) outOfRange, repeatedEnum.get(0));
+ }
+ {
+ List<Long> packedRepeatedEnum =
+ parsed
+ .getUnknownFields()
+ .getField(Proto2Message.FIELD_ENUM_LIST_PACKED_44_FIELD_NUMBER)
+ .getVarintList();
+ assertEquals(1, packedRepeatedEnum.size());
+ assertEquals((Long) (long) outOfRange, packedRepeatedEnum.get(0));
+ }
+ assertEquals(
+ "out-of-range repeated enum should not be in message",
+ 2,
+ parsed.getExtension(Proto2Testing.fieldEnumList30).size());
+ assertEquals(TestEnum.ONE, parsed.getExtension(Proto2Testing.fieldEnumList30, 0));
+ assertEquals(TestEnum.TWO, parsed.getExtension(Proto2Testing.fieldEnumList30, 1));
+ assertEquals(
+ "out-of-range packed repeated enum should not be in message",
+ 2,
+ parsed.getExtension(Proto2Testing.fieldEnumListPacked44).size());
+ assertEquals(TestEnum.ONE, parsed.getExtension(Proto2Testing.fieldEnumListPacked44, 0));
+ assertEquals(TestEnum.TWO, parsed.getExtension(Proto2Testing.fieldEnumListPacked44, 1));
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto2LiteSchemaTest.java b/java/core/src/test/java/com/google/protobuf/Proto2LiteSchemaTest.java
new file mode 100755
index 0000000..8242f84
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto2LiteSchemaTest.java
@@ -0,0 +1,49 @@
+// 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.testing.Proto2TestingLite.Proto2MessageLite;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class Proto2LiteSchemaTest extends AbstractProto2LiteSchemaTest {
+
+ @Override
+ protected Schema<Proto2MessageLite> schema() {
+ return TestSchemasLite.genericProto2LiteSchema;
+ }
+
+ @Override
+ protected void registerSchemas() {
+ TestSchemasLite.registerGenericProto2LiteSchemas();
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto2MessageFactory.java b/java/core/src/test/java/com/google/protobuf/Proto2MessageFactory.java
new file mode 100755
index 0000000..b5c61ed
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto2MessageFactory.java
@@ -0,0 +1,555 @@
+// 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.testing.Proto2Testing.Proto2Message;
+import com.google.protobuf.testing.Proto2Testing.Proto2MessageWithMaps;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/** Creates instances of {@link Proto2Message} based on the tree configuration. */
+public final class Proto2MessageFactory implements ExperimentalMessageFactory<Proto2Message> {
+ private final int numRepeatedFields;
+ private final int branchingFactor;
+ private final Proto2MessageFactory nextLevel;
+ private final ExperimentalTestDataProvider data;
+
+ public Proto2MessageFactory(
+ int numRepeatedFields, int stringLength, int branchingFactor, int treeDepth) {
+ this(
+ new ExperimentalTestDataProvider(stringLength),
+ numRepeatedFields,
+ branchingFactor,
+ treeDepth);
+ }
+
+ private Proto2MessageFactory(
+ ExperimentalTestDataProvider data,
+ int numRepeatedFields,
+ int branchingFactor,
+ int treeDepth) {
+ this.numRepeatedFields = numRepeatedFields;
+ this.branchingFactor = branchingFactor;
+ this.data = data;
+ if (treeDepth > 0) {
+ nextLevel = new Proto2MessageFactory(data, numRepeatedFields, branchingFactor, treeDepth - 1);
+ } else {
+ nextLevel = null;
+ }
+ }
+
+ @Override
+ public ExperimentalTestDataProvider dataProvider() {
+ return data;
+ }
+
+ @Override
+ public Proto2Message newMessage() {
+ Proto2Message.Builder builder = Proto2Message.newBuilder();
+ builder.setFieldDouble1(data.getDouble());
+ builder.setFieldFloat2(data.getFloat());
+ builder.setFieldInt643(data.getLong());
+ builder.setFieldUint644(data.getLong());
+ builder.setFieldInt325(data.getInt());
+ builder.setFieldFixed646(data.getLong());
+ builder.setFieldFixed327(data.getInt());
+ builder.setFieldBool8(data.getBool());
+ builder.setFieldString9(data.getString());
+ // We don't populate the message field. Instead we apply the branching factor to the
+ // repeated message field below.
+ builder.setFieldBytes11(data.getBytes());
+ builder.setFieldUint3212(data.getInt());
+ builder.setFieldEnum13(Proto2Message.TestEnum.forNumber(data.getEnum()));
+ builder.setFieldSfixed3214(data.getInt());
+ builder.setFieldSfixed6415(data.getLong());
+ builder.setFieldSint3216(data.getInt());
+ builder.setFieldSint6417(data.getLong());
+
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ builder.addFieldDoubleList18(data.getDouble());
+ builder.addFieldFloatList19(data.getFloat());
+ builder.addFieldInt64List20(data.getLong());
+ builder.addFieldUint64List21(data.getLong());
+ builder.addFieldInt32List22(data.getInt());
+ builder.addFieldFixed64List23(data.getLong());
+ builder.addFieldFixed32List24(data.getInt());
+ builder.addFieldBoolList25(data.getBool());
+ builder.addFieldStringList26(data.getString());
+ // Repeated message field is controlled by the branching factor below.
+ builder.addFieldBytesList28(data.getBytes());
+ builder.addFieldUint32List29(data.getInt());
+ builder.addFieldEnumList30(Proto2Message.TestEnum.forNumber(data.getEnum()));
+ builder.addFieldSfixed32List31(data.getInt());
+ builder.addFieldSfixed64List32(data.getLong());
+ builder.addFieldSint32List33(data.getInt());
+ builder.addFieldSint64List34(data.getLong());
+
+ builder.addFieldDoubleListPacked35(data.getDouble());
+ builder.addFieldFloatListPacked36(data.getFloat());
+ builder.addFieldInt64ListPacked37(data.getLong());
+ builder.addFieldUint64ListPacked38(data.getLong());
+ builder.addFieldInt32ListPacked39(data.getInt());
+ builder.addFieldFixed64ListPacked40(data.getLong());
+ builder.addFieldFixed32ListPacked41(data.getInt());
+ builder.addFieldBoolListPacked42(data.getBool());
+ builder.addFieldUint32ListPacked43(data.getInt());
+ builder.addFieldEnumListPacked44(Proto2Message.TestEnum.forNumber(data.getEnum()));
+ builder.addFieldSfixed32ListPacked45(data.getInt());
+ builder.addFieldSfixed64ListPacked46(data.getLong());
+ builder.addFieldSint32ListPacked47(data.getInt());
+ builder.addFieldSint64ListPacked48(data.getLong());
+ }
+
+ builder.setFieldGroup49(Proto2Message.FieldGroup49.newBuilder().setFieldInt3250(data.getInt()));
+
+ for (int i = 0; i < branchingFactor; ++i) {
+ builder.addFieldGroupList51(
+ Proto2Message.FieldGroupList51.newBuilder().setFieldInt3252(data.getInt()));
+ }
+
+ // Set all required fields.
+ populateRequiredFields(builder, INCLUDE_ALL_REQUIRED_FIELDS);
+
+ // Handle the branching factor.
+ if (nextLevel != null) {
+ for (int i = 0; i < branchingFactor; ++i) {
+ builder.addFieldMessageList27(nextLevel.newMessage());
+ }
+ }
+
+ return builder.build();
+ }
+
+ private interface MapValueProvider<T> {
+ public T getValue();
+ }
+
+ private final MapValueProvider<Integer> integerProvider =
+ new MapValueProvider<Integer>() {
+ @Override
+ public Integer getValue() {
+ return data.getInt();
+ }
+ };
+ private final MapValueProvider<Long> longProvider =
+ new MapValueProvider<Long>() {
+ @Override
+ public Long getValue() {
+ return data.getLong();
+ }
+ };
+ private final MapValueProvider<String> stringProvider =
+ new MapValueProvider<String>() {
+ @Override
+ public String getValue() {
+ return data.getString();
+ }
+ };
+ private final MapValueProvider<ByteString> bytesProvider =
+ new MapValueProvider<ByteString>() {
+ @Override
+ public ByteString getValue() {
+ return data.getBytes();
+ }
+ };
+ private final MapValueProvider<Boolean> booleanProvider =
+ new MapValueProvider<Boolean>() {
+ @Override
+ public Boolean getValue() {
+ return data.getBool();
+ }
+ };
+ private final MapValueProvider<Float> floatProvider =
+ new MapValueProvider<Float>() {
+ @Override
+ public Float getValue() {
+ return data.getFloat();
+ }
+ };
+ private final MapValueProvider<Double> doubleProvider =
+ new MapValueProvider<Double>() {
+ @Override
+ public Double getValue() {
+ return data.getDouble();
+ }
+ };
+ private final MapValueProvider<Proto2Message> messageProvider =
+ new MapValueProvider<Proto2Message>() {
+ @Override
+ public Proto2Message getValue() {
+ return newMessage();
+ }
+ };
+ private final MapValueProvider<Proto2Message.TestEnum> enumProvider =
+ new MapValueProvider<Proto2Message.TestEnum>() {
+ @Override
+ public Proto2Message.TestEnum getValue() {
+ return Proto2Message.TestEnum.forNumber(data.getEnum());
+ }
+ };
+
+ private <V> Map<Integer, V> populateIntegerMap(MapValueProvider<V> provider) {
+ Map<Integer, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getInt(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<Long, V> populateLongMap(MapValueProvider<V> provider) {
+ Map<Long, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getLong(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<String, V> populateStringMap(MapValueProvider<V> provider) {
+ Map<String, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getString(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<Boolean, V> populateBooleanMap(MapValueProvider<V> provider) {
+ Map<Boolean, V> map = new HashMap<>();
+ map.put(false, provider.getValue());
+ map.put(true, provider.getValue());
+ return map;
+ }
+
+ public Proto2MessageWithMaps newMessageWithMaps() {
+ Proto2MessageWithMaps.Builder builder = Proto2MessageWithMaps.newBuilder();
+
+ builder.putAllFieldMapBoolBool1(populateBooleanMap(booleanProvider));
+ builder.putAllFieldMapBoolBytes2(populateBooleanMap(bytesProvider));
+ builder.putAllFieldMapBoolDouble3(populateBooleanMap(doubleProvider));
+ builder.putAllFieldMapBoolEnum4(populateBooleanMap(enumProvider));
+ builder.putAllFieldMapBoolFixed325(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolFixed646(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolFloat7(populateBooleanMap(floatProvider));
+ builder.putAllFieldMapBoolInt328(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolInt649(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolMessage10(populateBooleanMap(messageProvider));
+ builder.putAllFieldMapBoolSfixed3211(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolSfixed6412(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolSint3213(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolSint6414(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolString15(populateBooleanMap(stringProvider));
+ builder.putAllFieldMapBoolUint3216(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolUint6417(populateBooleanMap(longProvider));
+ builder.putAllFieldMapFixed32Bool18(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapFixed32Bytes19(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapFixed32Double20(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapFixed32Enum21(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapFixed32Fixed3222(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Fixed6423(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Float24(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapFixed32Int3225(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Int6426(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Message27(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapFixed32Sfixed3228(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Sfixed6429(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Sint3230(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Sint6431(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32String32(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapFixed32Uint3233(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Uint6434(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed64Bool35(populateLongMap(booleanProvider));
+ builder.putAllFieldMapFixed64Bytes36(populateLongMap(bytesProvider));
+ builder.putAllFieldMapFixed64Double37(populateLongMap(doubleProvider));
+ builder.putAllFieldMapFixed64Enum38(populateLongMap(enumProvider));
+ builder.putAllFieldMapFixed64Fixed3239(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Fixed6440(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Float41(populateLongMap(floatProvider));
+ builder.putAllFieldMapFixed64Int3242(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Int6443(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Message44(populateLongMap(messageProvider));
+ builder.putAllFieldMapFixed64Sfixed3245(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Sfixed6446(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Sint3247(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Sint6448(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64String49(populateLongMap(stringProvider));
+ builder.putAllFieldMapFixed64Uint3250(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Uint6451(populateLongMap(longProvider));
+ builder.putAllFieldMapInt32Bool52(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapInt32Bytes53(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapInt32Double54(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapInt32Enum55(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapInt32Fixed3256(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Fixed6457(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Float58(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapInt32Int3259(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Int6460(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Message61(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapInt32Sfixed3262(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Sfixed6463(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Sint3264(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Sint6465(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32String66(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapInt32Uint3267(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Uint6468(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt64Bool69(populateLongMap(booleanProvider));
+ builder.putAllFieldMapInt64Bytes70(populateLongMap(bytesProvider));
+ builder.putAllFieldMapInt64Double71(populateLongMap(doubleProvider));
+ builder.putAllFieldMapInt64Enum72(populateLongMap(enumProvider));
+ builder.putAllFieldMapInt64Fixed3273(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Fixed6474(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Float75(populateLongMap(floatProvider));
+ builder.putAllFieldMapInt64Int3276(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Int6477(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Message78(populateLongMap(messageProvider));
+ builder.putAllFieldMapInt64Sfixed3279(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Sfixed6480(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Sint3281(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Sint6482(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64String83(populateLongMap(stringProvider));
+ builder.putAllFieldMapInt64Uint3284(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Uint6485(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed32Bool86(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapSfixed32Bytes87(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapSfixed32Double88(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapSfixed32Enum89(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapSfixed32Fixed3290(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Fixed6491(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Float92(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapSfixed32Int3293(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Int6494(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Message95(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapSfixed32Sfixed3296(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Sfixed6497(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Sint3298(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Sint6499(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32String100(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapSfixed32Uint32101(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Uint64102(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed64Bool103(populateLongMap(booleanProvider));
+ builder.putAllFieldMapSfixed64Bytes104(populateLongMap(bytesProvider));
+ builder.putAllFieldMapSfixed64Double105(populateLongMap(doubleProvider));
+ builder.putAllFieldMapSfixed64Enum106(populateLongMap(enumProvider));
+ builder.putAllFieldMapSfixed64Fixed32107(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Fixed64108(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Float109(populateLongMap(floatProvider));
+ builder.putAllFieldMapSfixed64Int32110(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Int64111(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Message112(populateLongMap(messageProvider));
+ builder.putAllFieldMapSfixed64Sfixed32113(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Sfixed64114(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Sint32115(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Sint64116(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64String117(populateLongMap(stringProvider));
+ builder.putAllFieldMapSfixed64Uint32118(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Uint64119(populateLongMap(longProvider));
+ builder.putAllFieldMapSint32Bool120(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapSint32Bytes121(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapSint32Double122(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapSint32Enum123(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapSint32Fixed32124(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Fixed64125(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Float126(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapSint32Int32127(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Int64128(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Message129(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapSint32Sfixed32130(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Sfixed64131(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Sint32132(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Sint64133(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32String134(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapSint32Uint32135(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Uint64136(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint64Bool137(populateLongMap(booleanProvider));
+ builder.putAllFieldMapSint64Bytes138(populateLongMap(bytesProvider));
+ builder.putAllFieldMapSint64Double139(populateLongMap(doubleProvider));
+ builder.putAllFieldMapSint64Enum140(populateLongMap(enumProvider));
+ builder.putAllFieldMapSint64Fixed32141(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Fixed64142(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Float143(populateLongMap(floatProvider));
+ builder.putAllFieldMapSint64Int32144(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Int64145(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Message146(populateLongMap(messageProvider));
+ builder.putAllFieldMapSint64Sfixed32147(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Sfixed64148(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Sint32149(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Sint64150(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64String151(populateLongMap(stringProvider));
+ builder.putAllFieldMapSint64Uint32152(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Uint64153(populateLongMap(longProvider));
+ builder.putAllFieldMapStringBool154(populateStringMap(booleanProvider));
+ builder.putAllFieldMapStringBytes155(populateStringMap(bytesProvider));
+ builder.putAllFieldMapStringDouble156(populateStringMap(doubleProvider));
+ builder.putAllFieldMapStringEnum157(populateStringMap(enumProvider));
+ builder.putAllFieldMapStringFixed32158(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringFixed64159(populateStringMap(longProvider));
+ builder.putAllFieldMapStringFloat160(populateStringMap(floatProvider));
+ builder.putAllFieldMapStringInt32161(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringInt64162(populateStringMap(longProvider));
+ builder.putAllFieldMapStringMessage163(populateStringMap(messageProvider));
+ builder.putAllFieldMapStringSfixed32164(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringSfixed64165(populateStringMap(longProvider));
+ builder.putAllFieldMapStringSint32166(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringSint64167(populateStringMap(longProvider));
+ builder.putAllFieldMapStringString168(populateStringMap(stringProvider));
+ builder.putAllFieldMapStringUint32169(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringUint64170(populateStringMap(longProvider));
+ builder.putAllFieldMapUint32Bool171(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapUint32Bytes172(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapUint32Double173(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapUint32Enum174(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapUint32Fixed32175(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Fixed64176(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Float177(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapUint32Int32178(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Int64179(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Message180(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapUint32Sfixed32181(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Sfixed64182(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Sint32183(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Sint64184(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32String185(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapUint32Uint32186(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Uint64187(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint64Bool188(populateLongMap(booleanProvider));
+ builder.putAllFieldMapUint64Bytes189(populateLongMap(bytesProvider));
+ builder.putAllFieldMapUint64Double190(populateLongMap(doubleProvider));
+ builder.putAllFieldMapUint64Enum191(populateLongMap(enumProvider));
+ builder.putAllFieldMapUint64Fixed32192(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Fixed64193(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Float194(populateLongMap(floatProvider));
+ builder.putAllFieldMapUint64Int32195(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Int64196(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Message197(populateLongMap(messageProvider));
+ builder.putAllFieldMapUint64Sfixed32198(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Sfixed64199(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Sint32200(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Sint64201(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64String202(populateLongMap(stringProvider));
+ builder.putAllFieldMapUint64Uint32203(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Uint64204(populateLongMap(longProvider));
+
+ return builder.build();
+ }
+
+ public List<Proto2Message> newMessagesMissingRequiredFields() {
+ List<Proto2Message> results = new ArrayList<>();
+ for (int i = 71; i <= 88; ++i) {
+ Proto2Message.Builder builder = Proto2Message.newBuilder();
+ populateRequiredFields(builder, i);
+ results.add(builder.buildPartial());
+ }
+ {
+ // A nested optional message field is missing required fields.
+ Proto2Message.Builder builder = Proto2Message.newBuilder();
+ populateRequiredFields(builder, INCLUDE_ALL_REQUIRED_FIELDS);
+ builder.setFieldMessage10(Proto2Message.getDefaultInstance());
+ results.add(builder.buildPartial());
+ }
+ {
+ // A nested repeated message field is missing required fields.
+ Proto2Message.Builder builder = Proto2Message.newBuilder();
+ populateRequiredFields(builder, INCLUDE_ALL_REQUIRED_FIELDS);
+ builder.addFieldMessageList27(Proto2Message.getDefaultInstance());
+ results.add(builder.buildPartial());
+ }
+ {
+ // A nested oneof message field is missing required fields.
+ Proto2Message.Builder builder = Proto2Message.newBuilder();
+ populateRequiredFields(builder, INCLUDE_ALL_REQUIRED_FIELDS);
+ builder.setFieldMessage62(Proto2Message.getDefaultInstance());
+ results.add(builder.buildPartial());
+ }
+ return results;
+ }
+
+ // 0 is not a valid field number so we use it to mean no fields are excluded.
+ private static final int INCLUDE_ALL_REQUIRED_FIELDS = 0;
+
+ private void populateRequiredFields(Proto2Message.Builder builder, int excludedFieldNumber) {
+ if (excludedFieldNumber != 71) {
+ builder.setFieldRequiredDouble71(data.getDouble());
+ }
+ if (excludedFieldNumber != 72) {
+ builder.setFieldRequiredFloat72(data.getFloat());
+ }
+ if (excludedFieldNumber != 73) {
+ builder.setFieldRequiredInt6473(data.getLong());
+ }
+ if (excludedFieldNumber != 74) {
+ builder.setFieldRequiredUint6474(data.getLong());
+ }
+ if (excludedFieldNumber != 75) {
+ builder.setFieldRequiredInt3275(data.getInt());
+ }
+ if (excludedFieldNumber != 76) {
+ builder.setFieldRequiredFixed6476(data.getLong());
+ }
+ if (excludedFieldNumber != 77) {
+ builder.setFieldRequiredFixed3277(data.getInt());
+ }
+ if (excludedFieldNumber != 78) {
+ builder.setFieldRequiredBool78(data.getBool());
+ }
+ if (excludedFieldNumber != 79) {
+ builder.setFieldRequiredString79(data.getString());
+ }
+ if (excludedFieldNumber != 80) {
+ builder.setFieldRequiredMessage80(
+ Proto2Message.RequiredNestedMessage.newBuilder().setValue(data.getInt()));
+ }
+ if (excludedFieldNumber != 81) {
+ builder.setFieldRequiredBytes81(data.getBytes());
+ }
+ if (excludedFieldNumber != 82) {
+ builder.setFieldRequiredUint3282(data.getInt());
+ }
+ if (excludedFieldNumber != 83) {
+ builder.setFieldRequiredEnum83(Proto2Message.TestEnum.forNumber(data.getEnum()));
+ }
+ if (excludedFieldNumber != 84) {
+ builder.setFieldRequiredSfixed3284(data.getInt());
+ }
+ if (excludedFieldNumber != 85) {
+ builder.setFieldRequiredSfixed6485(data.getLong());
+ }
+ if (excludedFieldNumber != 86) {
+ builder.setFieldRequiredSint3286(data.getInt());
+ }
+ if (excludedFieldNumber != 87) {
+ builder.setFieldRequiredSint6487(data.getLong());
+ }
+ if (excludedFieldNumber != 88) {
+ builder.setFieldRequiredGroup88(
+ Proto2Message.FieldRequiredGroup88.newBuilder().setFieldInt3289(data.getInt()));
+ }
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto2MessageInfoFactory.java b/java/core/src/test/java/com/google/protobuf/Proto2MessageInfoFactory.java
new file mode 100755
index 0000000..af671b2
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto2MessageInfoFactory.java
@@ -0,0 +1,892 @@
+// 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.forFieldWithEnumVerifier;
+import static com.google.protobuf.FieldInfo.forMapField;
+import static com.google.protobuf.FieldInfo.forOneofMemberField;
+import static com.google.protobuf.FieldInfo.forProto2OptionalField;
+import static com.google.protobuf.FieldInfo.forProto2RequiredField;
+import static com.google.protobuf.FieldInfo.forRepeatedMessageField;
+
+import com.google.protobuf.testing.Proto2Testing;
+import com.google.protobuf.testing.Proto2Testing.Proto2Empty;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message.FieldGroup49;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message.FieldGroup69;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message.FieldGroupList51;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message.FieldRequiredGroup88;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message.RequiredNestedMessage;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message.TestEnum;
+import com.google.protobuf.testing.Proto2Testing.Proto2MessageWithExtensions;
+import com.google.protobuf.testing.Proto2Testing.Proto2MessageWithMaps;
+import java.lang.reflect.Field;
+
+/** A factory that generates a hard-coded message info for {@link Proto2Message}. */
+public final class Proto2MessageInfoFactory implements MessageInfoFactory {
+ private static final Proto2MessageInfoFactory INSTANCE = new Proto2MessageInfoFactory();
+
+ private Proto2MessageInfoFactory() {}
+
+ public static Proto2MessageInfoFactory getInstance() {
+ return INSTANCE;
+ }
+
+ @Override
+ public boolean isSupported(Class<?> clazz) {
+ return true;
+ }
+
+ @Override
+ public MessageInfo messageInfoFor(Class<?> clazz) {
+ if (Proto2Message.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto2Message();
+ } else if (FieldGroup49.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForFieldGroup49();
+ } else if (FieldGroupList51.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForFieldGroupList51();
+ } else if (FieldGroup69.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForFieldGroup69();
+ } else if (FieldRequiredGroup88.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForFieldRequiredGroup88();
+ } else if (RequiredNestedMessage.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForRequiredNestedMessage();
+ } else if (Proto2Empty.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto2Empty();
+ } else if (Proto2MessageWithExtensions.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto2MessageWithExtensions();
+ } else if (Proto2Testing.FieldGroup49.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForExtensionFieldGroup49();
+ } else if (Proto2Testing.FieldGroupList51.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForExtensionFieldGroupList51();
+ } else if (Proto2Testing.Proto2MessageWithMaps.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto2MessageWithMaps();
+ } else {
+ throw new IllegalArgumentException("Unsupported class: " + clazz.getName());
+ }
+ }
+
+ /**
+ * Creates a new hard-coded info for {@link Proto2Message}. Each time this is called, we manually
+ * go through the entire process of what a message would do if it self-registered its own info,
+ * including looking up each field by name. This is done for benchmarking purposes, so that we get
+ * a more accurate representation of the time it takes to perform this process.
+ */
+ private static StructuralMessageInfo newMessageInfoForProto2Message() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(50);
+ builder.withCheckInitialized(
+ new int[] {
+ 10, 27, 62, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ });
+ lookupFieldsByName(builder);
+ return builder.build();
+ }
+
+ private static void lookupFieldsByName(StructuralMessageInfo.Builder builder) {
+ Field bitField0 = field("bitField0_");
+
+ builder.withDefaultInstance(Proto2Message.getDefaultInstance());
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldDouble1_"), 1, FieldType.DOUBLE, bitField0, 0x00000001, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldFloat2_"), 2, FieldType.FLOAT, bitField0, 0x00000002, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldInt643_"), 3, FieldType.INT64, bitField0, 0x00000004, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldUint644_"), 4, FieldType.UINT64, bitField0, 0x00000008, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldInt325_"), 5, FieldType.INT32, bitField0, 0x00000010, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldFixed646_"), 6, FieldType.FIXED64, bitField0, 0x00000020, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldFixed327_"), 7, FieldType.FIXED32, bitField0, 0x00000040, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldBool8_"), 8, FieldType.BOOL, bitField0, 0x00000080, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldString9_"), 9, FieldType.STRING, bitField0, 0x00000100, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldMessage10_"), 10, FieldType.MESSAGE, bitField0, 0x00000200, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldBytes11_"), 11, FieldType.BYTES, bitField0, 0x00000400, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldUint3212_"), 12, FieldType.UINT32, bitField0, 0x00000800, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldEnum13_"),
+ 13,
+ FieldType.ENUM,
+ bitField0,
+ 0x00001000,
+ false,
+ asVerifier(TestEnum.internalGetValueMap())));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldSfixed3214_"), 14, FieldType.SFIXED32, bitField0, 0x00002000, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldSfixed6415_"), 15, FieldType.SFIXED64, bitField0, 0x00004000, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldSint3216_"), 16, FieldType.SINT32, bitField0, 0x00008000, false, null));
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldSint6417_"), 17, FieldType.SINT64, bitField0, 0x00010000, false, null));
+ builder.withField(forField(field("fieldDoubleList18_"), 18, FieldType.DOUBLE_LIST, false));
+ builder.withField(forField(field("fieldFloatList19_"), 19, FieldType.FLOAT_LIST, false));
+ builder.withField(forField(field("fieldInt64List20_"), 20, FieldType.INT64_LIST, false));
+ builder.withField(forField(field("fieldUint64List21_"), 21, FieldType.UINT64_LIST, false));
+ builder.withField(forField(field("fieldInt32List22_"), 22, FieldType.INT32_LIST, false));
+ builder.withField(forField(field("fieldFixed64List23_"), 23, FieldType.FIXED64_LIST, false));
+ builder.withField(forField(field("fieldFixed32List24_"), 24, FieldType.FIXED32_LIST, false));
+ builder.withField(forField(field("fieldBoolList25_"), 25, FieldType.BOOL_LIST, false));
+ builder.withField(forField(field("fieldStringList26_"), 26, FieldType.STRING_LIST, false));
+ builder.withField(
+ forRepeatedMessageField(
+ field("fieldMessageList27_"), 27, FieldType.MESSAGE_LIST, Proto2Message.class));
+ builder.withField(forField(field("fieldBytesList28_"), 28, FieldType.BYTES_LIST, false));
+ builder.withField(forField(field("fieldUint32List29_"), 29, FieldType.UINT32_LIST, false));
+ builder.withField(
+ forFieldWithEnumVerifier(
+ field("fieldEnumList30_"),
+ 30,
+ FieldType.ENUM_LIST,
+ asVerifier(TestEnum.internalGetValueMap())));
+ builder.withField(forField(field("fieldSfixed32List31_"), 31, FieldType.SFIXED32_LIST, false));
+ builder.withField(forField(field("fieldSfixed64List32_"), 32, FieldType.SFIXED64_LIST, false));
+ builder.withField(forField(field("fieldSint32List33_"), 33, FieldType.SINT32_LIST, false));
+ builder.withField(forField(field("fieldSint64List34_"), 34, FieldType.SINT64_LIST, false));
+ builder.withField(
+ forField(field("fieldDoubleListPacked35_"), 35, FieldType.DOUBLE_LIST_PACKED, false));
+ builder.withField(
+ forField(field("fieldFloatListPacked36_"), 36, FieldType.FLOAT_LIST_PACKED, false));
+ builder.withField(
+ forField(field("fieldInt64ListPacked37_"), 37, FieldType.INT64_LIST_PACKED, false));
+ builder.withField(
+ forField(field("fieldUint64ListPacked38_"), 38, FieldType.UINT64_LIST_PACKED, false));
+ builder.withField(
+ forField(field("fieldInt32ListPacked39_"), 39, FieldType.INT32_LIST_PACKED, false));
+ builder.withField(
+ forField(field("fieldFixed64ListPacked40_"), 40, FieldType.FIXED64_LIST_PACKED, false));
+ builder.withField(
+ forField(field("fieldFixed32ListPacked41_"), 41, FieldType.FIXED32_LIST_PACKED, false));
+ builder.withField(
+ forField(field("fieldBoolListPacked42_"), 42, FieldType.BOOL_LIST_PACKED, false));
+ builder.withField(
+ forField(field("fieldUint32ListPacked43_"), 43, FieldType.UINT32_LIST_PACKED, false));
+ builder.withField(
+ forFieldWithEnumVerifier(
+ field("fieldEnumListPacked44_"),
+ 44,
+ FieldType.ENUM_LIST_PACKED,
+ asVerifier(TestEnum.internalGetValueMap())));
+ builder.withField(
+ forField(field("fieldSfixed32ListPacked45_"), 45, FieldType.SFIXED32_LIST_PACKED, false));
+ builder.withField(
+ forField(field("fieldSfixed64ListPacked46_"), 46, FieldType.SFIXED64_LIST_PACKED, false));
+ builder.withField(
+ forField(field("fieldSint32ListPacked47_"), 47, FieldType.SINT32_LIST_PACKED, false));
+ builder.withField(
+ forField(field("fieldSint64ListPacked48_"), 48, FieldType.SINT64_LIST_PACKED, false));
+
+ builder.withField(
+ forProto2OptionalField(
+ field("fieldGroup49_"), 49, FieldType.GROUP, bitField0, 0x00020000, false, null));
+ builder.withField(
+ forRepeatedMessageField(
+ field("fieldGroupList51_"),
+ 51,
+ FieldType.GROUP_LIST,
+ Proto2Message.FieldGroupList51.class));
+
+ OneofInfo oneof = new OneofInfo(0, field("testOneofCase_"), field("testOneof_"));
+ builder.withField(forOneofMemberField(53, FieldType.DOUBLE, oneof, Double.class, false, null));
+ builder.withField(forOneofMemberField(54, FieldType.FLOAT, oneof, Float.class, false, null));
+ builder.withField(forOneofMemberField(55, FieldType.INT64, oneof, Long.class, false, null));
+ builder.withField(forOneofMemberField(56, FieldType.UINT64, oneof, Long.class, false, null));
+ builder.withField(forOneofMemberField(57, FieldType.INT32, oneof, Integer.class, false, null));
+ builder.withField(forOneofMemberField(58, FieldType.FIXED64, oneof, Long.class, false, null));
+ builder.withField(
+ forOneofMemberField(59, FieldType.FIXED32, oneof, Integer.class, false, null));
+ builder.withField(forOneofMemberField(60, FieldType.BOOL, oneof, Boolean.class, false, null));
+ builder.withField(forOneofMemberField(61, FieldType.STRING, oneof, String.class, false, null));
+ builder.withField(
+ forOneofMemberField(62, FieldType.MESSAGE, oneof, Proto2Message.class, false, null));
+ builder.withField(
+ forOneofMemberField(63, FieldType.BYTES, oneof, ByteString.class, false, null));
+ builder.withField(forOneofMemberField(64, FieldType.UINT32, oneof, Integer.class, false, null));
+ builder.withField(
+ forOneofMemberField(65, FieldType.SFIXED32, oneof, Integer.class, false, null));
+ builder.withField(forOneofMemberField(66, FieldType.SFIXED64, oneof, Long.class, false, null));
+ builder.withField(forOneofMemberField(67, FieldType.SINT32, oneof, Integer.class, false, null));
+ builder.withField(forOneofMemberField(68, FieldType.SINT64, oneof, Long.class, false, null));
+ builder.withField(
+ forOneofMemberField(
+ 69, FieldType.GROUP, oneof, Proto2Message.FieldGroup69.class, false, null));
+
+ Field bitField1 = field("bitField1_");
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredDouble71_"),
+ 71,
+ FieldType.DOUBLE,
+ bitField1,
+ 0x00000008,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredFloat72_"),
+ 72,
+ FieldType.FLOAT,
+ bitField1,
+ 0x00000010,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredInt6473_"),
+ 73,
+ FieldType.INT64,
+ bitField1,
+ 0x00000020,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredUint6474_"),
+ 74,
+ FieldType.UINT64,
+ bitField1,
+ 0x00000040,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredInt3275_"),
+ 75,
+ FieldType.INT32,
+ bitField1,
+ 0x00000080,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredFixed6476_"),
+ 76,
+ FieldType.FIXED64,
+ bitField1,
+ 0x00000100,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredFixed3277_"),
+ 77,
+ FieldType.FIXED32,
+ bitField1,
+ 0x00000200,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredBool78_"), 78, FieldType.BOOL, bitField1, 0x00000400, false, null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredString79_"),
+ 79,
+ FieldType.STRING,
+ bitField1,
+ 0x00000800,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredMessage80_"),
+ 80,
+ FieldType.MESSAGE,
+ bitField1,
+ 0x00001000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredBytes81_"),
+ 81,
+ FieldType.BYTES,
+ bitField1,
+ 0x00002000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredUint3282_"),
+ 82,
+ FieldType.UINT32,
+ bitField1,
+ 0x00004000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredEnum83_"),
+ 83,
+ FieldType.ENUM,
+ bitField1,
+ 0x00008000,
+ false,
+ asVerifier(TestEnum.internalGetValueMap())));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredSfixed3284_"),
+ 84,
+ FieldType.SFIXED32,
+ bitField1,
+ 0x00010000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredSfixed6485_"),
+ 85,
+ FieldType.SFIXED64,
+ bitField1,
+ 0x00020000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredSint3286_"),
+ 86,
+ FieldType.SINT32,
+ bitField1,
+ 0x00040000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredSint6487_"),
+ 87,
+ FieldType.SINT64,
+ bitField1,
+ 0x00080000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field("fieldRequiredGroup88_"),
+ 88,
+ FieldType.GROUP,
+ bitField1,
+ 0x00100000,
+ false,
+ null));
+ }
+
+ private static StructuralMessageInfo newMessageInfoForFieldGroup49() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(FieldGroup49.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(FieldGroup49.class, "fieldInt3250_"),
+ 50,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForFieldGroupList51() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(FieldGroupList51.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(FieldGroupList51.class, "fieldInt3252_"),
+ 52,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForFieldGroup69() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(FieldGroup69.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(FieldGroup69.class, "fieldInt3270_"),
+ 70,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForRequiredNestedMessage() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(RequiredNestedMessage.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(RequiredNestedMessage.class, "value_"),
+ 1,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForFieldRequiredGroup88() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(FieldRequiredGroup88.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(FieldRequiredGroup88.class, "fieldInt3289_"),
+ 89,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForProto2Empty() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForProto2MessageWithExtensions() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(0);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForExtensionFieldGroup49() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(Proto2Testing.FieldGroup49.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2Testing.FieldGroup49.class, "fieldInt3250_"),
+ 50,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForExtensionFieldGroupList51() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(Proto2Testing.FieldGroupList51.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2Testing.FieldGroupList51.class, "fieldInt3252_"),
+ 52,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForProto2MessageWithMaps() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder();
+ builder.withCheckInitialized(
+ new int[] {
+ 10, 27, 44, 61, 78, 95, 112, 129, 146, 163, 180, 197,
+ });
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_bool_1", 1));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_bytes_2", 2));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_double_3", 3));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_enum_4", 4));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_fixed32_5", 5));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_fixed64_6", 6));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_float_7", 7));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_int32_8", 8));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_int64_9", 9));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_message_10", 10));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_sfixed32_11", 11));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_sfixed64_12", 12));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_sint32_13", 13));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_sint64_14", 14));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_string_15", 15));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_uint32_16", 16));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_bool_uint64_17", 17));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_bool_18", 18));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_bytes_19", 19));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_double_20", 20));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_enum_21", 21));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_fixed32_22", 22));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_fixed64_23", 23));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_float_24", 24));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_int32_25", 25));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_int64_26", 26));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_message_27", 27));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_sfixed32_28", 28));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_sfixed64_29", 29));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_sint32_30", 30));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_sint64_31", 31));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_string_32", 32));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_uint32_33", 33));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed32_uint64_34", 34));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_bool_35", 35));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_bytes_36", 36));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_double_37", 37));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_enum_38", 38));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_fixed32_39", 39));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_fixed64_40", 40));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_float_41", 41));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_int32_42", 42));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_int64_43", 43));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_message_44", 44));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_sfixed32_45", 45));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_sfixed64_46", 46));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_sint32_47", 47));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_sint64_48", 48));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_string_49", 49));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_uint32_50", 50));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_fixed64_uint64_51", 51));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_bool_52", 52));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_bytes_53", 53));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_double_54", 54));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_enum_55", 55));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_fixed32_56", 56));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_fixed64_57", 57));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_float_58", 58));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_int32_59", 59));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_int64_60", 60));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_message_61", 61));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_sfixed32_62", 62));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_sfixed64_63", 63));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_sint32_64", 64));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_sint64_65", 65));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_string_66", 66));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_uint32_67", 67));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int32_uint64_68", 68));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_bool_69", 69));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_bytes_70", 70));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_double_71", 71));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_enum_72", 72));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_fixed32_73", 73));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_fixed64_74", 74));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_float_75", 75));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_int32_76", 76));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_int64_77", 77));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_message_78", 78));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_sfixed32_79", 79));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_sfixed64_80", 80));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_sint32_81", 81));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_sint64_82", 82));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_string_83", 83));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_uint32_84", 84));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_int64_uint64_85", 85));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_bool_86", 86));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_bytes_87", 87));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_double_88", 88));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_enum_89", 89));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_fixed32_90", 90));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_fixed64_91", 91));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_float_92", 92));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_int32_93", 93));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_int64_94", 94));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_message_95", 95));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_sfixed32_96", 96));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_sfixed64_97", 97));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_sint32_98", 98));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_sint64_99", 99));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_string_100", 100));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_uint32_101", 101));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed32_uint64_102", 102));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_bool_103", 103));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_bytes_104", 104));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_double_105", 105));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_enum_106", 106));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_fixed32_107", 107));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_fixed64_108", 108));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_float_109", 109));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_int32_110", 110));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_int64_111", 111));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_message_112", 112));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_sfixed32_113", 113));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_sfixed64_114", 114));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_sint32_115", 115));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_sint64_116", 116));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_string_117", 117));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_uint32_118", 118));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sfixed64_uint64_119", 119));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_bool_120", 120));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_bytes_121", 121));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_double_122", 122));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_enum_123", 123));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_fixed32_124", 124));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_fixed64_125", 125));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_float_126", 126));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_int32_127", 127));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_int64_128", 128));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_message_129", 129));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_sfixed32_130", 130));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_sfixed64_131", 131));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_sint32_132", 132));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_sint64_133", 133));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_string_134", 134));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_uint32_135", 135));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint32_uint64_136", 136));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_bool_137", 137));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_bytes_138", 138));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_double_139", 139));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_enum_140", 140));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_fixed32_141", 141));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_fixed64_142", 142));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_float_143", 143));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_int32_144", 144));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_int64_145", 145));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_message_146", 146));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_sfixed32_147", 147));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_sfixed64_148", 148));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_sint32_149", 149));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_sint64_150", 150));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_string_151", 151));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_uint32_152", 152));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_sint64_uint64_153", 153));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_bool_154", 154));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_bytes_155", 155));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_double_156", 156));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_enum_157", 157));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_fixed32_158", 158));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_fixed64_159", 159));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_float_160", 160));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_int32_161", 161));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_int64_162", 162));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_message_163", 163));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_sfixed32_164", 164));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_sfixed64_165", 165));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_sint32_166", 166));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_sint64_167", 167));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_string_168", 168));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_uint32_169", 169));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_string_uint64_170", 170));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_bool_171", 171));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_bytes_172", 172));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_double_173", 173));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_enum_174", 174));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_fixed32_175", 175));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_fixed64_176", 176));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_float_177", 177));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_int32_178", 178));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_int64_179", 179));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_message_180", 180));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_sfixed32_181", 181));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_sfixed64_182", 182));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_sint32_183", 183));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_sint64_184", 184));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_string_185", 185));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_uint32_186", 186));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint32_uint64_187", 187));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_bool_188", 188));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_bytes_189", 189));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_double_190", 190));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_enum_191", 191));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_fixed32_192", 192));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_fixed64_193", 193));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_float_194", 194));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_int32_195", 195));
+ builder.withField(mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_int64_196", 196));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_message_197", 197));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_sfixed32_198", 198));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_sfixed64_199", 199));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_sint32_200", 200));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_sint64_201", 201));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_string_202", 202));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_uint32_203", 203));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_uint64_204", 204));
+
+ return builder.build();
+ }
+
+ private static FieldInfo mapFieldInfo(Class<?> clazz, String fieldName, int fieldNumber) {
+ try {
+ return forMapField(
+ field(clazz, SchemaUtil.toCamelCase(fieldName, false) + "_"),
+ fieldNumber,
+ SchemaUtil.getMapDefaultEntry(clazz, fieldName),
+ fieldName.contains("_enum_") ? asVerifier(TestEnum.internalGetValueMap()) : null);
+ } catch (Throwable t) {
+ throw new RuntimeException(t);
+ }
+ }
+
+
+ private static Field field(String name) {
+ return field(Proto2Message.class, name);
+ }
+
+ private static Field field(Class<?> clazz, String name) {
+ try {
+ return clazz.getDeclaredField(name);
+ } catch (NoSuchFieldException | SecurityException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static Internal.EnumVerifier asVerifier(final Internal.EnumLiteMap<?> map) {
+ return new Internal.EnumVerifier() {
+ @Override
+ public boolean isInRange(int number) {
+ return map.findValueByNumber(number) != null;
+ }
+ };
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto2MessageLiteFactory.java b/java/core/src/test/java/com/google/protobuf/Proto2MessageLiteFactory.java
new file mode 100755
index 0000000..2da3494
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto2MessageLiteFactory.java
@@ -0,0 +1,558 @@
+// 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.testing.Proto2TestingLite.Proto2MessageLite;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLiteWithMaps;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/** Creates instances of {@link Proto2MessageLite} based on the tree configuration. */
+public final class Proto2MessageLiteFactory
+ implements ExperimentalMessageFactory<Proto2MessageLite> {
+ private final int numRepeatedFields;
+ private final int branchingFactor;
+ private final Proto2MessageLiteFactory nextLevel;
+ private final ExperimentalTestDataProvider data;
+
+ public Proto2MessageLiteFactory(
+ int numRepeatedFields, int stringLength, int branchingFactor, int treeDepth) {
+ this(
+ new ExperimentalTestDataProvider(stringLength),
+ numRepeatedFields,
+ branchingFactor,
+ treeDepth);
+ }
+
+ private Proto2MessageLiteFactory(
+ ExperimentalTestDataProvider data,
+ int numRepeatedFields,
+ int branchingFactor,
+ int treeDepth) {
+ this.numRepeatedFields = numRepeatedFields;
+ this.branchingFactor = branchingFactor;
+ this.data = data;
+ if (treeDepth > 0) {
+ nextLevel =
+ new Proto2MessageLiteFactory(data, numRepeatedFields, branchingFactor, treeDepth - 1);
+ } else {
+ nextLevel = null;
+ }
+ }
+
+ @Override
+ public ExperimentalTestDataProvider dataProvider() {
+ return data;
+ }
+
+ @Override
+ public Proto2MessageLite newMessage() {
+ Proto2MessageLite.Builder builder = Proto2MessageLite.newBuilder();
+ builder.setFieldDouble1(data.getDouble());
+ builder.setFieldFloat2(data.getFloat());
+ builder.setFieldInt643(data.getLong());
+ builder.setFieldUint644(data.getLong());
+ builder.setFieldInt325(data.getInt());
+ builder.setFieldFixed646(data.getLong());
+ builder.setFieldFixed327(data.getInt());
+ builder.setFieldBool8(data.getBool());
+ builder.setFieldString9(data.getString());
+ // We don't populate the message field. Instead we apply the branching factor to the
+ // repeated message field below.
+ builder.setFieldBytes11(data.getBytes());
+ builder.setFieldUint3212(data.getInt());
+ builder.setFieldEnum13(Proto2MessageLite.TestEnum.forNumber(data.getEnum()));
+ builder.setFieldSfixed3214(data.getInt());
+ builder.setFieldSfixed6415(data.getLong());
+ builder.setFieldSint3216(data.getInt());
+ builder.setFieldSint6417(data.getLong());
+
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ builder.addFieldDoubleList18(data.getDouble());
+ builder.addFieldFloatList19(data.getFloat());
+ builder.addFieldInt64List20(data.getLong());
+ builder.addFieldUint64List21(data.getLong());
+ builder.addFieldInt32List22(data.getInt());
+ builder.addFieldFixed64List23(data.getLong());
+ builder.addFieldFixed32List24(data.getInt());
+ builder.addFieldBoolList25(data.getBool());
+ builder.addFieldStringList26(data.getString());
+ // Repeated message field is controlled by the branching factor below.
+ builder.addFieldBytesList28(data.getBytes());
+ builder.addFieldUint32List29(data.getInt());
+ builder.addFieldEnumList30(Proto2MessageLite.TestEnum.forNumber(data.getEnum()));
+ builder.addFieldSfixed32List31(data.getInt());
+ builder.addFieldSfixed64List32(data.getLong());
+ builder.addFieldSint32List33(data.getInt());
+ builder.addFieldSint64List34(data.getLong());
+
+ builder.addFieldDoubleListPacked35(data.getDouble());
+ builder.addFieldFloatListPacked36(data.getFloat());
+ builder.addFieldInt64ListPacked37(data.getLong());
+ builder.addFieldUint64ListPacked38(data.getLong());
+ builder.addFieldInt32ListPacked39(data.getInt());
+ builder.addFieldFixed64ListPacked40(data.getLong());
+ builder.addFieldFixed32ListPacked41(data.getInt());
+ builder.addFieldBoolListPacked42(data.getBool());
+ builder.addFieldUint32ListPacked43(data.getInt());
+ builder.addFieldEnumListPacked44(Proto2MessageLite.TestEnum.forNumber(data.getEnum()));
+ builder.addFieldSfixed32ListPacked45(data.getInt());
+ builder.addFieldSfixed64ListPacked46(data.getLong());
+ builder.addFieldSint32ListPacked47(data.getInt());
+ builder.addFieldSint64ListPacked48(data.getLong());
+ }
+
+ builder.setFieldGroup49(
+ Proto2MessageLite.FieldGroup49.newBuilder().setFieldInt3250(data.getInt()));
+
+ for (int i = 0; i < branchingFactor; ++i) {
+ builder.addFieldGroupList51(
+ Proto2MessageLite.FieldGroupList51.newBuilder().setFieldInt3252(data.getInt()));
+ }
+
+ // Set all required fields.
+ populateRequiredFields(builder, INCLUDE_ALL_REQUIRED_FIELDS);
+
+ // Handle the branching factor.
+ if (nextLevel != null) {
+ for (int i = 0; i < branchingFactor; ++i) {
+ builder.addFieldMessageList27(nextLevel.newMessage());
+ }
+ }
+
+ return builder.build();
+ }
+
+ private interface MapValueProvider<T> {
+ public T getValue();
+ }
+
+ private final MapValueProvider<Integer> integerProvider =
+ new MapValueProvider<Integer>() {
+ @Override
+ public Integer getValue() {
+ return data.getInt();
+ }
+ };
+ private final MapValueProvider<Long> longProvider =
+ new MapValueProvider<Long>() {
+ @Override
+ public Long getValue() {
+ return data.getLong();
+ }
+ };
+ private final MapValueProvider<String> stringProvider =
+ new MapValueProvider<String>() {
+ @Override
+ public String getValue() {
+ return data.getString();
+ }
+ };
+ private final MapValueProvider<ByteString> bytesProvider =
+ new MapValueProvider<ByteString>() {
+ @Override
+ public ByteString getValue() {
+ return data.getBytes();
+ }
+ };
+ private final MapValueProvider<Boolean> booleanProvider =
+ new MapValueProvider<Boolean>() {
+ @Override
+ public Boolean getValue() {
+ return data.getBool();
+ }
+ };
+ private final MapValueProvider<Float> floatProvider =
+ new MapValueProvider<Float>() {
+ @Override
+ public Float getValue() {
+ return data.getFloat();
+ }
+ };
+ private final MapValueProvider<Double> doubleProvider =
+ new MapValueProvider<Double>() {
+ @Override
+ public Double getValue() {
+ return data.getDouble();
+ }
+ };
+ private final MapValueProvider<Proto2MessageLite> messageProvider =
+ new MapValueProvider<Proto2MessageLite>() {
+ @Override
+ public Proto2MessageLite getValue() {
+ return newMessage();
+ }
+ };
+ private final MapValueProvider<Proto2MessageLite.TestEnum> enumProvider =
+ new MapValueProvider<Proto2MessageLite.TestEnum>() {
+ @Override
+ public Proto2MessageLite.TestEnum getValue() {
+ return Proto2MessageLite.TestEnum.forNumber(data.getEnum());
+ }
+ };
+
+ private <V> Map<Integer, V> populateIntegerMap(MapValueProvider<V> provider) {
+ Map<Integer, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getInt(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<Long, V> populateLongMap(MapValueProvider<V> provider) {
+ Map<Long, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getLong(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<String, V> populateStringMap(MapValueProvider<V> provider) {
+ Map<String, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getString(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<Boolean, V> populateBooleanMap(MapValueProvider<V> provider) {
+ Map<Boolean, V> map = new HashMap<>();
+ map.put(false, provider.getValue());
+ map.put(true, provider.getValue());
+ return map;
+ }
+
+ public Proto2MessageLiteWithMaps newMessageWithMaps() {
+ Proto2MessageLiteWithMaps.Builder builder = Proto2MessageLiteWithMaps.newBuilder();
+
+ builder.putAllFieldMapBoolBool1(populateBooleanMap(booleanProvider));
+ builder.putAllFieldMapBoolBytes2(populateBooleanMap(bytesProvider));
+ builder.putAllFieldMapBoolDouble3(populateBooleanMap(doubleProvider));
+ builder.putAllFieldMapBoolEnum4(populateBooleanMap(enumProvider));
+ builder.putAllFieldMapBoolFixed325(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolFixed646(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolFloat7(populateBooleanMap(floatProvider));
+ builder.putAllFieldMapBoolInt328(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolInt649(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolMessage10(populateBooleanMap(messageProvider));
+ builder.putAllFieldMapBoolSfixed3211(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolSfixed6412(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolSint3213(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolSint6414(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolString15(populateBooleanMap(stringProvider));
+ builder.putAllFieldMapBoolUint3216(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolUint6417(populateBooleanMap(longProvider));
+ builder.putAllFieldMapFixed32Bool18(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapFixed32Bytes19(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapFixed32Double20(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapFixed32Enum21(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapFixed32Fixed3222(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Fixed6423(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Float24(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapFixed32Int3225(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Int6426(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Message27(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapFixed32Sfixed3228(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Sfixed6429(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Sint3230(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Sint6431(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32String32(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapFixed32Uint3233(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Uint6434(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed64Bool35(populateLongMap(booleanProvider));
+ builder.putAllFieldMapFixed64Bytes36(populateLongMap(bytesProvider));
+ builder.putAllFieldMapFixed64Double37(populateLongMap(doubleProvider));
+ builder.putAllFieldMapFixed64Enum38(populateLongMap(enumProvider));
+ builder.putAllFieldMapFixed64Fixed3239(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Fixed6440(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Float41(populateLongMap(floatProvider));
+ builder.putAllFieldMapFixed64Int3242(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Int6443(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Message44(populateLongMap(messageProvider));
+ builder.putAllFieldMapFixed64Sfixed3245(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Sfixed6446(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Sint3247(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Sint6448(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64String49(populateLongMap(stringProvider));
+ builder.putAllFieldMapFixed64Uint3250(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Uint6451(populateLongMap(longProvider));
+ builder.putAllFieldMapInt32Bool52(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapInt32Bytes53(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapInt32Double54(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapInt32Enum55(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapInt32Fixed3256(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Fixed6457(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Float58(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapInt32Int3259(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Int6460(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Message61(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapInt32Sfixed3262(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Sfixed6463(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Sint3264(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Sint6465(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32String66(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapInt32Uint3267(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Uint6468(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt64Bool69(populateLongMap(booleanProvider));
+ builder.putAllFieldMapInt64Bytes70(populateLongMap(bytesProvider));
+ builder.putAllFieldMapInt64Double71(populateLongMap(doubleProvider));
+ builder.putAllFieldMapInt64Enum72(populateLongMap(enumProvider));
+ builder.putAllFieldMapInt64Fixed3273(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Fixed6474(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Float75(populateLongMap(floatProvider));
+ builder.putAllFieldMapInt64Int3276(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Int6477(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Message78(populateLongMap(messageProvider));
+ builder.putAllFieldMapInt64Sfixed3279(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Sfixed6480(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Sint3281(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Sint6482(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64String83(populateLongMap(stringProvider));
+ builder.putAllFieldMapInt64Uint3284(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Uint6485(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed32Bool86(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapSfixed32Bytes87(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapSfixed32Double88(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapSfixed32Enum89(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapSfixed32Fixed3290(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Fixed6491(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Float92(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapSfixed32Int3293(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Int6494(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Message95(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapSfixed32Sfixed3296(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Sfixed6497(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Sint3298(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Sint6499(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32String100(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapSfixed32Uint32101(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Uint64102(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed64Bool103(populateLongMap(booleanProvider));
+ builder.putAllFieldMapSfixed64Bytes104(populateLongMap(bytesProvider));
+ builder.putAllFieldMapSfixed64Double105(populateLongMap(doubleProvider));
+ builder.putAllFieldMapSfixed64Enum106(populateLongMap(enumProvider));
+ builder.putAllFieldMapSfixed64Fixed32107(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Fixed64108(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Float109(populateLongMap(floatProvider));
+ builder.putAllFieldMapSfixed64Int32110(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Int64111(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Message112(populateLongMap(messageProvider));
+ builder.putAllFieldMapSfixed64Sfixed32113(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Sfixed64114(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Sint32115(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Sint64116(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64String117(populateLongMap(stringProvider));
+ builder.putAllFieldMapSfixed64Uint32118(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Uint64119(populateLongMap(longProvider));
+ builder.putAllFieldMapSint32Bool120(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapSint32Bytes121(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapSint32Double122(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapSint32Enum123(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapSint32Fixed32124(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Fixed64125(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Float126(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapSint32Int32127(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Int64128(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Message129(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapSint32Sfixed32130(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Sfixed64131(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Sint32132(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Sint64133(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32String134(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapSint32Uint32135(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Uint64136(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint64Bool137(populateLongMap(booleanProvider));
+ builder.putAllFieldMapSint64Bytes138(populateLongMap(bytesProvider));
+ builder.putAllFieldMapSint64Double139(populateLongMap(doubleProvider));
+ builder.putAllFieldMapSint64Enum140(populateLongMap(enumProvider));
+ builder.putAllFieldMapSint64Fixed32141(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Fixed64142(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Float143(populateLongMap(floatProvider));
+ builder.putAllFieldMapSint64Int32144(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Int64145(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Message146(populateLongMap(messageProvider));
+ builder.putAllFieldMapSint64Sfixed32147(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Sfixed64148(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Sint32149(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Sint64150(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64String151(populateLongMap(stringProvider));
+ builder.putAllFieldMapSint64Uint32152(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Uint64153(populateLongMap(longProvider));
+ builder.putAllFieldMapStringBool154(populateStringMap(booleanProvider));
+ builder.putAllFieldMapStringBytes155(populateStringMap(bytesProvider));
+ builder.putAllFieldMapStringDouble156(populateStringMap(doubleProvider));
+ builder.putAllFieldMapStringEnum157(populateStringMap(enumProvider));
+ builder.putAllFieldMapStringFixed32158(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringFixed64159(populateStringMap(longProvider));
+ builder.putAllFieldMapStringFloat160(populateStringMap(floatProvider));
+ builder.putAllFieldMapStringInt32161(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringInt64162(populateStringMap(longProvider));
+ builder.putAllFieldMapStringMessage163(populateStringMap(messageProvider));
+ builder.putAllFieldMapStringSfixed32164(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringSfixed64165(populateStringMap(longProvider));
+ builder.putAllFieldMapStringSint32166(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringSint64167(populateStringMap(longProvider));
+ builder.putAllFieldMapStringString168(populateStringMap(stringProvider));
+ builder.putAllFieldMapStringUint32169(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringUint64170(populateStringMap(longProvider));
+ builder.putAllFieldMapUint32Bool171(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapUint32Bytes172(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapUint32Double173(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapUint32Enum174(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapUint32Fixed32175(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Fixed64176(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Float177(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapUint32Int32178(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Int64179(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Message180(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapUint32Sfixed32181(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Sfixed64182(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Sint32183(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Sint64184(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32String185(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapUint32Uint32186(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Uint64187(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint64Bool188(populateLongMap(booleanProvider));
+ builder.putAllFieldMapUint64Bytes189(populateLongMap(bytesProvider));
+ builder.putAllFieldMapUint64Double190(populateLongMap(doubleProvider));
+ builder.putAllFieldMapUint64Enum191(populateLongMap(enumProvider));
+ builder.putAllFieldMapUint64Fixed32192(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Fixed64193(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Float194(populateLongMap(floatProvider));
+ builder.putAllFieldMapUint64Int32195(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Int64196(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Message197(populateLongMap(messageProvider));
+ builder.putAllFieldMapUint64Sfixed32198(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Sfixed64199(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Sint32200(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Sint64201(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64String202(populateLongMap(stringProvider));
+ builder.putAllFieldMapUint64Uint32203(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Uint64204(populateLongMap(longProvider));
+
+ return builder.build();
+ }
+
+ public List<Proto2MessageLite> newMessagesMissingRequiredFields() {
+ List<Proto2MessageLite> results = new ArrayList<>();
+ for (int i = 71; i <= 88; ++i) {
+ Proto2MessageLite.Builder builder = Proto2MessageLite.newBuilder();
+ populateRequiredFields(builder, i);
+ results.add(builder.buildPartial());
+ }
+ {
+ // A nested optional message field is missing required fields.
+ Proto2MessageLite.Builder builder = Proto2MessageLite.newBuilder();
+ populateRequiredFields(builder, INCLUDE_ALL_REQUIRED_FIELDS);
+ builder.setFieldMessage10(Proto2MessageLite.getDefaultInstance());
+ results.add(builder.buildPartial());
+ }
+ {
+ // A nested repeated message field is missing required fields.
+ Proto2MessageLite.Builder builder = Proto2MessageLite.newBuilder();
+ populateRequiredFields(builder, INCLUDE_ALL_REQUIRED_FIELDS);
+ builder.addFieldMessageList27(Proto2MessageLite.getDefaultInstance());
+ results.add(builder.buildPartial());
+ }
+ {
+ // A nested oneof message field is missing required fields.
+ Proto2MessageLite.Builder builder = Proto2MessageLite.newBuilder();
+ populateRequiredFields(builder, INCLUDE_ALL_REQUIRED_FIELDS);
+ builder.setFieldMessage62(Proto2MessageLite.getDefaultInstance());
+ results.add(builder.buildPartial());
+ }
+ return results;
+ }
+
+ // 0 is not a valid field number so we use it to mean no fields are excluded.
+ private static final int INCLUDE_ALL_REQUIRED_FIELDS = 0;
+
+ private void populateRequiredFields(Proto2MessageLite.Builder builder, int excludedFieldNumber) {
+ if (excludedFieldNumber != 71) {
+ builder.setFieldRequiredDouble71(data.getDouble());
+ }
+ if (excludedFieldNumber != 72) {
+ builder.setFieldRequiredFloat72(data.getFloat());
+ }
+ if (excludedFieldNumber != 73) {
+ builder.setFieldRequiredInt6473(data.getLong());
+ }
+ if (excludedFieldNumber != 74) {
+ builder.setFieldRequiredUint6474(data.getLong());
+ }
+ if (excludedFieldNumber != 75) {
+ builder.setFieldRequiredInt3275(data.getInt());
+ }
+ if (excludedFieldNumber != 76) {
+ builder.setFieldRequiredFixed6476(data.getLong());
+ }
+ if (excludedFieldNumber != 77) {
+ builder.setFieldRequiredFixed3277(data.getInt());
+ }
+ if (excludedFieldNumber != 78) {
+ builder.setFieldRequiredBool78(data.getBool());
+ }
+ if (excludedFieldNumber != 79) {
+ builder.setFieldRequiredString79(data.getString());
+ }
+ if (excludedFieldNumber != 80) {
+ builder.setFieldRequiredMessage80(
+ Proto2MessageLite.RequiredNestedMessage.newBuilder().setValue(data.getInt()));
+ }
+ if (excludedFieldNumber != 81) {
+ builder.setFieldRequiredBytes81(data.getBytes());
+ }
+ if (excludedFieldNumber != 82) {
+ builder.setFieldRequiredUint3282(data.getInt());
+ }
+ if (excludedFieldNumber != 83) {
+ builder.setFieldRequiredEnum83(Proto2MessageLite.TestEnum.forNumber(data.getEnum()));
+ }
+ if (excludedFieldNumber != 84) {
+ builder.setFieldRequiredSfixed3284(data.getInt());
+ }
+ if (excludedFieldNumber != 85) {
+ builder.setFieldRequiredSfixed6485(data.getLong());
+ }
+ if (excludedFieldNumber != 86) {
+ builder.setFieldRequiredSint3286(data.getInt());
+ }
+ if (excludedFieldNumber != 87) {
+ builder.setFieldRequiredSint6487(data.getLong());
+ }
+ if (excludedFieldNumber != 88) {
+ builder.setFieldRequiredGroup88(
+ Proto2MessageLite.FieldRequiredGroup88.newBuilder().setFieldInt3289(data.getInt()));
+ }
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto2SchemaTest.java b/java/core/src/test/java/com/google/protobuf/Proto2SchemaTest.java
new file mode 100755
index 0000000..098e7fe
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto2SchemaTest.java
@@ -0,0 +1,49 @@
+// 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.testing.Proto2Testing.Proto2Message;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class Proto2SchemaTest extends AbstractProto2SchemaTest {
+
+ @Override
+ protected Schema<Proto2Message> schema() {
+ return TestSchemas.genericProto2Schema;
+ }
+
+ @Override
+ protected void registerSchemas() {
+ TestSchemas.registerGenericProto2Schemas();
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto2UnknownEnumValueTest.java b/java/core/src/test/java/com/google/protobuf/Proto2UnknownEnumValueTest.java
new file mode 100755
index 0000000..57ac069
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto2UnknownEnumValueTest.java
@@ -0,0 +1,111 @@
+// 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.Descriptors.FieldDescriptor;
+import protobuf_unittest.UnittestProto;
+import protobuf_unittest.UnittestProto.TestAllExtensions;
+import protobuf_unittest.UnittestProto.TestAllTypes;
+import junit.framework.TestCase;
+
+/** Unit tests for proto2 that treats unknown enum values as unknown fields. */
+public class Proto2UnknownEnumValueTest extends TestCase {
+ FieldDescriptor singularField =
+ TestAllTypes.getDescriptor().findFieldByName("optional_nested_enum");
+ FieldDescriptor repeatedField =
+ TestAllTypes.getDescriptor().findFieldByName("repeated_nested_enum");
+ byte[] payload = buildPayloadWithUnknownEnumValues();
+
+ private byte[] buildPayloadWithUnknownEnumValues() {
+ // Builds a payload with unknown enum values.
+ UnknownFieldSet.Builder builder = UnknownFieldSet.newBuilder();
+ builder.addField(
+ singularField.getNumber(),
+ UnknownFieldSet.Field.newBuilder()
+ .addVarint(TestAllTypes.NestedEnum.BAR.getNumber())
+ .addVarint(1901 /* unknown enum value */)
+ .build());
+ builder.addField(
+ repeatedField.getNumber(),
+ UnknownFieldSet.Field.newBuilder()
+ .addVarint(TestAllTypes.NestedEnum.FOO.getNumber())
+ .addVarint(1902 /* unknown enum value */)
+ .addVarint(TestAllTypes.NestedEnum.BAZ.getNumber())
+ .addVarint(1903 /* unknown enum value */)
+ .build());
+ return builder.build().toByteArray();
+ }
+
+ public void testUnknownEnumValues() throws Exception {
+ TestAllTypes message = TestAllTypes.parseFrom(payload);
+
+ // Known enum values should be preserved.
+ assertEquals(TestAllTypes.NestedEnum.BAR, message.getOptionalNestedEnum());
+ assertEquals(2, message.getRepeatedNestedEnumList().size());
+ assertEquals(TestAllTypes.NestedEnum.FOO, message.getRepeatedNestedEnum(0));
+ assertEquals(TestAllTypes.NestedEnum.BAZ, message.getRepeatedNestedEnum(1));
+
+ // Unknown enum values should be found in UnknownFieldSet.
+ UnknownFieldSet unknown = message.getUnknownFields();
+ assertEquals(
+ 1901, unknown.getField(singularField.getNumber()).getVarintList().get(0).longValue());
+ assertEquals(
+ 1902, unknown.getField(repeatedField.getNumber()).getVarintList().get(0).longValue());
+ assertEquals(
+ 1903, unknown.getField(repeatedField.getNumber()).getVarintList().get(1).longValue());
+ }
+
+ public void testExtensionUnknownEnumValues() throws Exception {
+ ExtensionRegistry registry = ExtensionRegistry.newInstance();
+ UnittestProto.registerAllExtensions(registry);
+ TestAllExtensions message = TestAllExtensions.parseFrom(payload, registry);
+
+ assertEquals(
+ TestAllTypes.NestedEnum.BAR,
+ message.getExtension(UnittestProto.optionalNestedEnumExtension));
+ assertEquals(2, message.getExtension(UnittestProto.repeatedNestedEnumExtension).size());
+ assertEquals(
+ TestAllTypes.NestedEnum.FOO,
+ message.getExtension(UnittestProto.repeatedNestedEnumExtension, 0));
+ assertEquals(
+ TestAllTypes.NestedEnum.BAZ,
+ message.getExtension(UnittestProto.repeatedNestedEnumExtension, 1));
+
+ // Unknown enum values should be found in UnknownFieldSet.
+ UnknownFieldSet unknown = message.getUnknownFields();
+ assertEquals(
+ 1901, unknown.getField(singularField.getNumber()).getVarintList().get(0).longValue());
+ assertEquals(
+ 1902, unknown.getField(repeatedField.getNumber()).getVarintList().get(0).longValue());
+ assertEquals(
+ 1903, unknown.getField(repeatedField.getNumber()).getVarintList().get(1).longValue());
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto3LiteSchemaTest.java b/java/core/src/test/java/com/google/protobuf/Proto3LiteSchemaTest.java
new file mode 100755
index 0000000..ac9d6df
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto3LiteSchemaTest.java
@@ -0,0 +1,49 @@
+// 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.testing.Proto3TestingLite.Proto3MessageLite;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class Proto3LiteSchemaTest extends AbstractProto3LiteSchemaTest {
+
+ @Override
+ protected Schema<Proto3MessageLite> schema() {
+ return TestSchemasLite.genericProto3LiteSchema;
+ }
+
+ @Override
+ protected void registerSchemas() {
+ TestSchemasLite.registerGenericProto3LiteSchemas();
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto3MessageFactory.java b/java/core/src/test/java/com/google/protobuf/Proto3MessageFactory.java
new file mode 100755
index 0000000..33d5fe0
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto3MessageFactory.java
@@ -0,0 +1,450 @@
+// 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.testing.Proto3Testing.Proto3Message;
+import com.google.protobuf.testing.Proto3Testing.Proto3MessageWithMaps;
+import java.util.HashMap;
+import java.util.Map;
+
+/** Creates instances of {@link Proto3Message} based on the tree configuration. */
+public final class Proto3MessageFactory implements ExperimentalMessageFactory<Proto3Message> {
+ private final int numRepeatedFields;
+ private final int branchingFactor;
+ private final Proto3MessageFactory nextLevel;
+ private final ExperimentalTestDataProvider data;
+
+ public Proto3MessageFactory(
+ int numRepeatedFields, int stringLength, int branchingFactor, int treeDepth) {
+ this(
+ new ExperimentalTestDataProvider(stringLength),
+ numRepeatedFields,
+ branchingFactor,
+ treeDepth);
+ }
+
+ private Proto3MessageFactory(
+ ExperimentalTestDataProvider data,
+ int numRepeatedFields,
+ int branchingFactor,
+ int treeDepth) {
+ this.numRepeatedFields = numRepeatedFields;
+ this.branchingFactor = branchingFactor;
+ this.data = data;
+ if (treeDepth > 0) {
+ nextLevel = new Proto3MessageFactory(data, numRepeatedFields, branchingFactor, treeDepth - 1);
+ } else {
+ nextLevel = null;
+ }
+ }
+
+ @Override
+ public ExperimentalTestDataProvider dataProvider() {
+ return data;
+ }
+
+ @Override
+ public Proto3Message newMessage() {
+ Proto3Message.Builder builder = Proto3Message.newBuilder();
+ builder.setFieldDouble1(data.getDouble());
+ builder.setFieldFloat2(data.getFloat());
+ builder.setFieldInt643(data.getLong());
+ builder.setFieldUint644(data.getLong());
+ builder.setFieldInt325(data.getInt());
+ builder.setFieldFixed646(data.getLong());
+ builder.setFieldFixed327(data.getInt());
+ builder.setFieldBool8(data.getBool());
+ builder.setFieldString9(data.getString());
+ // We don't populate the message field. Instead we apply the branching factor to the
+ // repeated message field below.
+ builder.setFieldBytes11(data.getBytes());
+ builder.setFieldUint3212(data.getInt());
+ builder.setFieldEnum13Value(data.getEnum());
+ builder.setFieldSfixed3214(data.getInt());
+ builder.setFieldSfixed6415(data.getLong());
+ builder.setFieldSint3216(data.getInt());
+ builder.setFieldSint6417(data.getLong());
+
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ builder.addFieldDoubleList18(data.getDouble());
+ builder.addFieldFloatList19(data.getFloat());
+ builder.addFieldInt64List20(data.getLong());
+ builder.addFieldUint64List21(data.getLong());
+ builder.addFieldInt32List22(data.getInt());
+ builder.addFieldFixed64List23(data.getLong());
+ builder.addFieldFixed32List24(data.getInt());
+ builder.addFieldBoolList25(data.getBool());
+ builder.addFieldStringList26(data.getString());
+ // Repeated message field is controlled by the branching factor below.
+ builder.addFieldBytesList28(data.getBytes());
+ builder.addFieldUint32List29(data.getInt());
+ builder.addFieldEnumList30Value(data.getEnum());
+ builder.addFieldSfixed32List31(data.getInt());
+ builder.addFieldSfixed64List32(data.getLong());
+ builder.addFieldSint32List33(data.getInt());
+ builder.addFieldSint64List34(data.getLong());
+
+ builder.addFieldDoubleListPacked35(data.getDouble());
+ builder.addFieldFloatListPacked36(data.getFloat());
+ builder.addFieldInt64ListPacked37(data.getLong());
+ builder.addFieldUint64ListPacked38(data.getLong());
+ builder.addFieldInt32ListPacked39(data.getInt());
+ builder.addFieldFixed64ListPacked40(data.getLong());
+ builder.addFieldFixed32ListPacked41(data.getInt());
+ builder.addFieldBoolListPacked42(data.getBool());
+ builder.addFieldUint32ListPacked43(data.getInt());
+ builder.addFieldEnumListPacked44Value(data.getEnum());
+ builder.addFieldSfixed32ListPacked45(data.getInt());
+ builder.addFieldSfixed64ListPacked46(data.getLong());
+ builder.addFieldSint32ListPacked47(data.getInt());
+ builder.addFieldSint64ListPacked48(data.getLong());
+ }
+
+ // Handle the branching factor.
+ if (nextLevel != null) {
+ for (int i = 0; i < branchingFactor; ++i) {
+ builder.addFieldMessageList27(nextLevel.newMessage());
+ }
+ }
+
+ return builder.build();
+ }
+
+ private interface MapValueProvider<T> {
+ public T getValue();
+ }
+
+ private final MapValueProvider<Integer> integerProvider =
+ new MapValueProvider<Integer>() {
+ @Override
+ public Integer getValue() {
+ return data.getInt();
+ }
+ };
+ private final MapValueProvider<Long> longProvider =
+ new MapValueProvider<Long>() {
+ @Override
+ public Long getValue() {
+ return data.getLong();
+ }
+ };
+ private final MapValueProvider<String> stringProvider =
+ new MapValueProvider<String>() {
+ @Override
+ public String getValue() {
+ return data.getString();
+ }
+ };
+ private final MapValueProvider<ByteString> bytesProvider =
+ new MapValueProvider<ByteString>() {
+ @Override
+ public ByteString getValue() {
+ return data.getBytes();
+ }
+ };
+ private final MapValueProvider<Boolean> booleanProvider =
+ new MapValueProvider<Boolean>() {
+ @Override
+ public Boolean getValue() {
+ return data.getBool();
+ }
+ };
+ private final MapValueProvider<Float> floatProvider =
+ new MapValueProvider<Float>() {
+ @Override
+ public Float getValue() {
+ return data.getFloat();
+ }
+ };
+ private final MapValueProvider<Double> doubleProvider =
+ new MapValueProvider<Double>() {
+ @Override
+ public Double getValue() {
+ return data.getDouble();
+ }
+ };
+ private final MapValueProvider<Proto3Message> messageProvider =
+ new MapValueProvider<Proto3Message>() {
+ @Override
+ public Proto3Message getValue() {
+ return newMessage();
+ }
+ };
+ private final MapValueProvider<Proto3Message.TestEnum> enumProvider =
+ new MapValueProvider<Proto3Message.TestEnum>() {
+ @Override
+ public Proto3Message.TestEnum getValue() {
+ return Proto3Message.TestEnum.forNumber(data.getEnum());
+ }
+ };
+
+ private <V> Map<Integer, V> populateIntegerMap(MapValueProvider<V> provider) {
+ Map<Integer, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getInt(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<Long, V> populateLongMap(MapValueProvider<V> provider) {
+ Map<Long, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getLong(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<String, V> populateStringMap(MapValueProvider<V> provider) {
+ Map<String, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getString(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<Boolean, V> populateBooleanMap(MapValueProvider<V> provider) {
+ Map<Boolean, V> map = new HashMap<>();
+ map.put(false, provider.getValue());
+ map.put(true, provider.getValue());
+ return map;
+ }
+
+ public Proto3MessageWithMaps newMessageWithMaps() {
+ Proto3MessageWithMaps.Builder builder = Proto3MessageWithMaps.newBuilder();
+
+ builder.putAllFieldMapBoolBool1(populateBooleanMap(booleanProvider));
+ builder.putAllFieldMapBoolBytes2(populateBooleanMap(bytesProvider));
+ builder.putAllFieldMapBoolDouble3(populateBooleanMap(doubleProvider));
+ builder.putAllFieldMapBoolEnum4(populateBooleanMap(enumProvider));
+ builder.putAllFieldMapBoolFixed325(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolFixed646(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolFloat7(populateBooleanMap(floatProvider));
+ builder.putAllFieldMapBoolInt328(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolInt649(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolMessage10(populateBooleanMap(messageProvider));
+ builder.putAllFieldMapBoolSfixed3211(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolSfixed6412(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolSint3213(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolSint6414(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolString15(populateBooleanMap(stringProvider));
+ builder.putAllFieldMapBoolUint3216(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolUint6417(populateBooleanMap(longProvider));
+ builder.putAllFieldMapFixed32Bool18(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapFixed32Bytes19(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapFixed32Double20(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapFixed32Enum21(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapFixed32Fixed3222(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Fixed6423(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Float24(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapFixed32Int3225(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Int6426(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Message27(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapFixed32Sfixed3228(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Sfixed6429(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Sint3230(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Sint6431(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32String32(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapFixed32Uint3233(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Uint6434(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed64Bool35(populateLongMap(booleanProvider));
+ builder.putAllFieldMapFixed64Bytes36(populateLongMap(bytesProvider));
+ builder.putAllFieldMapFixed64Double37(populateLongMap(doubleProvider));
+ builder.putAllFieldMapFixed64Enum38(populateLongMap(enumProvider));
+ builder.putAllFieldMapFixed64Fixed3239(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Fixed6440(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Float41(populateLongMap(floatProvider));
+ builder.putAllFieldMapFixed64Int3242(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Int6443(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Message44(populateLongMap(messageProvider));
+ builder.putAllFieldMapFixed64Sfixed3245(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Sfixed6446(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Sint3247(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Sint6448(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64String49(populateLongMap(stringProvider));
+ builder.putAllFieldMapFixed64Uint3250(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Uint6451(populateLongMap(longProvider));
+ builder.putAllFieldMapInt32Bool52(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapInt32Bytes53(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapInt32Double54(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapInt32Enum55(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapInt32Fixed3256(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Fixed6457(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Float58(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapInt32Int3259(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Int6460(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Message61(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapInt32Sfixed3262(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Sfixed6463(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Sint3264(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Sint6465(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32String66(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapInt32Uint3267(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Uint6468(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt64Bool69(populateLongMap(booleanProvider));
+ builder.putAllFieldMapInt64Bytes70(populateLongMap(bytesProvider));
+ builder.putAllFieldMapInt64Double71(populateLongMap(doubleProvider));
+ builder.putAllFieldMapInt64Enum72(populateLongMap(enumProvider));
+ builder.putAllFieldMapInt64Fixed3273(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Fixed6474(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Float75(populateLongMap(floatProvider));
+ builder.putAllFieldMapInt64Int3276(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Int6477(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Message78(populateLongMap(messageProvider));
+ builder.putAllFieldMapInt64Sfixed3279(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Sfixed6480(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Sint3281(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Sint6482(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64String83(populateLongMap(stringProvider));
+ builder.putAllFieldMapInt64Uint3284(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Uint6485(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed32Bool86(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapSfixed32Bytes87(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapSfixed32Double88(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapSfixed32Enum89(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapSfixed32Fixed3290(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Fixed6491(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Float92(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapSfixed32Int3293(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Int6494(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Message95(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapSfixed32Sfixed3296(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Sfixed6497(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Sint3298(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Sint6499(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32String100(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapSfixed32Uint32101(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Uint64102(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed64Bool103(populateLongMap(booleanProvider));
+ builder.putAllFieldMapSfixed64Bytes104(populateLongMap(bytesProvider));
+ builder.putAllFieldMapSfixed64Double105(populateLongMap(doubleProvider));
+ builder.putAllFieldMapSfixed64Enum106(populateLongMap(enumProvider));
+ builder.putAllFieldMapSfixed64Fixed32107(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Fixed64108(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Float109(populateLongMap(floatProvider));
+ builder.putAllFieldMapSfixed64Int32110(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Int64111(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Message112(populateLongMap(messageProvider));
+ builder.putAllFieldMapSfixed64Sfixed32113(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Sfixed64114(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Sint32115(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Sint64116(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64String117(populateLongMap(stringProvider));
+ builder.putAllFieldMapSfixed64Uint32118(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Uint64119(populateLongMap(longProvider));
+ builder.putAllFieldMapSint32Bool120(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapSint32Bytes121(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapSint32Double122(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapSint32Enum123(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapSint32Fixed32124(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Fixed64125(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Float126(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapSint32Int32127(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Int64128(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Message129(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapSint32Sfixed32130(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Sfixed64131(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Sint32132(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Sint64133(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32String134(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapSint32Uint32135(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Uint64136(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint64Bool137(populateLongMap(booleanProvider));
+ builder.putAllFieldMapSint64Bytes138(populateLongMap(bytesProvider));
+ builder.putAllFieldMapSint64Double139(populateLongMap(doubleProvider));
+ builder.putAllFieldMapSint64Enum140(populateLongMap(enumProvider));
+ builder.putAllFieldMapSint64Fixed32141(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Fixed64142(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Float143(populateLongMap(floatProvider));
+ builder.putAllFieldMapSint64Int32144(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Int64145(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Message146(populateLongMap(messageProvider));
+ builder.putAllFieldMapSint64Sfixed32147(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Sfixed64148(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Sint32149(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Sint64150(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64String151(populateLongMap(stringProvider));
+ builder.putAllFieldMapSint64Uint32152(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Uint64153(populateLongMap(longProvider));
+ builder.putAllFieldMapStringBool154(populateStringMap(booleanProvider));
+ builder.putAllFieldMapStringBytes155(populateStringMap(bytesProvider));
+ builder.putAllFieldMapStringDouble156(populateStringMap(doubleProvider));
+ builder.putAllFieldMapStringEnum157(populateStringMap(enumProvider));
+ builder.putAllFieldMapStringFixed32158(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringFixed64159(populateStringMap(longProvider));
+ builder.putAllFieldMapStringFloat160(populateStringMap(floatProvider));
+ builder.putAllFieldMapStringInt32161(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringInt64162(populateStringMap(longProvider));
+ builder.putAllFieldMapStringMessage163(populateStringMap(messageProvider));
+ builder.putAllFieldMapStringSfixed32164(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringSfixed64165(populateStringMap(longProvider));
+ builder.putAllFieldMapStringSint32166(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringSint64167(populateStringMap(longProvider));
+ builder.putAllFieldMapStringString168(populateStringMap(stringProvider));
+ builder.putAllFieldMapStringUint32169(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringUint64170(populateStringMap(longProvider));
+ builder.putAllFieldMapUint32Bool171(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapUint32Bytes172(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapUint32Double173(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapUint32Enum174(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapUint32Fixed32175(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Fixed64176(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Float177(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapUint32Int32178(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Int64179(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Message180(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapUint32Sfixed32181(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Sfixed64182(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Sint32183(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Sint64184(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32String185(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapUint32Uint32186(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Uint64187(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint64Bool188(populateLongMap(booleanProvider));
+ builder.putAllFieldMapUint64Bytes189(populateLongMap(bytesProvider));
+ builder.putAllFieldMapUint64Double190(populateLongMap(doubleProvider));
+ builder.putAllFieldMapUint64Enum191(populateLongMap(enumProvider));
+ builder.putAllFieldMapUint64Fixed32192(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Fixed64193(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Float194(populateLongMap(floatProvider));
+ builder.putAllFieldMapUint64Int32195(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Int64196(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Message197(populateLongMap(messageProvider));
+ builder.putAllFieldMapUint64Sfixed32198(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Sfixed64199(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Sint32200(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Sint64201(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64String202(populateLongMap(stringProvider));
+ builder.putAllFieldMapUint64Uint32203(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Uint64204(populateLongMap(longProvider));
+
+ return builder.build();
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto3MessageInfoFactory.java b/java/core/src/test/java/com/google/protobuf/Proto3MessageInfoFactory.java
new file mode 100755
index 0000000..364071b
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto3MessageInfoFactory.java
@@ -0,0 +1,506 @@
+// 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.forMapField;
+import static com.google.protobuf.FieldInfo.forOneofMemberField;
+import static com.google.protobuf.FieldInfo.forRepeatedMessageField;
+
+import com.google.protobuf.testing.Proto2Testing.Proto2MessageWithMaps;
+import com.google.protobuf.testing.Proto3Testing.Proto3Empty;
+import com.google.protobuf.testing.Proto3Testing.Proto3Message;
+import com.google.protobuf.testing.Proto3Testing.Proto3MessageWithMaps;
+import java.lang.reflect.Field;
+
+/** A factory that generates a hard-coded info for {@link Proto3Message}. */
+public final class Proto3MessageInfoFactory implements MessageInfoFactory {
+ private static final Proto3MessageInfoFactory INSTANCE = new Proto3MessageInfoFactory();
+
+ private Proto3MessageInfoFactory() {}
+
+ public static Proto3MessageInfoFactory getInstance() {
+ return INSTANCE;
+ }
+
+ @Override
+ public boolean isSupported(Class<?> clazz) {
+ return true;
+ }
+
+ @Override
+ public MessageInfo messageInfoFor(Class<?> clazz) {
+ if (Proto3Message.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto3Message();
+ } else if (Proto3Empty.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto3Empty();
+ } else if (Proto3MessageWithMaps.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto3MessageWithMaps();
+ } else {
+ throw new IllegalArgumentException("Unsupported class: " + clazz.getName());
+ }
+ }
+
+ /**
+ * Creates a new hard-coded info for {@link Proto3Message}. Each time this is called, we manually
+ * go through the entire process of what a message would do if it self-registered its own info,
+ * including looking up each field by name. This is done for benchmarking purposes, so that we get
+ * a more accurate representation of the time it takes to perform this process.
+ */
+ private static StructuralMessageInfo newMessageInfoForProto3Message() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(48);
+ lookupFieldsByName(builder);
+ return builder.build();
+ }
+
+ private static void lookupFieldsByName(StructuralMessageInfo.Builder builder) {
+ builder.withDefaultInstance(Proto3Message.getDefaultInstance());
+ builder.withSyntax(ProtoSyntax.PROTO3);
+ builder.withField(forField(field("fieldDouble1_"), 1, FieldType.DOUBLE, true));
+ builder.withField(forField(field("fieldFloat2_"), 2, FieldType.FLOAT, true));
+ builder.withField(forField(field("fieldInt643_"), 3, FieldType.INT64, true));
+ builder.withField(forField(field("fieldUint644_"), 4, FieldType.UINT64, true));
+ builder.withField(forField(field("fieldInt325_"), 5, FieldType.INT32, true));
+ builder.withField(forField(field("fieldFixed646_"), 6, FieldType.FIXED64, true));
+ builder.withField(forField(field("fieldFixed327_"), 7, FieldType.FIXED32, true));
+ builder.withField(forField(field("fieldBool8_"), 8, FieldType.BOOL, true));
+ builder.withField(forField(field("fieldString9_"), 9, FieldType.STRING, true));
+ builder.withField(forField(field("fieldMessage10_"), 10, FieldType.MESSAGE, true));
+ builder.withField(forField(field("fieldBytes11_"), 11, FieldType.BYTES, true));
+ builder.withField(forField(field("fieldUint3212_"), 12, FieldType.UINT32, true));
+ builder.withField(forField(field("fieldEnum13_"), 13, FieldType.ENUM, true));
+ builder.withField(forField(field("fieldSfixed3214_"), 14, FieldType.SFIXED32, true));
+ builder.withField(forField(field("fieldSfixed6415_"), 15, FieldType.SFIXED64, true));
+ builder.withField(forField(field("fieldSint3216_"), 16, FieldType.SINT32, true));
+ builder.withField(forField(field("fieldSint6417_"), 17, FieldType.SINT64, true));
+ builder.withField(forField(field("fieldDoubleList18_"), 18, FieldType.DOUBLE_LIST, true));
+ builder.withField(forField(field("fieldFloatList19_"), 19, FieldType.FLOAT_LIST, true));
+ builder.withField(forField(field("fieldInt64List20_"), 20, FieldType.INT64_LIST, true));
+ builder.withField(forField(field("fieldUint64List21_"), 21, FieldType.UINT64_LIST, true));
+ builder.withField(forField(field("fieldInt32List22_"), 22, FieldType.INT32_LIST, true));
+ builder.withField(forField(field("fieldFixed64List23_"), 23, FieldType.FIXED64_LIST, true));
+ builder.withField(forField(field("fieldFixed32List24_"), 24, FieldType.FIXED32_LIST, true));
+ builder.withField(forField(field("fieldBoolList25_"), 25, FieldType.BOOL_LIST, true));
+ builder.withField(forField(field("fieldStringList26_"), 26, FieldType.STRING_LIST, true));
+ builder.withField(
+ forRepeatedMessageField(
+ field("fieldMessageList27_"), 27, FieldType.MESSAGE_LIST, Proto3Message.class));
+ builder.withField(forField(field("fieldBytesList28_"), 28, FieldType.BYTES_LIST, true));
+ builder.withField(forField(field("fieldUint32List29_"), 29, FieldType.UINT32_LIST, true));
+ builder.withField(forField(field("fieldEnumList30_"), 30, FieldType.ENUM_LIST, true));
+ builder.withField(forField(field("fieldSfixed32List31_"), 31, FieldType.SFIXED32_LIST, true));
+ builder.withField(forField(field("fieldSfixed64List32_"), 32, FieldType.SFIXED64_LIST, true));
+ builder.withField(forField(field("fieldSint32List33_"), 33, FieldType.SINT32_LIST, true));
+ builder.withField(forField(field("fieldSint64List34_"), 34, FieldType.SINT64_LIST, true));
+ builder.withField(
+ forField(field("fieldDoubleListPacked35_"), 35, FieldType.DOUBLE_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldFloatListPacked36_"), 36, FieldType.FLOAT_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldInt64ListPacked37_"), 37, FieldType.INT64_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldUint64ListPacked38_"), 38, FieldType.UINT64_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldInt32ListPacked39_"), 39, FieldType.INT32_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldFixed64ListPacked40_"), 40, FieldType.FIXED64_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldFixed32ListPacked41_"), 41, FieldType.FIXED32_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldBoolListPacked42_"), 42, FieldType.BOOL_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldUint32ListPacked43_"), 43, FieldType.UINT32_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldEnumListPacked44_"), 44, FieldType.ENUM_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldSfixed32ListPacked45_"), 45, FieldType.SFIXED32_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldSfixed64ListPacked46_"), 46, FieldType.SFIXED64_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldSint32ListPacked47_"), 47, FieldType.SINT32_LIST_PACKED, true));
+ builder.withField(
+ forField(field("fieldSint64ListPacked48_"), 48, FieldType.SINT64_LIST_PACKED, true));
+
+ OneofInfo oneof = new OneofInfo(0, field("testOneofCase_"), field("testOneof_"));
+ builder.withField(forOneofMemberField(53, FieldType.DOUBLE, oneof, Double.class, true, null));
+ builder.withField(forOneofMemberField(54, FieldType.FLOAT, oneof, Float.class, true, null));
+ builder.withField(forOneofMemberField(55, FieldType.INT64, oneof, Long.class, true, null));
+ builder.withField(forOneofMemberField(56, FieldType.UINT64, oneof, Long.class, true, null));
+ builder.withField(forOneofMemberField(57, FieldType.INT32, oneof, Integer.class, true, null));
+ builder.withField(forOneofMemberField(58, FieldType.FIXED64, oneof, Long.class, true, null));
+ builder.withField(forOneofMemberField(59, FieldType.FIXED32, oneof, Integer.class, true, null));
+ builder.withField(forOneofMemberField(60, FieldType.BOOL, oneof, Boolean.class, true, null));
+ builder.withField(forOneofMemberField(61, FieldType.STRING, oneof, String.class, true, null));
+ builder.withField(
+ forOneofMemberField(62, FieldType.MESSAGE, oneof, Proto3Message.class, true, null));
+ builder.withField(
+ forOneofMemberField(63, FieldType.BYTES, oneof, ByteString.class, true, null));
+ builder.withField(forOneofMemberField(64, FieldType.UINT32, oneof, Integer.class, true, null));
+ builder.withField(
+ forOneofMemberField(65, FieldType.SFIXED32, oneof, Integer.class, true, null));
+ builder.withField(forOneofMemberField(66, FieldType.SFIXED64, oneof, Long.class, true, null));
+ builder.withField(forOneofMemberField(67, FieldType.SINT32, oneof, Integer.class, true, null));
+ builder.withField(forOneofMemberField(68, FieldType.SINT64, oneof, Long.class, true, null));
+ }
+
+ private StructuralMessageInfo newMessageInfoForProto3Empty() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO3);
+ return builder.build();
+ }
+
+ private StructuralMessageInfo newMessageInfoForProto3MessageWithMaps() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder();
+ builder.withSyntax(ProtoSyntax.PROTO3);
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_bool_1", 1));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_bytes_2", 2));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_double_3", 3));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_enum_4", 4));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_fixed32_5", 5));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_fixed64_6", 6));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_float_7", 7));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_int32_8", 8));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_int64_9", 9));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_message_10", 10));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_sfixed32_11", 11));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_sfixed64_12", 12));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_sint32_13", 13));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_sint64_14", 14));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_string_15", 15));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_uint32_16", 16));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_bool_uint64_17", 17));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_bool_18", 18));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_bytes_19", 19));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_double_20", 20));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_enum_21", 21));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_fixed32_22", 22));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_fixed64_23", 23));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_float_24", 24));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_int32_25", 25));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_int64_26", 26));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_message_27", 27));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_sfixed32_28", 28));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_sfixed64_29", 29));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_sint32_30", 30));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_sint64_31", 31));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_string_32", 32));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_uint32_33", 33));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed32_uint64_34", 34));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_bool_35", 35));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_bytes_36", 36));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_double_37", 37));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_enum_38", 38));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_fixed32_39", 39));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_fixed64_40", 40));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_float_41", 41));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_int32_42", 42));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_int64_43", 43));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_message_44", 44));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_sfixed32_45", 45));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_sfixed64_46", 46));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_sint32_47", 47));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_sint64_48", 48));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_string_49", 49));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_uint32_50", 50));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_fixed64_uint64_51", 51));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_bool_52", 52));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_bytes_53", 53));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_double_54", 54));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_enum_55", 55));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_fixed32_56", 56));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_fixed64_57", 57));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_float_58", 58));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_int32_59", 59));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_int64_60", 60));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_message_61", 61));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_sfixed32_62", 62));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_sfixed64_63", 63));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_sint32_64", 64));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_sint64_65", 65));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_string_66", 66));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_uint32_67", 67));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int32_uint64_68", 68));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_bool_69", 69));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_bytes_70", 70));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_double_71", 71));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_enum_72", 72));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_fixed32_73", 73));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_fixed64_74", 74));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_float_75", 75));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_int32_76", 76));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_int64_77", 77));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_message_78", 78));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_sfixed32_79", 79));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_sfixed64_80", 80));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_sint32_81", 81));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_sint64_82", 82));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_string_83", 83));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_uint32_84", 84));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_int64_uint64_85", 85));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_bool_86", 86));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_bytes_87", 87));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_double_88", 88));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_enum_89", 89));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_fixed32_90", 90));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_fixed64_91", 91));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_float_92", 92));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_int32_93", 93));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_int64_94", 94));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_message_95", 95));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_sfixed32_96", 96));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_sfixed64_97", 97));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_sint32_98", 98));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_sint64_99", 99));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_string_100", 100));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_uint32_101", 101));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed32_uint64_102", 102));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_bool_103", 103));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_bytes_104", 104));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_double_105", 105));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_enum_106", 106));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_fixed32_107", 107));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_fixed64_108", 108));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_float_109", 109));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_int32_110", 110));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_int64_111", 111));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_message_112", 112));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_sfixed32_113", 113));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_sfixed64_114", 114));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_sint32_115", 115));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_sint64_116", 116));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_string_117", 117));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_uint32_118", 118));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sfixed64_uint64_119", 119));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_bool_120", 120));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_bytes_121", 121));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_double_122", 122));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_enum_123", 123));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_fixed32_124", 124));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_fixed64_125", 125));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_float_126", 126));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_int32_127", 127));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_int64_128", 128));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_message_129", 129));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_sfixed32_130", 130));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_sfixed64_131", 131));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_sint32_132", 132));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_sint64_133", 133));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_string_134", 134));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_uint32_135", 135));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint32_uint64_136", 136));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_bool_137", 137));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_bytes_138", 138));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_double_139", 139));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_enum_140", 140));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_fixed32_141", 141));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_fixed64_142", 142));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_float_143", 143));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_int32_144", 144));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_int64_145", 145));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_message_146", 146));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_sfixed32_147", 147));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_sfixed64_148", 148));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_sint32_149", 149));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_sint64_150", 150));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_string_151", 151));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_uint32_152", 152));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_sint64_uint64_153", 153));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_bool_154", 154));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_bytes_155", 155));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_double_156", 156));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_enum_157", 157));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_fixed32_158", 158));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_fixed64_159", 159));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_float_160", 160));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_int32_161", 161));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_int64_162", 162));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_message_163", 163));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_sfixed32_164", 164));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_sfixed64_165", 165));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_sint32_166", 166));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_sint64_167", 167));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_string_168", 168));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_uint32_169", 169));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_string_uint64_170", 170));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_bool_171", 171));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_bytes_172", 172));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_double_173", 173));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_enum_174", 174));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_fixed32_175", 175));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_fixed64_176", 176));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_float_177", 177));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_int32_178", 178));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_int64_179", 179));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_message_180", 180));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_sfixed32_181", 181));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_sfixed64_182", 182));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_sint32_183", 183));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_sint64_184", 184));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_string_185", 185));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_uint32_186", 186));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint32_uint64_187", 187));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_bool_188", 188));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_bytes_189", 189));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_double_190", 190));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_enum_191", 191));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_fixed32_192", 192));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_fixed64_193", 193));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_float_194", 194));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_int32_195", 195));
+ builder.withField(mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_int64_196", 196));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_message_197", 197));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_sfixed32_198", 198));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_sfixed64_199", 199));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_sint32_200", 200));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_sint64_201", 201));
+ builder.withField(
+ mapFieldInfo(Proto3MessageWithMaps.class, "field_map_uint64_string_202", 202));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_uint32_203", 203));
+ builder.withField(
+ mapFieldInfo(Proto2MessageWithMaps.class, "field_map_uint64_uint64_204", 204));
+ return builder.build();
+ }
+
+ private static Field field(String name) {
+ return field(Proto3Message.class, name);
+ }
+
+ private static Field field(Class<?> clazz, String name) {
+ try {
+ return clazz.getDeclaredField(name);
+ } catch (NoSuchFieldException | SecurityException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static FieldInfo mapFieldInfo(Class<?> clazz, String fieldName, int fieldNumber) {
+ try {
+ return forMapField(
+ field(clazz, SchemaUtil.toCamelCase(fieldName, false) + "_"),
+ fieldNumber,
+ SchemaUtil.getMapDefaultEntry(clazz, fieldName),
+ null);
+ } catch (Throwable t) {
+ throw new RuntimeException(t);
+ }
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto3MessageLiteFactory.java b/java/core/src/test/java/com/google/protobuf/Proto3MessageLiteFactory.java
new file mode 100755
index 0000000..2f6947d
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto3MessageLiteFactory.java
@@ -0,0 +1,452 @@
+// 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.testing.Proto3TestingLite.Proto3MessageLite;
+import com.google.protobuf.testing.Proto3TestingLite.Proto3MessageLiteWithMaps;
+import java.util.HashMap;
+import java.util.Map;
+
+/** Creates instances of {@link Proto3MessageLite} based on the tree configuration. */
+public final class Proto3MessageLiteFactory
+ implements ExperimentalMessageFactory<Proto3MessageLite> {
+ private final int numRepeatedFields;
+ private final int branchingFactor;
+ private final Proto3MessageLiteFactory nextLevel;
+ private final ExperimentalTestDataProvider data;
+
+ public Proto3MessageLiteFactory(
+ int numRepeatedFields, int stringLength, int branchingFactor, int treeDepth) {
+ this(
+ new ExperimentalTestDataProvider(stringLength),
+ numRepeatedFields,
+ branchingFactor,
+ treeDepth);
+ }
+
+ private Proto3MessageLiteFactory(
+ ExperimentalTestDataProvider data,
+ int numRepeatedFields,
+ int branchingFactor,
+ int treeDepth) {
+ this.numRepeatedFields = numRepeatedFields;
+ this.branchingFactor = branchingFactor;
+ this.data = data;
+ if (treeDepth > 0) {
+ nextLevel =
+ new Proto3MessageLiteFactory(data, numRepeatedFields, branchingFactor, treeDepth - 1);
+ } else {
+ nextLevel = null;
+ }
+ }
+
+ @Override
+ public ExperimentalTestDataProvider dataProvider() {
+ return data;
+ }
+
+ @Override
+ public Proto3MessageLite newMessage() {
+ Proto3MessageLite.Builder builder = Proto3MessageLite.newBuilder();
+ builder.setFieldDouble1(data.getDouble());
+ builder.setFieldFloat2(data.getFloat());
+ builder.setFieldInt643(data.getLong());
+ builder.setFieldUint644(data.getLong());
+ builder.setFieldInt325(data.getInt());
+ builder.setFieldFixed646(data.getLong());
+ builder.setFieldFixed327(data.getInt());
+ builder.setFieldBool8(data.getBool());
+ builder.setFieldString9(data.getString());
+ // We don't populate the message field. Instead we apply the branching factor to the
+ // repeated message field below.
+ builder.setFieldBytes11(data.getBytes());
+ builder.setFieldUint3212(data.getInt());
+ builder.setFieldEnum13Value(data.getEnum());
+ builder.setFieldSfixed3214(data.getInt());
+ builder.setFieldSfixed6415(data.getLong());
+ builder.setFieldSint3216(data.getInt());
+ builder.setFieldSint6417(data.getLong());
+
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ builder.addFieldDoubleList18(data.getDouble());
+ builder.addFieldFloatList19(data.getFloat());
+ builder.addFieldInt64List20(data.getLong());
+ builder.addFieldUint64List21(data.getLong());
+ builder.addFieldInt32List22(data.getInt());
+ builder.addFieldFixed64List23(data.getLong());
+ builder.addFieldFixed32List24(data.getInt());
+ builder.addFieldBoolList25(data.getBool());
+ builder.addFieldStringList26(data.getString());
+ // Repeated message field is controlled by the branching factor below.
+ builder.addFieldBytesList28(data.getBytes());
+ builder.addFieldUint32List29(data.getInt());
+ builder.addFieldEnumList30Value(data.getEnum());
+ builder.addFieldSfixed32List31(data.getInt());
+ builder.addFieldSfixed64List32(data.getLong());
+ builder.addFieldSint32List33(data.getInt());
+ builder.addFieldSint64List34(data.getLong());
+
+ builder.addFieldDoubleListPacked35(data.getDouble());
+ builder.addFieldFloatListPacked36(data.getFloat());
+ builder.addFieldInt64ListPacked37(data.getLong());
+ builder.addFieldUint64ListPacked38(data.getLong());
+ builder.addFieldInt32ListPacked39(data.getInt());
+ builder.addFieldFixed64ListPacked40(data.getLong());
+ builder.addFieldFixed32ListPacked41(data.getInt());
+ builder.addFieldBoolListPacked42(data.getBool());
+ builder.addFieldUint32ListPacked43(data.getInt());
+ builder.addFieldEnumListPacked44Value(data.getEnum());
+ builder.addFieldSfixed32ListPacked45(data.getInt());
+ builder.addFieldSfixed64ListPacked46(data.getLong());
+ builder.addFieldSint32ListPacked47(data.getInt());
+ builder.addFieldSint64ListPacked48(data.getLong());
+ }
+
+ // Handle the branching factor.
+ if (nextLevel != null) {
+ for (int i = 0; i < branchingFactor; ++i) {
+ builder.addFieldMessageList27(nextLevel.newMessage());
+ }
+ }
+
+ return builder.build();
+ }
+
+ private interface MapValueProvider<T> {
+ public T getValue();
+ }
+
+ private final MapValueProvider<Integer> integerProvider =
+ new MapValueProvider<Integer>() {
+ @Override
+ public Integer getValue() {
+ return data.getInt();
+ }
+ };
+ private final MapValueProvider<Long> longProvider =
+ new MapValueProvider<Long>() {
+ @Override
+ public Long getValue() {
+ return data.getLong();
+ }
+ };
+ private final MapValueProvider<String> stringProvider =
+ new MapValueProvider<String>() {
+ @Override
+ public String getValue() {
+ return data.getString();
+ }
+ };
+ private final MapValueProvider<ByteString> bytesProvider =
+ new MapValueProvider<ByteString>() {
+ @Override
+ public ByteString getValue() {
+ return data.getBytes();
+ }
+ };
+ private final MapValueProvider<Boolean> booleanProvider =
+ new MapValueProvider<Boolean>() {
+ @Override
+ public Boolean getValue() {
+ return data.getBool();
+ }
+ };
+ private final MapValueProvider<Float> floatProvider =
+ new MapValueProvider<Float>() {
+ @Override
+ public Float getValue() {
+ return data.getFloat();
+ }
+ };
+ private final MapValueProvider<Double> doubleProvider =
+ new MapValueProvider<Double>() {
+ @Override
+ public Double getValue() {
+ return data.getDouble();
+ }
+ };
+ private final MapValueProvider<Proto3MessageLite> messageProvider =
+ new MapValueProvider<Proto3MessageLite>() {
+ @Override
+ public Proto3MessageLite getValue() {
+ return newMessage();
+ }
+ };
+ private final MapValueProvider<Proto3MessageLite.TestEnum> enumProvider =
+ new MapValueProvider<Proto3MessageLite.TestEnum>() {
+ @Override
+ public Proto3MessageLite.TestEnum getValue() {
+ return Proto3MessageLite.TestEnum.forNumber(data.getEnum());
+ }
+ };
+
+ private <V> Map<Integer, V> populateIntegerMap(MapValueProvider<V> provider) {
+ Map<Integer, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getInt(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<Long, V> populateLongMap(MapValueProvider<V> provider) {
+ Map<Long, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getLong(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<String, V> populateStringMap(MapValueProvider<V> provider) {
+ Map<String, V> map = new HashMap<>();
+ for (int i = 0; i < numRepeatedFields; ++i) {
+ map.put(data.getString(), provider.getValue());
+ }
+ return map;
+ }
+
+ private <V> Map<Boolean, V> populateBooleanMap(MapValueProvider<V> provider) {
+ Map<Boolean, V> map = new HashMap<>();
+ map.put(false, provider.getValue());
+ map.put(true, provider.getValue());
+ return map;
+ }
+
+ public Proto3MessageLiteWithMaps newMessageWithMaps() {
+ Proto3MessageLiteWithMaps.Builder builder = Proto3MessageLiteWithMaps.newBuilder();
+
+ builder.putAllFieldMapBoolBool1(populateBooleanMap(booleanProvider));
+ builder.putAllFieldMapBoolBytes2(populateBooleanMap(bytesProvider));
+ builder.putAllFieldMapBoolDouble3(populateBooleanMap(doubleProvider));
+ builder.putAllFieldMapBoolEnum4(populateBooleanMap(enumProvider));
+ builder.putAllFieldMapBoolFixed325(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolFixed646(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolFloat7(populateBooleanMap(floatProvider));
+ builder.putAllFieldMapBoolInt328(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolInt649(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolMessage10(populateBooleanMap(messageProvider));
+ builder.putAllFieldMapBoolSfixed3211(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolSfixed6412(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolSint3213(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolSint6414(populateBooleanMap(longProvider));
+ builder.putAllFieldMapBoolString15(populateBooleanMap(stringProvider));
+ builder.putAllFieldMapBoolUint3216(populateBooleanMap(integerProvider));
+ builder.putAllFieldMapBoolUint6417(populateBooleanMap(longProvider));
+ builder.putAllFieldMapFixed32Bool18(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapFixed32Bytes19(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapFixed32Double20(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapFixed32Enum21(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapFixed32Fixed3222(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Fixed6423(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Float24(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapFixed32Int3225(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Int6426(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Message27(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapFixed32Sfixed3228(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Sfixed6429(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32Sint3230(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Sint6431(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed32String32(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapFixed32Uint3233(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapFixed32Uint6434(populateIntegerMap(longProvider));
+ builder.putAllFieldMapFixed64Bool35(populateLongMap(booleanProvider));
+ builder.putAllFieldMapFixed64Bytes36(populateLongMap(bytesProvider));
+ builder.putAllFieldMapFixed64Double37(populateLongMap(doubleProvider));
+ builder.putAllFieldMapFixed64Enum38(populateLongMap(enumProvider));
+ builder.putAllFieldMapFixed64Fixed3239(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Fixed6440(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Float41(populateLongMap(floatProvider));
+ builder.putAllFieldMapFixed64Int3242(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Int6443(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Message44(populateLongMap(messageProvider));
+ builder.putAllFieldMapFixed64Sfixed3245(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Sfixed6446(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64Sint3247(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Sint6448(populateLongMap(longProvider));
+ builder.putAllFieldMapFixed64String49(populateLongMap(stringProvider));
+ builder.putAllFieldMapFixed64Uint3250(populateLongMap(integerProvider));
+ builder.putAllFieldMapFixed64Uint6451(populateLongMap(longProvider));
+ builder.putAllFieldMapInt32Bool52(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapInt32Bytes53(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapInt32Double54(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapInt32Enum55(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapInt32Fixed3256(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Fixed6457(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Float58(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapInt32Int3259(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Int6460(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Message61(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapInt32Sfixed3262(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Sfixed6463(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32Sint3264(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Sint6465(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt32String66(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapInt32Uint3267(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapInt32Uint6468(populateIntegerMap(longProvider));
+ builder.putAllFieldMapInt64Bool69(populateLongMap(booleanProvider));
+ builder.putAllFieldMapInt64Bytes70(populateLongMap(bytesProvider));
+ builder.putAllFieldMapInt64Double71(populateLongMap(doubleProvider));
+ builder.putAllFieldMapInt64Enum72(populateLongMap(enumProvider));
+ builder.putAllFieldMapInt64Fixed3273(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Fixed6474(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Float75(populateLongMap(floatProvider));
+ builder.putAllFieldMapInt64Int3276(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Int6477(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Message78(populateLongMap(messageProvider));
+ builder.putAllFieldMapInt64Sfixed3279(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Sfixed6480(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64Sint3281(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Sint6482(populateLongMap(longProvider));
+ builder.putAllFieldMapInt64String83(populateLongMap(stringProvider));
+ builder.putAllFieldMapInt64Uint3284(populateLongMap(integerProvider));
+ builder.putAllFieldMapInt64Uint6485(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed32Bool86(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapSfixed32Bytes87(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapSfixed32Double88(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapSfixed32Enum89(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapSfixed32Fixed3290(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Fixed6491(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Float92(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapSfixed32Int3293(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Int6494(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Message95(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapSfixed32Sfixed3296(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Sfixed6497(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32Sint3298(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Sint6499(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed32String100(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapSfixed32Uint32101(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSfixed32Uint64102(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSfixed64Bool103(populateLongMap(booleanProvider));
+ builder.putAllFieldMapSfixed64Bytes104(populateLongMap(bytesProvider));
+ builder.putAllFieldMapSfixed64Double105(populateLongMap(doubleProvider));
+ builder.putAllFieldMapSfixed64Enum106(populateLongMap(enumProvider));
+ builder.putAllFieldMapSfixed64Fixed32107(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Fixed64108(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Float109(populateLongMap(floatProvider));
+ builder.putAllFieldMapSfixed64Int32110(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Int64111(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Message112(populateLongMap(messageProvider));
+ builder.putAllFieldMapSfixed64Sfixed32113(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Sfixed64114(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64Sint32115(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Sint64116(populateLongMap(longProvider));
+ builder.putAllFieldMapSfixed64String117(populateLongMap(stringProvider));
+ builder.putAllFieldMapSfixed64Uint32118(populateLongMap(integerProvider));
+ builder.putAllFieldMapSfixed64Uint64119(populateLongMap(longProvider));
+ builder.putAllFieldMapSint32Bool120(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapSint32Bytes121(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapSint32Double122(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapSint32Enum123(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapSint32Fixed32124(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Fixed64125(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Float126(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapSint32Int32127(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Int64128(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Message129(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapSint32Sfixed32130(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Sfixed64131(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32Sint32132(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Sint64133(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint32String134(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapSint32Uint32135(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapSint32Uint64136(populateIntegerMap(longProvider));
+ builder.putAllFieldMapSint64Bool137(populateLongMap(booleanProvider));
+ builder.putAllFieldMapSint64Bytes138(populateLongMap(bytesProvider));
+ builder.putAllFieldMapSint64Double139(populateLongMap(doubleProvider));
+ builder.putAllFieldMapSint64Enum140(populateLongMap(enumProvider));
+ builder.putAllFieldMapSint64Fixed32141(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Fixed64142(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Float143(populateLongMap(floatProvider));
+ builder.putAllFieldMapSint64Int32144(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Int64145(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Message146(populateLongMap(messageProvider));
+ builder.putAllFieldMapSint64Sfixed32147(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Sfixed64148(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64Sint32149(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Sint64150(populateLongMap(longProvider));
+ builder.putAllFieldMapSint64String151(populateLongMap(stringProvider));
+ builder.putAllFieldMapSint64Uint32152(populateLongMap(integerProvider));
+ builder.putAllFieldMapSint64Uint64153(populateLongMap(longProvider));
+ builder.putAllFieldMapStringBool154(populateStringMap(booleanProvider));
+ builder.putAllFieldMapStringBytes155(populateStringMap(bytesProvider));
+ builder.putAllFieldMapStringDouble156(populateStringMap(doubleProvider));
+ builder.putAllFieldMapStringEnum157(populateStringMap(enumProvider));
+ builder.putAllFieldMapStringFixed32158(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringFixed64159(populateStringMap(longProvider));
+ builder.putAllFieldMapStringFloat160(populateStringMap(floatProvider));
+ builder.putAllFieldMapStringInt32161(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringInt64162(populateStringMap(longProvider));
+ builder.putAllFieldMapStringMessage163(populateStringMap(messageProvider));
+ builder.putAllFieldMapStringSfixed32164(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringSfixed64165(populateStringMap(longProvider));
+ builder.putAllFieldMapStringSint32166(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringSint64167(populateStringMap(longProvider));
+ builder.putAllFieldMapStringString168(populateStringMap(stringProvider));
+ builder.putAllFieldMapStringUint32169(populateStringMap(integerProvider));
+ builder.putAllFieldMapStringUint64170(populateStringMap(longProvider));
+ builder.putAllFieldMapUint32Bool171(populateIntegerMap(booleanProvider));
+ builder.putAllFieldMapUint32Bytes172(populateIntegerMap(bytesProvider));
+ builder.putAllFieldMapUint32Double173(populateIntegerMap(doubleProvider));
+ builder.putAllFieldMapUint32Enum174(populateIntegerMap(enumProvider));
+ builder.putAllFieldMapUint32Fixed32175(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Fixed64176(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Float177(populateIntegerMap(floatProvider));
+ builder.putAllFieldMapUint32Int32178(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Int64179(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Message180(populateIntegerMap(messageProvider));
+ builder.putAllFieldMapUint32Sfixed32181(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Sfixed64182(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32Sint32183(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Sint64184(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint32String185(populateIntegerMap(stringProvider));
+ builder.putAllFieldMapUint32Uint32186(populateIntegerMap(integerProvider));
+ builder.putAllFieldMapUint32Uint64187(populateIntegerMap(longProvider));
+ builder.putAllFieldMapUint64Bool188(populateLongMap(booleanProvider));
+ builder.putAllFieldMapUint64Bytes189(populateLongMap(bytesProvider));
+ builder.putAllFieldMapUint64Double190(populateLongMap(doubleProvider));
+ builder.putAllFieldMapUint64Enum191(populateLongMap(enumProvider));
+ builder.putAllFieldMapUint64Fixed32192(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Fixed64193(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Float194(populateLongMap(floatProvider));
+ builder.putAllFieldMapUint64Int32195(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Int64196(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Message197(populateLongMap(messageProvider));
+ builder.putAllFieldMapUint64Sfixed32198(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Sfixed64199(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64Sint32200(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Sint64201(populateLongMap(longProvider));
+ builder.putAllFieldMapUint64String202(populateLongMap(stringProvider));
+ builder.putAllFieldMapUint64Uint32203(populateLongMap(integerProvider));
+ builder.putAllFieldMapUint64Uint64204(populateLongMap(longProvider));
+
+ return builder.build();
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto3MessageLiteInfoFactory.java b/java/core/src/test/java/com/google/protobuf/Proto3MessageLiteInfoFactory.java
new file mode 100755
index 0000000..66e406a
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto3MessageLiteInfoFactory.java
@@ -0,0 +1,816 @@
+// 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.forMapField;
+import static com.google.protobuf.FieldInfo.forOneofMemberField;
+import static com.google.protobuf.FieldInfo.forRepeatedMessageField;
+
+import com.google.protobuf.testing.Proto3TestingLite.Proto3EmptyLite;
+import com.google.protobuf.testing.Proto3TestingLite.Proto3MessageLite;
+import com.google.protobuf.testing.Proto3TestingLite.Proto3MessageLiteWithMaps;
+import java.lang.reflect.Field;
+
+/** A factory that generates a hard-coded info for {@link Proto3MessageLite}. */
+public final class Proto3MessageLiteInfoFactory implements MessageInfoFactory {
+ private static final Proto3MessageLiteInfoFactory instanceForRawMessageInfo =
+ new Proto3MessageLiteInfoFactory(true);
+ private static final Proto3MessageLiteInfoFactory instanceForStructuralMessageInfo =
+ new Proto3MessageLiteInfoFactory(false);
+
+ public static Proto3MessageLiteInfoFactory getInstanceForRawMessageInfo() {
+ return instanceForRawMessageInfo;
+ }
+
+ public static Proto3MessageLiteInfoFactory getInstanceForStructuralMessageInfo() {
+ return instanceForStructuralMessageInfo;
+ }
+
+ private final boolean produceRawMessageInfo;
+
+ private Proto3MessageLiteInfoFactory(boolean produceRawMessageInfo) {
+ this.produceRawMessageInfo = produceRawMessageInfo;
+ }
+
+ @Override
+ public boolean isSupported(Class<?> clazz) {
+ return true;
+ }
+
+ @Override
+ public MessageInfo messageInfoFor(Class<?> clazz) {
+ return produceRawMessageInfo ? rawMessageInfoFor(clazz) : structuralMessageInfoFor(clazz);
+ }
+
+ private MessageInfo rawMessageInfoFor(Class<?> clazz) {
+ if (Proto3MessageLite.class.isAssignableFrom(clazz)) {
+ return newRawMessageInfoForProto3MessageLite();
+ } else {
+ throw new IllegalArgumentException("Unsupported class: " + clazz.getName());
+ }
+ }
+
+ private MessageInfo newRawMessageInfoForProto3MessageLite() {
+ java.lang.Object[] objects =
+ new java.lang.Object[] {
+ "testOneof_",
+ "testOneofCase_",
+ "fieldDouble1_",
+ "fieldFloat2_",
+ "fieldInt643_",
+ "fieldUint644_",
+ "fieldInt325_",
+ "fieldFixed646_",
+ "fieldFixed327_",
+ "fieldBool8_",
+ "fieldString9_",
+ "fieldMessage10_",
+ "fieldBytes11_",
+ "fieldUint3212_",
+ "fieldEnum13_",
+ "fieldSfixed3214_",
+ "fieldSfixed6415_",
+ "fieldSint3216_",
+ "fieldSint6417_",
+ "fieldDoubleList18_",
+ "fieldFloatList19_",
+ "fieldInt64List20_",
+ "fieldUint64List21_",
+ "fieldInt32List22_",
+ "fieldFixed64List23_",
+ "fieldFixed32List24_",
+ "fieldBoolList25_",
+ "fieldStringList26_",
+ "fieldMessageList27_",
+ Proto3MessageLite.class,
+ "fieldBytesList28_",
+ "fieldUint32List29_",
+ "fieldEnumList30_",
+ "fieldSfixed32List31_",
+ "fieldSfixed64List32_",
+ "fieldSint32List33_",
+ "fieldSint64List34_",
+ "fieldDoubleListPacked35_",
+ "fieldFloatListPacked36_",
+ "fieldInt64ListPacked37_",
+ "fieldUint64ListPacked38_",
+ "fieldInt32ListPacked39_",
+ "fieldFixed64ListPacked40_",
+ "fieldFixed32ListPacked41_",
+ "fieldBoolListPacked42_",
+ "fieldUint32ListPacked43_",
+ "fieldEnumListPacked44_",
+ "fieldSfixed32ListPacked45_",
+ "fieldSfixed64ListPacked46_",
+ "fieldSint32ListPacked47_",
+ "fieldSint64ListPacked48_",
+ Proto3MessageLite.class,
+ };
+ // To update this after a proto change, run protoc on proto3_message_lite.proto and copy over
+ // the content of the generated buildMessageInfo() method here.
+ java.lang.String info =
+ "\u0000@\u0001\u0000\u0001D@\u0000\u001f\u0000\u0001\u0000\u0002\u0001\u0003\u0002"
+ + "\u0004\u0003\u0005\u0004\u0006\u0005\u0007\u0006\b\u0007\t\u0208\n\t\u000b\n\f\u000b"
+ + "\r\f\u000e\r\u000f\u000e\u0010\u000f\u0011\u0010\u0012\u0012\u0013\u0013\u0014\u0014"
+ + "\u0015\u0015\u0016\u0016\u0017\u0017\u0018\u0018\u0019\u0019\u001a\u021a\u001b\u001b"
+ + "\u001c\u001c\u001d\u001d\u001e\u001e\u001f\u001f !!\"\"##$$%%&&\'\'(())**++,,--"
+ + "..//0053\u000064\u000075\u000086\u000097\u0000:8\u0000;9\u0000<:\u0000=\u023b\u0000"
+ + "><\u0000?=\u0000@>\u0000A@\u0000BA\u0000CB\u0000DC\u0000";
+ return new RawMessageInfo(Proto3MessageLite.getDefaultInstance(), info, objects);
+ }
+
+ private MessageInfo structuralMessageInfoFor(Class<?> clazz) {
+ if (Proto3MessageLite.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto3MessageLite();
+ } else if (Proto3EmptyLite.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto3EmptyLite();
+ } else if (Proto3MessageLiteWithMaps.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto3MessageLiteWithMaps();
+ } else {
+ throw new IllegalArgumentException("Unsupported class: " + clazz.getName());
+ }
+ }
+
+ /**
+ * Creates a new hard-coded info for {@link Proto3MessageLite}. Each time this is called, we
+ * manually go through the entire process of what a message would do if it self-registered its own
+ * info, including looking up each field by name. This is done for benchmarking purposes, so that
+ * we get a more accurate representation of the time it takes to perform this process.
+ */
+ private static StructuralMessageInfo newMessageInfoForProto3MessageLite() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(48);
+ lookupFieldsByName(builder);
+ return builder.build();
+ }
+
+ private static void lookupFieldsByName(StructuralMessageInfo.Builder builder) {
+ builder.withDefaultInstance(Proto3MessageLite.getDefaultInstance());
+ builder.withSyntax(ProtoSyntax.PROTO3);
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldDouble1_"), 1, FieldType.DOUBLE, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldFloat2_"), 2, FieldType.FLOAT, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldInt643_"), 3, FieldType.INT64, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldUint644_"), 4, FieldType.UINT64, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldInt325_"), 5, FieldType.INT32, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldFixed646_"), 6, FieldType.FIXED64, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldFixed327_"), 7, FieldType.FIXED32, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldBool8_"), 8, FieldType.BOOL, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldString9_"), 9, FieldType.STRING, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldMessage10_"), 10, FieldType.MESSAGE, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldBytes11_"), 11, FieldType.BYTES, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldUint3212_"), 12, FieldType.UINT32, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldEnum13_"), 13, FieldType.ENUM, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldSfixed3214_"), 14, FieldType.SFIXED32, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldSfixed6415_"), 15, FieldType.SFIXED64, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldSint3216_"), 16, FieldType.SINT32, true));
+ builder.withField(
+ forField(field(Proto3MessageLite.class, "fieldSint6417_"), 17, FieldType.SINT64, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldDoubleList18_"), 18, FieldType.DOUBLE_LIST, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldFloatList19_"), 19, FieldType.FLOAT_LIST, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldInt64List20_"), 20, FieldType.INT64_LIST, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldUint64List21_"), 21, FieldType.UINT64_LIST, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldInt32List22_"), 22, FieldType.INT32_LIST, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldFixed64List23_"),
+ 23,
+ FieldType.FIXED64_LIST,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldFixed32List24_"),
+ 24,
+ FieldType.FIXED32_LIST,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldBoolList25_"), 25, FieldType.BOOL_LIST, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldStringList26_"), 26, FieldType.STRING_LIST, true));
+ builder.withField(
+ forRepeatedMessageField(
+ field(Proto3MessageLite.class, "fieldMessageList27_"),
+ 27,
+ FieldType.MESSAGE_LIST,
+ Proto3MessageLite.class));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldBytesList28_"), 28, FieldType.BYTES_LIST, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldUint32List29_"), 29, FieldType.UINT32_LIST, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldEnumList30_"), 30, FieldType.ENUM_LIST, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldSfixed32List31_"),
+ 31,
+ FieldType.SFIXED32_LIST,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldSfixed64List32_"),
+ 32,
+ FieldType.SFIXED64_LIST,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldSint32List33_"), 33, FieldType.SINT32_LIST, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldSint64List34_"), 34, FieldType.SINT64_LIST, true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldDoubleListPacked35_"),
+ 35,
+ FieldType.DOUBLE_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldFloatListPacked36_"),
+ 36,
+ FieldType.FLOAT_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldInt64ListPacked37_"),
+ 37,
+ FieldType.INT64_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldUint64ListPacked38_"),
+ 38,
+ FieldType.UINT64_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldInt32ListPacked39_"),
+ 39,
+ FieldType.INT32_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldFixed64ListPacked40_"),
+ 40,
+ FieldType.FIXED64_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldFixed32ListPacked41_"),
+ 41,
+ FieldType.FIXED32_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldBoolListPacked42_"),
+ 42,
+ FieldType.BOOL_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldUint32ListPacked43_"),
+ 43,
+ FieldType.UINT32_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldEnumListPacked44_"),
+ 44,
+ FieldType.ENUM_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldSfixed32ListPacked45_"),
+ 45,
+ FieldType.SFIXED32_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldSfixed64ListPacked46_"),
+ 46,
+ FieldType.SFIXED64_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldSint32ListPacked47_"),
+ 47,
+ FieldType.SINT32_LIST_PACKED,
+ true));
+ builder.withField(
+ forField(
+ field(Proto3MessageLite.class, "fieldSint64ListPacked48_"),
+ 48,
+ FieldType.SINT64_LIST_PACKED,
+ true));
+
+ OneofInfo oneof =
+ new OneofInfo(
+ 0,
+ field(Proto3MessageLite.class, "testOneofCase_"),
+ field(Proto3MessageLite.class, "testOneof_"));
+ builder.withField(forOneofMemberField(53, FieldType.DOUBLE, oneof, Double.class, true, null));
+ builder.withField(forOneofMemberField(54, FieldType.FLOAT, oneof, Float.class, true, null));
+ builder.withField(forOneofMemberField(55, FieldType.INT64, oneof, Long.class, true, null));
+ builder.withField(forOneofMemberField(56, FieldType.UINT64, oneof, Long.class, true, null));
+ builder.withField(forOneofMemberField(57, FieldType.INT32, oneof, Integer.class, true, null));
+ builder.withField(forOneofMemberField(58, FieldType.FIXED64, oneof, Long.class, true, null));
+ builder.withField(forOneofMemberField(59, FieldType.FIXED32, oneof, Integer.class, true, null));
+ builder.withField(forOneofMemberField(60, FieldType.BOOL, oneof, Boolean.class, true, null));
+ builder.withField(forOneofMemberField(61, FieldType.STRING, oneof, String.class, true, null));
+ builder.withField(
+ forOneofMemberField(62, FieldType.MESSAGE, oneof, Proto3MessageLite.class, true, null));
+ builder.withField(
+ forOneofMemberField(63, FieldType.BYTES, oneof, ByteString.class, true, null));
+ builder.withField(forOneofMemberField(64, FieldType.UINT32, oneof, Integer.class, true, null));
+ builder.withField(
+ forOneofMemberField(65, FieldType.SFIXED32, oneof, Integer.class, true, null));
+ builder.withField(forOneofMemberField(66, FieldType.SFIXED64, oneof, Long.class, true, null));
+ builder.withField(forOneofMemberField(67, FieldType.SINT32, oneof, Integer.class, true, null));
+ builder.withField(forOneofMemberField(68, FieldType.SINT64, oneof, Long.class, true, null));
+ }
+
+ private StructuralMessageInfo newMessageInfoForProto3EmptyLite() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO3);
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForProto3MessageLiteWithMaps() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder();
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_bool_1", 1));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_bytes_2", 2));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_double_3", 3));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_enum_4", 4));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_fixed32_5", 5));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_fixed64_6", 6));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_float_7", 7));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_int32_8", 8));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_int64_9", 9));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_message_10", 10));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_sfixed32_11", 11));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_sfixed64_12", 12));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_sint32_13", 13));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_sint64_14", 14));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_string_15", 15));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_uint32_16", 16));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_bool_uint64_17", 17));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_bool_18", 18));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_bytes_19", 19));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_double_20", 20));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_enum_21", 21));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_fixed32_22", 22));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_fixed64_23", 23));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_float_24", 24));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_int32_25", 25));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_int64_26", 26));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_message_27", 27));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_sfixed32_28", 28));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_sfixed64_29", 29));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_sint32_30", 30));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_sint64_31", 31));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_string_32", 32));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_uint32_33", 33));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed32_uint64_34", 34));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_bool_35", 35));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_bytes_36", 36));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_double_37", 37));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_enum_38", 38));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_fixed32_39", 39));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_fixed64_40", 40));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_float_41", 41));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_int32_42", 42));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_int64_43", 43));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_message_44", 44));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_sfixed32_45", 45));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_sfixed64_46", 46));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_sint32_47", 47));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_sint64_48", 48));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_string_49", 49));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_uint32_50", 50));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_fixed64_uint64_51", 51));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_bool_52", 52));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_bytes_53", 53));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_double_54", 54));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_enum_55", 55));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_fixed32_56", 56));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_fixed64_57", 57));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_float_58", 58));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_int32_59", 59));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_int64_60", 60));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_message_61", 61));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_sfixed32_62", 62));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_sfixed64_63", 63));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_sint32_64", 64));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_sint64_65", 65));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_string_66", 66));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_uint32_67", 67));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int32_uint64_68", 68));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_bool_69", 69));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_bytes_70", 70));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_double_71", 71));
+ builder.withField(mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_enum_72", 72));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_fixed32_73", 73));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_fixed64_74", 74));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_float_75", 75));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_int32_76", 76));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_int64_77", 77));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_message_78", 78));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_sfixed32_79", 79));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_sfixed64_80", 80));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_sint32_81", 81));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_sint64_82", 82));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_string_83", 83));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_uint32_84", 84));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_int64_uint64_85", 85));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_bool_86", 86));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_bytes_87", 87));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_double_88", 88));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_enum_89", 89));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_fixed32_90", 90));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_fixed64_91", 91));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_float_92", 92));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_int32_93", 93));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_int64_94", 94));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_message_95", 95));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_sfixed32_96", 96));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_sfixed64_97", 97));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_sint32_98", 98));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_sint64_99", 99));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_string_100", 100));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_uint32_101", 101));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed32_uint64_102", 102));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_bool_103", 103));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_bytes_104", 104));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_double_105", 105));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_enum_106", 106));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_fixed32_107", 107));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_fixed64_108", 108));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_float_109", 109));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_int32_110", 110));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_int64_111", 111));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_message_112", 112));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_sfixed32_113", 113));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_sfixed64_114", 114));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_sint32_115", 115));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_sint64_116", 116));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_string_117", 117));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_uint32_118", 118));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sfixed64_uint64_119", 119));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_bool_120", 120));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_bytes_121", 121));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_double_122", 122));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_enum_123", 123));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_fixed32_124", 124));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_fixed64_125", 125));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_float_126", 126));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_int32_127", 127));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_int64_128", 128));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_message_129", 129));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_sfixed32_130", 130));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_sfixed64_131", 131));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_sint32_132", 132));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_sint64_133", 133));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_string_134", 134));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_uint32_135", 135));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint32_uint64_136", 136));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_bool_137", 137));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_bytes_138", 138));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_double_139", 139));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_enum_140", 140));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_fixed32_141", 141));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_fixed64_142", 142));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_float_143", 143));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_int32_144", 144));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_int64_145", 145));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_message_146", 146));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_sfixed32_147", 147));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_sfixed64_148", 148));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_sint32_149", 149));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_sint64_150", 150));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_string_151", 151));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_uint32_152", 152));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_sint64_uint64_153", 153));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_bool_154", 154));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_bytes_155", 155));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_double_156", 156));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_enum_157", 157));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_fixed32_158", 158));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_fixed64_159", 159));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_float_160", 160));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_int32_161", 161));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_int64_162", 162));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_message_163", 163));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_sfixed32_164", 164));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_sfixed64_165", 165));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_sint32_166", 166));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_sint64_167", 167));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_string_168", 168));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_uint32_169", 169));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_string_uint64_170", 170));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_bool_171", 171));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_bytes_172", 172));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_double_173", 173));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_enum_174", 174));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_fixed32_175", 175));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_fixed64_176", 176));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_float_177", 177));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_int32_178", 178));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_int64_179", 179));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_message_180", 180));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_sfixed32_181", 181));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_sfixed64_182", 182));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_sint32_183", 183));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_sint64_184", 184));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_string_185", 185));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_uint32_186", 186));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint32_uint64_187", 187));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_bool_188", 188));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_bytes_189", 189));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_double_190", 190));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_enum_191", 191));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_fixed32_192", 192));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_fixed64_193", 193));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_float_194", 194));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_int32_195", 195));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_int64_196", 196));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_message_197", 197));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_sfixed32_198", 198));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_sfixed64_199", 199));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_sint32_200", 200));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_sint64_201", 201));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_string_202", 202));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_uint32_203", 203));
+ builder.withField(
+ mapFieldInfo(Proto3MessageLiteWithMaps.class, "field_map_uint64_uint64_204", 204));
+
+ return builder.build();
+ }
+
+ private static Field field(Class<?> clazz, String name) {
+ try {
+ return clazz.getDeclaredField(name);
+ } catch (NoSuchFieldException | SecurityException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static FieldInfo mapFieldInfo(Class<?> clazz, String fieldName, int fieldNumber) {
+ try {
+ return forMapField(
+ field(clazz, SchemaUtil.toCamelCase(fieldName, false) + "_"),
+ fieldNumber,
+ SchemaUtil.getMapDefaultEntry(clazz, fieldName),
+ null);
+ } catch (Throwable t) {
+ throw new RuntimeException(t);
+ }
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Proto3SchemaTest.java b/java/core/src/test/java/com/google/protobuf/Proto3SchemaTest.java
new file mode 100755
index 0000000..5cd145b
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Proto3SchemaTest.java
@@ -0,0 +1,48 @@
+// 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.testing.Proto3Testing.Proto3Message;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class Proto3SchemaTest extends AbstractProto3SchemaTest {
+ @Override
+ protected void registerSchemas() {
+ TestSchemas.registerGenericProto3Schemas();
+ }
+
+ @Override
+ protected Schema<Proto3Message> schema() {
+ return TestSchemas.genericProto3Schema;
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/TestSchemas.java b/java/core/src/test/java/com/google/protobuf/TestSchemas.java
new file mode 100755
index 0000000..ab0ced4
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/TestSchemas.java
@@ -0,0 +1,94 @@
+// 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.testing.Proto2Testing;
+import com.google.protobuf.testing.Proto2Testing.Proto2Empty;
+import com.google.protobuf.testing.Proto2Testing.Proto2Message;
+import com.google.protobuf.testing.Proto2Testing.Proto2MessageWithExtensions;
+import com.google.protobuf.testing.Proto2Testing.Proto2MessageWithMaps;
+import com.google.protobuf.testing.Proto3Testing.Proto3Empty;
+import com.google.protobuf.testing.Proto3Testing.Proto3Message;
+import com.google.protobuf.testing.Proto3Testing.Proto3MessageWithMaps;
+
+/** Schemas to support testing. */
+public class TestSchemas {
+ public static final Schema<Proto2Message> genericProto2Schema =
+ new ManifestSchemaFactory().createSchema(Proto2Message.class);
+ public static final Schema<Proto3Message> genericProto3Schema =
+ new ManifestSchemaFactory().createSchema(Proto3Message.class);
+
+ public static void registerGenericProto2Schemas() {
+ registerProto2Schemas();
+ }
+
+ public static void registerGenericProto3Schemas() {
+ registerProto3Schemas();
+ }
+
+ private static void registerProto2Schemas() {
+ Protobuf protobuf = Protobuf.getInstance();
+ ManifestSchemaFactory factory = new ManifestSchemaFactory();
+ protobuf.registerSchemaOverride(Proto2Message.class, factory.createSchema(Proto2Message.class));
+ protobuf.registerSchemaOverride(
+ Proto2Message.FieldGroup49.class, factory.createSchema(Proto2Message.FieldGroup49.class));
+ protobuf.registerSchemaOverride(
+ Proto2Message.FieldGroupList51.class,
+ factory.createSchema(Proto2Message.FieldGroupList51.class));
+ protobuf.registerSchemaOverride(
+ Proto2Message.FieldGroup69.class, factory.createSchema(Proto2Message.FieldGroup69.class));
+ protobuf.registerSchemaOverride(
+ Proto2Message.RequiredNestedMessage.class,
+ factory.createSchema(Proto2Message.RequiredNestedMessage.class));
+ protobuf.registerSchemaOverride(
+ Proto2Message.FieldRequiredGroup88.class,
+ factory.createSchema(Proto2Message.FieldRequiredGroup88.class));
+ protobuf.registerSchemaOverride(Proto2Empty.class, factory.createSchema(Proto2Empty.class));
+ protobuf.registerSchemaOverride(
+ Proto2MessageWithExtensions.class, factory.createSchema(Proto2MessageWithExtensions.class));
+ protobuf.registerSchemaOverride(
+ Proto2Testing.FieldGroup49.class, factory.createSchema(Proto2Testing.FieldGroup49.class));
+ protobuf.registerSchemaOverride(
+ Proto2Testing.FieldGroupList51.class,
+ factory.createSchema(Proto2Testing.FieldGroupList51.class));
+ protobuf.registerSchemaOverride(
+ Proto2MessageWithMaps.class, factory.createSchema(Proto2MessageWithMaps.class));
+ }
+
+ private static void registerProto3Schemas() {
+ Protobuf protobuf = Protobuf.getInstance();
+ ManifestSchemaFactory factory = new ManifestSchemaFactory();
+ protobuf.registerSchemaOverride(Proto3Message.class, factory.createSchema(Proto3Message.class));
+ protobuf.registerSchemaOverride(Proto3Empty.class, factory.createSchema(Proto3Empty.class));
+ protobuf.registerSchemaOverride(
+ Proto3MessageWithMaps.class, factory.createSchema(Proto3MessageWithMaps.class));
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/TestSchemasLite.java b/java/core/src/test/java/com/google/protobuf/TestSchemasLite.java
new file mode 100755
index 0000000..28a89d7
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/TestSchemasLite.java
@@ -0,0 +1,103 @@
+// 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.testing.Proto2TestingLite;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2EmptyLite;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLite;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLiteWithExtensions;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLiteWithMaps;
+import com.google.protobuf.testing.Proto3TestingLite.Proto3EmptyLite;
+import com.google.protobuf.testing.Proto3TestingLite.Proto3MessageLite;
+import com.google.protobuf.testing.Proto3TestingLite.Proto3MessageLiteWithMaps;
+
+/** Schemas to support testing. */
+public final class TestSchemasLite {
+
+ public static final Schema<Proto2MessageLite> genericProto2LiteSchema =
+ new ManifestSchemaFactory().createSchema(Proto2MessageLite.class);
+ public static final Schema<Proto3MessageLite> genericProto3LiteSchema =
+ new ManifestSchemaFactory().createSchema(Proto3MessageLite.class);
+
+ public static void registerGenericProto2LiteSchemas() {
+ registerProto2LiteSchemas();
+ }
+
+ public static void registerGenericProto3LiteSchemas() {
+ registerProto3LiteSchemas();
+ }
+
+ private static void registerProto2LiteSchemas() {
+ Protobuf protobuf = Protobuf.getInstance();
+ ManifestSchemaFactory factory = new ManifestSchemaFactory();
+ protobuf.registerSchemaOverride(
+ Proto2MessageLite.class, factory.createSchema(Proto2MessageLite.class));
+ protobuf.registerSchemaOverride(
+ Proto2MessageLite.FieldGroup49.class,
+ factory.createSchema(Proto2MessageLite.FieldGroup49.class));
+ protobuf.registerSchemaOverride(
+ Proto2MessageLite.FieldGroupList51.class,
+ factory.createSchema(Proto2MessageLite.FieldGroupList51.class));
+ protobuf.registerSchemaOverride(
+ Proto2MessageLite.FieldGroup69.class,
+ factory.createSchema(Proto2MessageLite.FieldGroup69.class));
+ protobuf.registerSchemaOverride(
+ Proto2MessageLite.RequiredNestedMessage.class,
+ factory.createSchema(Proto2MessageLite.RequiredNestedMessage.class));
+ protobuf.registerSchemaOverride(
+ Proto2MessageLite.FieldRequiredGroup88.class,
+ factory.createSchema(Proto2MessageLite.FieldRequiredGroup88.class));
+ protobuf.registerSchemaOverride(
+ Proto2EmptyLite.class, factory.createSchema(Proto2EmptyLite.class));
+ protobuf.registerSchemaOverride(
+ Proto2MessageLiteWithExtensions.class,
+ factory.createSchema(Proto2MessageLiteWithExtensions.class));
+ protobuf.registerSchemaOverride(
+ Proto2TestingLite.FieldGroup49.class,
+ factory.createSchema(Proto2TestingLite.FieldGroup49.class));
+ protobuf.registerSchemaOverride(
+ Proto2TestingLite.FieldGroupList51.class,
+ factory.createSchema(Proto2TestingLite.FieldGroupList51.class));
+ protobuf.registerSchemaOverride(
+ Proto2MessageLiteWithMaps.class, factory.createSchema(Proto2MessageLiteWithMaps.class));
+ }
+
+ private static void registerProto3LiteSchemas() {
+ Protobuf protobuf = Protobuf.getInstance();
+ ManifestSchemaFactory factory = new ManifestSchemaFactory();
+ protobuf.registerSchemaOverride(
+ Proto3MessageLite.class, factory.createSchema(Proto3MessageLite.class));
+ protobuf.registerSchemaOverride(
+ Proto3EmptyLite.class, factory.createSchema(Proto3EmptyLite.class));
+ protobuf.registerSchemaOverride(
+ Proto3MessageLiteWithMaps.class, factory.createSchema(Proto3MessageLiteWithMaps.class));
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/TextFormatTest.java b/java/core/src/test/java/com/google/protobuf/TextFormatTest.java
index 2fad0b9..3ed1243 100644
--- a/java/core/src/test/java/com/google/protobuf/TextFormatTest.java
+++ b/java/core/src/test/java/com/google/protobuf/TextFormatTest.java
@@ -132,6 +132,9 @@
+ " i: 456\n"
+ "}\n";
+ private final TextFormat.Parser parserAllowingUnknownFields =
+ TextFormat.Parser.newBuilder().setAllowUnknownFields(true).build();
+
private final TextFormat.Parser parserAllowingUnknownExtensions =
TextFormat.Parser.newBuilder().setAllowUnknownExtensions(true).build();
@@ -502,6 +505,7 @@
assertEquals(2, builder.getOptionalInt64());
}
+
private void assertParseError(String error, String text) {
// Test merge().
TestAllTypes.Builder builder = TestAllTypes.newBuilder();
@@ -521,6 +525,22 @@
}
}
+ private void assertParseErrorWithUnknownFields(String error, String text) {
+ TestAllTypes.Builder builder = TestAllTypes.newBuilder();
+ try {
+ parserAllowingUnknownFields.merge(text, TestUtil.getFullExtensionRegistry(), builder);
+ fail("Expected parse exception.");
+ } catch (TextFormat.ParseException e) {
+ assertEquals(error, e.getMessage());
+ }
+ }
+
+ private TestAllTypes assertParseSuccessWithUnknownFields(String text)
+ throws TextFormat.ParseException {
+ TestAllTypes.Builder builder = TestAllTypes.newBuilder();
+ parserAllowingUnknownFields.merge(text, TestUtil.getFullExtensionRegistry(), builder);
+ return builder.build();
+ }
private void assertParseErrorWithUnknownExtensions(String error, String text) {
TestAllTypes.Builder builder = TestAllTypes.newBuilder();
@@ -1223,6 +1243,7 @@
// Set to allow unknown fields
TextFormat.Parser parser =
TextFormat.Parser.newBuilder()
+ .setAllowUnknownFields(true)
.setParseInfoTreeBuilder(treeBuilder)
.build();
diff --git a/java/core/src/test/java/com/google/protobuf/UnknownFieldSetLiteTest.java b/java/core/src/test/java/com/google/protobuf/UnknownFieldSetLiteTest.java
deleted file mode 100644
index a947d27..0000000
--- a/java/core/src/test/java/com/google/protobuf/UnknownFieldSetLiteTest.java
+++ /dev/null
@@ -1,601 +0,0 @@
-// 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 junit.framework.TestCase.assertEquals;
-
-import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
-import com.google.protobuf.UnittestLite.TestAllTypesLite;
-import protobuf_unittest.UnittestProto;
-import protobuf_unittest.UnittestProto.ForeignEnum;
-import protobuf_unittest.UnittestProto.TestAllExtensions;
-import protobuf_unittest.UnittestProto.TestAllTypes;
-import protobuf_unittest.UnittestProto.TestEmptyMessage;
-import protobuf_unittest.UnittestProto.TestPackedExtensions;
-import protobuf_unittest.UnittestProto.TestPackedTypes;
-import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash;
-import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Bar;
-import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Foo;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Map;
-import junit.framework.TestCase;
-
-/**
- * Tests for {@link UnknownFieldSetLite}.
- *
- * @author dweis@google.com (Daniel Weis)
- */
-public class UnknownFieldSetLiteTest extends TestCase {
- @Override
- public void setUp() throws Exception {
- allFields = TestUtil.getAllSet();
- allFieldsData = allFields.toByteString();
- emptyMessage = TestEmptyMessage.parseFrom(allFieldsData);
- unknownFields = emptyMessage.getUnknownFields();
- }
-
- TestAllTypes allFields;
- ByteString allFieldsData;
-
- // Constructs a protocol buffer which contains fields with all the same
- // numbers as allFieldsData except that each field is some other wire
- // type.
- private ByteString getBizarroData() throws Exception {
- UnknownFieldSet.Builder bizarroFields = UnknownFieldSet.newBuilder();
-
- UnknownFieldSet.Field varintField = UnknownFieldSet.Field.newBuilder().addVarint(1).build();
- UnknownFieldSet.Field fixed32Field = UnknownFieldSet.Field.newBuilder().addFixed32(1).build();
-
- for (Map.Entry<Integer, UnknownFieldSet.Field> entry : unknownFields.asMap().entrySet()) {
- if (entry.getValue().getVarintList().isEmpty()) {
- // Original field is not a varint, so use a varint.
- bizarroFields.addField(entry.getKey(), varintField);
- } else {
- // Original field *is* a varint, so use something else.
- bizarroFields.addField(entry.getKey(), fixed32Field);
- }
- }
-
- return bizarroFields.build().toByteString();
- }
-
- // An empty message that has been parsed from allFieldsData. So, it has
- // unknown fields of every type.
- TestEmptyMessage emptyMessage;
- UnknownFieldSet unknownFields;
-
- public void testDefaultInstance() {
- UnknownFieldSetLite unknownFields = UnknownFieldSetLite.getDefaultInstance();
-
- assertEquals(0, unknownFields.getSerializedSize());
- assertEquals(ByteString.EMPTY, toByteString(unknownFields));
- }
-
- public void testEmptyInstance() {
- UnknownFieldSetLite instance = UnknownFieldSetLite.newInstance();
-
- assertEquals(0, instance.getSerializedSize());
- assertEquals(ByteString.EMPTY, toByteString(instance));
- assertEquals(UnknownFieldSetLite.getDefaultInstance(), instance);
- }
-
- public void testMergeFieldFrom() throws IOException {
- Foo foo = Foo.newBuilder().setValue(2).build();
-
- CodedInputStream input = CodedInputStream.newInstance(foo.toByteArray());
-
- UnknownFieldSetLite instance = UnknownFieldSetLite.newInstance();
- instance.mergeFieldFrom(input.readTag(), input);
-
- assertEquals(foo.toByteString(), toByteString(instance));
- }
-
- public void testSerializedSize() throws IOException {
- Foo foo = Foo.newBuilder().setValue(2).build();
-
- CodedInputStream input = CodedInputStream.newInstance(foo.toByteArray());
-
- UnknownFieldSetLite instance = UnknownFieldSetLite.newInstance();
- instance.mergeFieldFrom(input.readTag(), input);
-
- assertEquals(foo.toByteString().size(), instance.getSerializedSize());
- }
-
- public void testHashCodeAfterDeserialization() throws IOException {
- Foo foo = Foo.newBuilder().setValue(2).build();
-
- Foo fooDeserialized = Foo.parseFrom(foo.toByteArray());
-
- assertEquals(fooDeserialized, foo);
- assertEquals(foo.hashCode(), fooDeserialized.hashCode());
- }
-
- public void testNewInstanceHashCode() {
- UnknownFieldSetLite emptyFieldSet = UnknownFieldSetLite.getDefaultInstance();
- UnknownFieldSetLite paddedFieldSet = UnknownFieldSetLite.newInstance();
-
- assertEquals(emptyFieldSet, paddedFieldSet);
- assertEquals(emptyFieldSet.hashCode(), paddedFieldSet.hashCode());
- }
-
- public void testMergeVarintField() throws IOException {
- UnknownFieldSetLite unknownFields = UnknownFieldSetLite.newInstance();
- unknownFields.mergeVarintField(10, 2);
-
- CodedInputStream input =
- CodedInputStream.newInstance(toByteString(unknownFields).toByteArray());
-
- int tag = input.readTag();
- assertEquals(10, WireFormat.getTagFieldNumber(tag));
- assertEquals(WireFormat.WIRETYPE_VARINT, WireFormat.getTagWireType(tag));
- assertEquals(2, input.readUInt64());
- assertTrue(input.isAtEnd());
- }
-
- public void testMergeVarintField_negative() throws IOException {
- UnknownFieldSetLite builder = UnknownFieldSetLite.newInstance();
- builder.mergeVarintField(10, -6);
-
- CodedInputStream input = CodedInputStream.newInstance(toByteString(builder).toByteArray());
-
- int tag = input.readTag();
- assertEquals(10, WireFormat.getTagFieldNumber(tag));
- assertEquals(WireFormat.WIRETYPE_VARINT, WireFormat.getTagWireType(tag));
- assertEquals(-6, input.readUInt64());
- assertTrue(input.isAtEnd());
- }
-
- public void testEqualsAndHashCode() {
- UnknownFieldSetLite unknownFields1 = UnknownFieldSetLite.newInstance();
- unknownFields1.mergeVarintField(10, 2);
-
- UnknownFieldSetLite unknownFields2 = UnknownFieldSetLite.newInstance();
- unknownFields2.mergeVarintField(10, 2);
-
- assertEquals(unknownFields1, unknownFields2);
- assertEquals(unknownFields1.hashCode(), unknownFields2.hashCode());
- assertFalse(unknownFields1.equals(UnknownFieldSetLite.getDefaultInstance()));
- assertFalse(unknownFields1.hashCode() == UnknownFieldSetLite.getDefaultInstance().hashCode());
- }
-
- public void testMutableCopyOf() throws IOException {
- UnknownFieldSetLite unknownFields = UnknownFieldSetLite.newInstance();
- unknownFields.mergeVarintField(10, 2);
- unknownFields = UnknownFieldSetLite.mutableCopyOf(unknownFields, unknownFields);
- unknownFields.checkMutable();
-
- CodedInputStream input =
- CodedInputStream.newInstance(toByteString(unknownFields).toByteArray());
-
- int tag = input.readTag();
- assertEquals(10, WireFormat.getTagFieldNumber(tag));
- assertEquals(WireFormat.WIRETYPE_VARINT, WireFormat.getTagWireType(tag));
- assertEquals(2, input.readUInt64());
- assertFalse(input.isAtEnd());
- input.readTag();
- assertEquals(10, WireFormat.getTagFieldNumber(tag));
- assertEquals(WireFormat.WIRETYPE_VARINT, WireFormat.getTagWireType(tag));
- assertEquals(2, input.readUInt64());
- assertTrue(input.isAtEnd());
- }
-
- public void testMutableCopyOf_empty() {
- UnknownFieldSetLite unknownFields =
- UnknownFieldSetLite.mutableCopyOf(
- UnknownFieldSetLite.getDefaultInstance(), UnknownFieldSetLite.getDefaultInstance());
- unknownFields.checkMutable();
-
- assertEquals(0, unknownFields.getSerializedSize());
- assertEquals(ByteString.EMPTY, toByteString(unknownFields));
- }
-
- public void testRoundTrips() throws InvalidProtocolBufferException {
- Foo foo =
- Foo.newBuilder()
- .setValue(1)
- .setExtension(Bar.fooExt, Bar.newBuilder().setName("name").build())
- .setExtension(LiteEqualsAndHash.varint, 22)
- .setExtension(LiteEqualsAndHash.fixed32, 44)
- .setExtension(LiteEqualsAndHash.fixed64, 66L)
- .setExtension(
- LiteEqualsAndHash.myGroup,
- LiteEqualsAndHash.MyGroup.newBuilder().setGroupValue("value").build())
- .build();
-
- Foo copy = Foo.parseFrom(foo.toByteArray());
-
- assertEquals(foo.getSerializedSize(), copy.getSerializedSize());
- assertFalse(foo.equals(copy));
-
- Foo secondCopy = Foo.parseFrom(foo.toByteArray());
- assertEquals(copy, secondCopy);
-
- ExtensionRegistryLite extensionRegistry = ExtensionRegistryLite.newInstance();
- LiteEqualsAndHash.registerAllExtensions(extensionRegistry);
- Foo copyOfCopy = Foo.parseFrom(copy.toByteArray(), extensionRegistry);
-
- assertEquals(foo, copyOfCopy);
- }
-
- public void testMalformedBytes() throws Exception {
- try {
- Foo.parseFrom("this is a malformed protocol buffer".getBytes(Internal.UTF_8));
- fail();
- } catch (InvalidProtocolBufferException e) {
- // Expected.
- }
- }
-
- public void testMissingStartGroupTag() throws IOException {
- ByteString.Output byteStringOutput = ByteString.newOutput();
- CodedOutputStream output = CodedOutputStream.newInstance(byteStringOutput);
- output.writeGroupNoTag(Foo.newBuilder().setValue(11).build());
- output.writeTag(100, WireFormat.WIRETYPE_END_GROUP);
- output.flush();
-
- try {
- Foo.parseFrom(byteStringOutput.toByteString());
- fail();
- } catch (InvalidProtocolBufferException e) {
- // Expected.
- }
- }
-
- public void testMissingEndGroupTag() throws IOException {
- ByteString.Output byteStringOutput = ByteString.newOutput();
- CodedOutputStream output = CodedOutputStream.newInstance(byteStringOutput);
- output.writeTag(100, WireFormat.WIRETYPE_START_GROUP);
- output.writeGroupNoTag(Foo.newBuilder().setValue(11).build());
- output.flush();
-
- try {
- Foo.parseFrom(byteStringOutput.toByteString());
- fail();
- } catch (InvalidProtocolBufferException e) {
- // Expected.
- }
- }
-
- public void testMismatchingGroupTags() throws IOException {
- ByteString.Output byteStringOutput = ByteString.newOutput();
- CodedOutputStream output = CodedOutputStream.newInstance(byteStringOutput);
- output.writeTag(100, WireFormat.WIRETYPE_START_GROUP);
- output.writeGroupNoTag(Foo.newBuilder().setValue(11).build());
- output.writeTag(101, WireFormat.WIRETYPE_END_GROUP);
- output.flush();
-
- try {
- Foo.parseFrom(byteStringOutput.toByteString());
- fail();
- } catch (InvalidProtocolBufferException e) {
- // Expected.
- }
- }
-
- public void testTruncatedInput() {
- Foo foo =
- Foo.newBuilder()
- .setValue(1)
- .setExtension(Bar.fooExt, Bar.newBuilder().setName("name").build())
- .setExtension(LiteEqualsAndHash.varint, 22)
- .setExtension(
- LiteEqualsAndHash.myGroup,
- LiteEqualsAndHash.MyGroup.newBuilder().setGroupValue("value").build())
- .build();
-
- try {
- Foo.parseFrom(foo.toByteString().substring(0, foo.toByteString().size() - 10));
- fail();
- } catch (InvalidProtocolBufferException e) {
- // Expected.
- }
- }
-
- public void testMakeImmutable() throws Exception {
- UnknownFieldSetLite unknownFields = UnknownFieldSetLite.newInstance();
- unknownFields.makeImmutable();
-
- try {
- unknownFields.mergeVarintField(1, 1);
- fail();
- } catch (UnsupportedOperationException expected) {
- }
-
- try {
- unknownFields.mergeLengthDelimitedField(2, ByteString.copyFromUtf8("hello"));
- fail();
- } catch (UnsupportedOperationException expected) {
- }
-
- try {
- unknownFields.mergeFieldFrom(1, CodedInputStream.newInstance(new byte[0]));
- fail();
- } catch (UnsupportedOperationException expected) {
- }
- }
-
- public void testEndToEnd() throws Exception {
- TestAllTypesLite testAllTypes = TestAllTypesLite.getDefaultInstance();
- try {
- testAllTypes.unknownFields.checkMutable();
- fail();
- } catch (UnsupportedOperationException expected) {
- }
-
- testAllTypes = TestAllTypesLite.parseFrom(new byte[0]);
- try {
- testAllTypes.unknownFields.checkMutable();
- fail();
- } catch (UnsupportedOperationException expected) {
- }
-
- testAllTypes = TestAllTypesLite.newBuilder().build();
- try {
- testAllTypes.unknownFields.checkMutable();
- fail();
- } catch (UnsupportedOperationException expected) {
- }
-
- testAllTypes = TestAllTypesLite.newBuilder().setDefaultBool(true).build();
- try {
- testAllTypes.unknownFields.checkMutable();
- fail();
- } catch (UnsupportedOperationException expected) {
- }
-
- TestAllExtensionsLite testAllExtensions =
- TestAllExtensionsLite.newBuilder()
- .mergeFrom(
- TestAllExtensionsLite.newBuilder()
- .setExtension(UnittestLite.optionalInt32ExtensionLite, 2)
- .build()
- .toByteArray())
- .build();
- try {
- testAllExtensions.unknownFields.checkMutable();
- fail();
- } catch (UnsupportedOperationException expected) {
- }
- }
-
- private ByteString toByteString(UnknownFieldSetLite unknownFields) {
- ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
- CodedOutputStream output = CodedOutputStream.newInstance(byteArrayOutputStream);
- try {
- unknownFields.writeTo(output);
- output.flush();
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- return ByteString.copyFrom(byteArrayOutputStream.toByteArray());
- }
-
- public void testSerializeLite() throws Exception {
- UnittestLite.TestEmptyMessageLite emptyMessageLite =
- UnittestLite.TestEmptyMessageLite.parseFrom(allFieldsData);
- assertEquals(allFieldsData.size(), emptyMessageLite.getSerializedSize());
- ByteString data = emptyMessageLite.toByteString();
- TestAllTypes message = TestAllTypes.parseFrom(data);
- TestUtil.assertAllFieldsSet(message);
- assertEquals(allFieldsData, data);
- }
-
- public void testAllExtensionsLite() throws Exception {
- TestAllExtensions allExtensions = TestUtil.getAllExtensionsSet();
- ByteString allExtensionsData = allExtensions.toByteString();
- UnittestLite.TestEmptyMessageLite emptyMessageLite =
- UnittestLite.TestEmptyMessageLite.parser().parseFrom(allExtensionsData);
- ByteString data = emptyMessageLite.toByteString();
- TestAllExtensions message = TestAllExtensions.parseFrom(data, TestUtil.getExtensionRegistry());
- TestUtil.assertAllExtensionsSet(message);
- assertEquals(allExtensionsData, data);
- }
-
- public void testAllPackedFieldsLite() throws Exception {
- TestPackedTypes allPackedFields = TestUtil.getPackedSet();
- ByteString allPackedData = allPackedFields.toByteString();
- UnittestLite.TestEmptyMessageLite emptyMessageLite =
- UnittestLite.TestEmptyMessageLite.parseFrom(allPackedData);
- ByteString data = emptyMessageLite.toByteString();
- TestPackedTypes message = TestPackedTypes.parseFrom(data, TestUtil.getExtensionRegistry());
- TestUtil.assertPackedFieldsSet(message);
- assertEquals(allPackedData, data);
- }
-
- public void testAllPackedExtensionsLite() throws Exception {
- TestPackedExtensions allPackedExtensions = TestUtil.getPackedExtensionsSet();
- ByteString allPackedExtensionsData = allPackedExtensions.toByteString();
- UnittestLite.TestEmptyMessageLite emptyMessageLite =
- UnittestLite.TestEmptyMessageLite.parseFrom(allPackedExtensionsData);
- ByteString data = emptyMessageLite.toByteString();
- TestPackedExtensions message =
- TestPackedExtensions.parseFrom(data, TestUtil.getExtensionRegistry());
- TestUtil.assertPackedExtensionsSet(message);
- assertEquals(allPackedExtensionsData, data);
- }
-
- public void testCopyFromLite() throws Exception {
- UnittestLite.TestEmptyMessageLite emptyMessageLite =
- UnittestLite.TestEmptyMessageLite.parseFrom(allFieldsData);
- UnittestLite.TestEmptyMessageLite emptyMessageLite2 =
- UnittestLite.TestEmptyMessageLite.newBuilder().mergeFrom(emptyMessageLite).build();
- assertEquals(emptyMessageLite.toByteString(), emptyMessageLite2.toByteString());
- }
-
- public void testMergeFromLite() throws Exception {
- TestAllTypes message1 =
- TestAllTypes.newBuilder()
- .setOptionalInt32(1)
- .setOptionalString("foo")
- .addRepeatedString("bar")
- .setOptionalNestedEnum(TestAllTypes.NestedEnum.BAZ)
- .build();
-
- TestAllTypes message2 =
- TestAllTypes.newBuilder()
- .setOptionalInt64(2)
- .setOptionalString("baz")
- .addRepeatedString("qux")
- .setOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ)
- .build();
-
- ByteString data1 = message1.toByteString();
- UnittestLite.TestEmptyMessageLite emptyMessageLite1 =
- UnittestLite.TestEmptyMessageLite.parseFrom(data1);
- ByteString data2 = message2.toByteString();
- UnittestLite.TestEmptyMessageLite emptyMessageLite2 =
- UnittestLite.TestEmptyMessageLite.parseFrom(data2);
-
- message1 = TestAllTypes.newBuilder(message1).mergeFrom(message2).build();
- emptyMessageLite1 =
- UnittestLite.TestEmptyMessageLite.newBuilder(emptyMessageLite1)
- .mergeFrom(emptyMessageLite2)
- .build();
-
- data1 = emptyMessageLite1.toByteString();
- message2 = TestAllTypes.parseFrom(data1);
-
- assertEquals(message1, message2);
- }
-
- public void testWrongTypeTreatedAsUnknownLite() throws Exception {
- // Test that fields of the wrong wire type are treated like unknown fields
- // when parsing.
-
- ByteString bizarroData = getBizarroData();
- TestAllTypes allTypesMessage = TestAllTypes.parseFrom(bizarroData);
- UnittestLite.TestEmptyMessageLite emptyMessageLite =
- UnittestLite.TestEmptyMessageLite.parseFrom(bizarroData);
- ByteString data = emptyMessageLite.toByteString();
- TestAllTypes allTypesMessage2 = TestAllTypes.parseFrom(data);
-
- assertEquals(allTypesMessage.toString(), allTypesMessage2.toString());
- }
-
- public void testUnknownExtensionsLite() throws Exception {
- // Make sure fields are properly parsed to the UnknownFieldSet even when
- // they are declared as extension numbers.
-
- UnittestLite.TestEmptyMessageWithExtensionsLite message =
- UnittestLite.TestEmptyMessageWithExtensionsLite.parseFrom(allFieldsData);
-
- assertEquals(allFieldsData, message.toByteString());
- }
-
- public void testWrongExtensionTypeTreatedAsUnknownLite() throws Exception {
- // Test that fields of the wrong wire type are treated like unknown fields
- // when parsing extensions.
-
- ByteString bizarroData = getBizarroData();
- TestAllExtensions allExtensionsMessage = TestAllExtensions.parseFrom(bizarroData);
- UnittestLite.TestEmptyMessageLite emptyMessageLite =
- UnittestLite.TestEmptyMessageLite.parseFrom(bizarroData);
-
- // All fields should have been interpreted as unknown, so the byte strings
- // should be the same.
- assertEquals(emptyMessageLite.toByteString(), allExtensionsMessage.toByteString());
- }
-
- public void testParseUnknownEnumValueLite() throws Exception {
- Descriptors.FieldDescriptor singularField =
- TestAllTypes.getDescriptor().findFieldByName("optional_nested_enum");
- Descriptors.FieldDescriptor repeatedField =
- TestAllTypes.getDescriptor().findFieldByName("repeated_nested_enum");
- assertNotNull(singularField);
- assertNotNull(repeatedField);
-
- ByteString data =
- UnknownFieldSet.newBuilder()
- .addField(
- singularField.getNumber(),
- UnknownFieldSet.Field.newBuilder()
- .addVarint(TestAllTypes.NestedEnum.BAR.getNumber())
- .addVarint(5) // not valid
- .build())
- .addField(
- repeatedField.getNumber(),
- UnknownFieldSet.Field.newBuilder()
- .addVarint(TestAllTypes.NestedEnum.FOO.getNumber())
- .addVarint(4) // not valid
- .addVarint(TestAllTypes.NestedEnum.BAZ.getNumber())
- .addVarint(6) // not valid
- .build())
- .build()
- .toByteString();
-
- UnittestLite.TestEmptyMessageLite emptyMessageLite =
- UnittestLite.TestEmptyMessageLite.parseFrom(data);
- data = emptyMessageLite.toByteString();
-
- {
- TestAllTypes message = TestAllTypes.parseFrom(data);
- assertEquals(TestAllTypes.NestedEnum.BAR, message.getOptionalNestedEnum());
- assertEquals(
- Arrays.asList(TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAZ),
- message.getRepeatedNestedEnumList());
- assertEquals(
- Arrays.asList(5L),
- message.getUnknownFields().getField(singularField.getNumber()).getVarintList());
- assertEquals(
- Arrays.asList(4L, 6L),
- message.getUnknownFields().getField(repeatedField.getNumber()).getVarintList());
- }
-
- {
- TestAllExtensions message =
- TestAllExtensions.parseFrom(data, TestUtil.getExtensionRegistry());
- assertEquals(
- TestAllTypes.NestedEnum.BAR,
- message.getExtension(UnittestProto.optionalNestedEnumExtension));
- assertEquals(
- Arrays.asList(TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAZ),
- message.getExtension(UnittestProto.repeatedNestedEnumExtension));
- assertEquals(
- Arrays.asList(5L),
- message.getUnknownFields().getField(singularField.getNumber()).getVarintList());
- assertEquals(
- Arrays.asList(4L, 6L),
- message.getUnknownFields().getField(repeatedField.getNumber()).getVarintList());
- }
- }
-
- public void testClearLite() throws Exception {
- UnittestLite.TestEmptyMessageLite emptyMessageLite1 =
- UnittestLite.TestEmptyMessageLite.parseFrom(allFieldsData);
- UnittestLite.TestEmptyMessageLite emptyMessageLite2 =
- UnittestLite.TestEmptyMessageLite.newBuilder().mergeFrom(emptyMessageLite1).clear().build();
- assertEquals(0, emptyMessageLite2.getSerializedSize());
- ByteString data = emptyMessageLite2.toByteString();
- assertEquals(0, data.size());
- }
-}
diff --git a/java/core/src/test/java/com/google/protobuf/Utf8Test.java b/java/core/src/test/java/com/google/protobuf/Utf8Test.java
new file mode 100755
index 0000000..bc3c985
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Utf8Test.java
@@ -0,0 +1,232 @@
+// 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.Arrays;
+import java.util.Random;
+import java.util.regex.Pattern;
+import junit.framework.TestCase;
+
+/** Unit tests for {@link Utf8}. */
+public class Utf8Test extends TestCase {
+ private static final int NUM_CHARS = 16384;
+
+ private static final Utf8.Processor safeProcessor = new Utf8.SafeProcessor();
+ private static final Utf8.Processor unsafeProcessor = new Utf8.UnsafeProcessor();
+
+ public void testEncode() {
+ assertEncoding(randomString(0x80));
+ assertEncoding(randomString(0x90));
+ assertEncoding(randomString(0x800));
+ assertEncoding(randomString(0x10000));
+ assertEncoding(randomString(0x10ffff));
+ }
+
+ public void testEncode_insufficientSpace() {
+ assertEncoding_insufficientSpace(randomString(0x80));
+ assertEncoding_insufficientSpace(randomString(0x90));
+ assertEncoding_insufficientSpace(randomString(0x800));
+ assertEncoding_insufficientSpace(randomString(0x10000));
+ assertEncoding_insufficientSpace(randomString(0x10ffff));
+ }
+
+ public void testValid() {
+ assertIsValid(new byte[] {(byte) 0xE0, (byte) 0xB9, (byte) 0x96}, true);
+ assertIsValid(new byte[] {(byte) 0xF0, (byte) 0xB2, (byte) 0x83, (byte) 0xBC}, true);
+ }
+
+ public void testOverlongIsInvalid() {
+ assertIsValid(new byte[] {(byte) 0xC0, (byte) 0x81}, false);
+ assertIsValid(new byte[] {(byte) 0xE0, (byte) 0x81, (byte) 0x81}, false);
+ assertIsValid(new byte[] {(byte) 0xF0, (byte) 0x81, (byte) 0x81, (byte) 0x81}, false);
+ }
+
+ public void testMaxCodepointExceeded() {
+ // byte1 > 0xF4
+ assertIsValid(new byte[] {(byte) 0xF5, (byte) 0x81, (byte) 0x81, (byte) 0x81}, false);
+ }
+
+ public void testInvalidSurrogateCodepoint() {
+ assertIsValid(new byte[] {(byte) 0xED, (byte) 0xA1, (byte) 0x81}, false);
+
+ // byte1 == 0xF0 && byte2 < 0x90
+ assertIsValid(new byte[] {(byte) 0xF0, (byte) 0x81, (byte) 0x81, (byte) 0x81}, false);
+ // byte1 == 0xF4 && byte2 > 0x8F
+ assertIsValid(new byte[] {(byte) 0xF4, (byte) 0x90, (byte) 0x81, (byte) 0x81}, false);
+ }
+
+ private static String randomString(int maxCodePoint) {
+ final long seed = 99;
+ final Random rnd = new Random(seed);
+ StringBuilder sb = new StringBuilder();
+ for (int j = 0; j < NUM_CHARS; j++) {
+ int codePoint;
+ do {
+ codePoint = rnd.nextInt(maxCodePoint);
+ } while (Utf8Utils.isSurrogate(codePoint));
+ sb.appendCodePoint(codePoint);
+ }
+ return sb.toString();
+ }
+
+ private static void assertIsValid(byte[] data, boolean valid) {
+ assertEquals("isValidUtf8[ARRAY]", valid, safeProcessor.isValidUtf8(data, 0, data.length));
+ assertEquals(
+ "isValidUtf8[ARRAY_UNSAFE]", valid, unsafeProcessor.isValidUtf8(data, 0, data.length));
+
+ ByteBuffer buffer = ByteBuffer.wrap(data);
+ assertEquals(
+ "isValidUtf8[NIO_HEAP]",
+ valid,
+ safeProcessor.isValidUtf8(buffer, buffer.position(), buffer.remaining()));
+
+ // Direct buffers.
+ buffer = ByteBuffer.allocateDirect(data.length);
+ buffer.put(data);
+ buffer.flip();
+ assertEquals(
+ "isValidUtf8[NIO_DEFAULT]",
+ valid,
+ safeProcessor.isValidUtf8(buffer, buffer.position(), buffer.remaining()));
+ assertEquals(
+ "isValidUtf8[NIO_UNSAFE]",
+ valid,
+ unsafeProcessor.isValidUtf8(buffer, buffer.position(), buffer.remaining()));
+ }
+
+ private static void assertEncoding(String message) {
+ byte[] expected = message.getBytes(Internal.UTF_8);
+ byte[] output = encodeToByteArray(message, expected.length, safeProcessor);
+ assertTrue("encodeUtf8[ARRAY]", Arrays.equals(expected, output));
+
+ output = encodeToByteArray(message, expected.length, unsafeProcessor);
+ assertTrue("encodeUtf8[ARRAY_UNSAFE]", Arrays.equals(expected, output));
+
+ output = encodeToByteBuffer(message, expected.length, false, safeProcessor);
+ assertTrue("encodeUtf8[NIO_HEAP]", Arrays.equals(expected, output));
+
+ output = encodeToByteBuffer(message, expected.length, true, safeProcessor);
+ assertTrue("encodeUtf8[NIO_DEFAULT]", Arrays.equals(expected, output));
+
+ output = encodeToByteBuffer(message, expected.length, true, unsafeProcessor);
+ assertTrue("encodeUtf8[NIO_UNSAFE]", Arrays.equals(expected, output));
+ }
+
+ private void assertEncoding_insufficientSpace(String message) {
+ final int length = message.length() - 1;
+ Class<ArrayIndexOutOfBoundsException> clazz = ArrayIndexOutOfBoundsException.class;
+
+ try {
+ encodeToByteArray(message, length, safeProcessor);
+ fail("Expected " + clazz.getSimpleName());
+ } catch (Throwable t) {
+ // Expected
+ assertExceptionType(t, clazz);
+ // byte[] + safeProcessor will not exit early. We can't match the message since we don't
+ // know which char/index due to random input.
+ }
+
+ try {
+ encodeToByteArray(message, length, unsafeProcessor);
+ fail("Expected " + clazz.getSimpleName());
+ } catch (Throwable t) {
+ assertExceptionType(t, clazz);
+ // byte[] + unsafeProcessor will exit early, so we have can match the message.
+ assertExceptionMessage(t, length);
+ }
+
+ try {
+ encodeToByteBuffer(message, length, false, safeProcessor);
+ fail("Expected " + clazz.getSimpleName());
+ } catch (Throwable t) {
+ // Expected
+ assertExceptionType(t, clazz);
+ // ByteBuffer + safeProcessor will not exit early. We can't match the message since we don't
+ // know which char/index due to random input.
+ }
+
+ try {
+ encodeToByteBuffer(message, length, true, safeProcessor);
+ fail("Expected " + clazz.getSimpleName());
+ } catch (Throwable t) {
+ // Expected
+ assertExceptionType(t, clazz);
+ // ByteBuffer + safeProcessor will not exit early. We can't match the message since we don't
+ // know which char/index due to random input.
+ }
+
+ try {
+ encodeToByteBuffer(message, length, true, unsafeProcessor);
+ fail("Expected " + clazz.getSimpleName());
+ } catch (Throwable t) {
+ // Expected
+ assertExceptionType(t, clazz);
+ // Direct ByteBuffer + unsafeProcessor will exit early if it's not on Android, so we can
+ // match the message. On Android, a direct ByteBuffer will have hasArray() being true and
+ // it will take a different code path and produces a different message.
+ if (!Android.isOnAndroidDevice()) {
+ assertExceptionMessage(t, length);
+ }
+ }
+ }
+
+ private static byte[] encodeToByteArray(String message, int length, Utf8.Processor processor) {
+ byte[] output = new byte[length];
+ processor.encodeUtf8(message, output, 0, output.length);
+ return output;
+ }
+
+ private static byte[] encodeToByteBuffer(
+ String message, int length, boolean direct, Utf8.Processor processor) {
+ ByteBuffer buffer = direct ? ByteBuffer.allocateDirect(length) : ByteBuffer.allocate(length);
+
+ processor.encodeUtf8(message, buffer);
+ buffer.flip();
+
+ byte[] output = new byte[buffer.remaining()];
+ buffer.get(output);
+ return output;
+ }
+
+ private <T extends Throwable> void assertExceptionType(Throwable t, Class<T> expected) {
+ if (!expected.isAssignableFrom(t.getClass())) {
+ fail("Expected " + expected.getSimpleName() + ", but found " + t.getClass().getSimpleName());
+ }
+ }
+
+ private void assertExceptionMessage(Throwable t, int index) {
+ String pattern = "Failed writing (.) at index " + index;
+ assertTrue(
+ t.getMessage() + " does not match pattern " + pattern,
+ Pattern.matches(pattern, t.getMessage()));
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/Utf8Utils.java b/java/core/src/test/java/com/google/protobuf/Utf8Utils.java
new file mode 100755
index 0000000..dbd3d39
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/Utf8Utils.java
@@ -0,0 +1,193 @@
+// 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 java.lang.Character.MIN_HIGH_SURROGATE;
+import static java.lang.Character.MIN_LOW_SURROGATE;
+import static java.lang.Character.MIN_SURROGATE;
+
+import java.util.Random;
+
+/** Utilities for benchmarking UTF-8. */
+final class Utf8Utils {
+ private Utf8Utils() {}
+
+ static class MaxCodePoint {
+ final int value;
+
+ /**
+ * Convert the input string to a code point. Accepts regular decimal numerals, hex strings, and
+ * some symbolic names meaningful to humans.
+ */
+ private static int decode(String userFriendly) {
+ try {
+ return Integer.decode(userFriendly);
+ } catch (NumberFormatException ignored) {
+ if (userFriendly.matches("(?i)(?:American|English|ASCII)")) {
+ // 1-byte UTF-8 sequences - "American" ASCII text
+ return 0x80;
+ } else if (userFriendly.matches("(?i)(?:Danish|Latin|Western.*European)")) {
+ // Mostly 1-byte UTF-8 sequences, mixed with occasional 2-byte
+ // sequences - "Western European" text
+ return 0x90;
+ } else if (userFriendly.matches("(?i)(?:Greek|Cyrillic|European|ISO.?8859)")) {
+ // Mostly 2-byte UTF-8 sequences - "European" text
+ return 0x800;
+ } else if (userFriendly.matches("(?i)(?:Chinese|Han|Asian|BMP)")) {
+ // Mostly 3-byte UTF-8 sequences - "Asian" text
+ return Character.MIN_SUPPLEMENTARY_CODE_POINT;
+ } else if (userFriendly.matches("(?i)(?:Cuneiform|rare|exotic|supplementary.*)")) {
+ // Mostly 4-byte UTF-8 sequences - "rare exotic" text
+ return Character.MAX_CODE_POINT;
+ } else {
+ throw new IllegalArgumentException("Can't decode codepoint " + userFriendly);
+ }
+ }
+ }
+
+ public static MaxCodePoint valueOf(String userFriendly) {
+ return new MaxCodePoint(userFriendly);
+ }
+
+ public MaxCodePoint(String userFriendly) {
+ value = decode(userFriendly);
+ }
+ }
+
+ /**
+ * The Utf8 distribution of real data. The distribution is an array with length 4.
+ * "distribution[i]" means the total number of characters who are encoded with (i + 1) bytes.
+ *
+ * <p>GMM_UTF8_DISTRIBUTION is the distribution of gmm data set. GSR_UTF8_DISTRIBUTION is the
+ * distribution of gsreq/gsresp data set
+ */
+ public enum Utf8Distribution {
+ GMM_UTF8_DISTRIBUTION {
+ @Override
+ public int[] getDistribution() {
+ return new int[] {53059, 104, 0, 0};
+ }
+ },
+ GSR_UTF8_DISTRIBUTION {
+ @Override
+ public int[] getDistribution() {
+ return new int[] {119458, 74, 2706, 0};
+ }
+ };
+
+ public abstract int[] getDistribution();
+ }
+
+ /**
+ * Creates an array of random strings.
+ *
+ * @param stringCount the number of strings to be created.
+ * @param charCount the number of characters per string.
+ * @param maxCodePoint the maximum code point for the characters in the strings.
+ * @return an array of random strings.
+ */
+ static String[] randomStrings(int stringCount, int charCount, MaxCodePoint maxCodePoint) {
+ final long seed = 99;
+ final Random rnd = new Random(seed);
+ String[] strings = new String[stringCount];
+ for (int i = 0; i < stringCount; i++) {
+ strings[i] = randomString(rnd, charCount, maxCodePoint);
+ }
+ return strings;
+ }
+
+ /**
+ * Creates a random string
+ *
+ * @param rnd the random generator.
+ * @param charCount the number of characters per string.
+ * @param maxCodePoint the maximum code point for the characters in the strings.
+ */
+ static String randomString(Random rnd, int charCount, MaxCodePoint maxCodePoint) {
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < charCount; i++) {
+ int codePoint;
+ do {
+ codePoint = rnd.nextInt(maxCodePoint.value);
+ } while (Utf8Utils.isSurrogate(codePoint));
+ sb.appendCodePoint(codePoint);
+ }
+ return sb.toString();
+ }
+
+ /** Character.isSurrogate was added in Java SE 7. */
+ static boolean isSurrogate(int c) {
+ return Character.MIN_HIGH_SURROGATE <= c && c <= Character.MAX_LOW_SURROGATE;
+ }
+
+ /**
+ * Creates an array of random strings according to UTF8 distribution.
+ *
+ * @param stringCount the number of strings to be created.
+ * @param charCount the number of characters per string.
+ */
+ static String[] randomStringsWithDistribution(
+ int stringCount, int charCount, Utf8Distribution utf8Distribution) {
+ final int[] distribution = utf8Distribution.getDistribution();
+ for (int i = 0; i < 3; i++) {
+ distribution[i + 1] += distribution[i];
+ }
+ final long seed = 99;
+ final Random rnd = new Random(seed);
+ String[] strings = new String[stringCount];
+ for (int i = 0; i < stringCount; i++) {
+ StringBuilder sb = new StringBuilder();
+ for (int j = 0; j < charCount; j++) {
+ int codePoint;
+ do {
+ codePoint = rnd.nextInt(distribution[3]);
+ if (codePoint < distribution[0]) {
+ // 1 bytes
+ sb.append(0x7F);
+ } else if (codePoint < distribution[1]) {
+ // 2 bytes
+ sb.append(0x7FF);
+ } else if (codePoint < distribution[2]) {
+ // 3 bytes
+ sb.append(MIN_SURROGATE - 1);
+ } else {
+ // 4 bytes
+ sb.append(MIN_HIGH_SURROGATE);
+ sb.append(MIN_LOW_SURROGATE);
+ }
+ } while (Utf8Utils.isSurrogate(codePoint));
+ sb.appendCodePoint(codePoint);
+ }
+ strings[i] = sb.toString();
+ }
+ return strings;
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/WireFormatLiteTest.java b/java/core/src/test/java/com/google/protobuf/WireFormatLiteTest.java
new file mode 100755
index 0000000..a725d41
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/WireFormatLiteTest.java
@@ -0,0 +1,1023 @@
+// 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.UnittestLite.optionalForeignEnumExtensionLite;
+
+import com.google.protobuf.UnittestLite.ForeignEnumLite;
+import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
+import com.google.protobuf.UnittestLite.TestPackedExtensionsLite;
+import map_test.MapForProto2TestProto;
+import map_test.MapTestProto.TestMap;
+import protobuf_unittest.UnittestMset.RawMessageSet;
+import protobuf_unittest.UnittestMset.TestMessageSetExtension1;
+import protobuf_unittest.UnittestMset.TestMessageSetExtension2;
+import protobuf_unittest.UnittestProto;
+import protobuf_unittest.UnittestProto.TestAllExtensions;
+import protobuf_unittest.UnittestProto.TestAllTypes;
+import protobuf_unittest.UnittestProto.TestExtensionInsideTable;
+import protobuf_unittest.UnittestProto.TestFieldOrderings;
+import protobuf_unittest.UnittestProto.TestOneof2;
+import protobuf_unittest.UnittestProto.TestOneofBackwardsCompatible;
+import protobuf_unittest.UnittestProto.TestPackedExtensions;
+import protobuf_unittest.UnittestProto.TestPackedTypes;
+import proto2_wireformat_unittest.UnittestMsetWireFormat.TestMessageSet;
+import proto3_unittest.UnittestProto3;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.List;
+import junit.framework.TestCase;
+
+public class WireFormatLiteTest extends TestCase {
+ public void testSerializeExtensionsLite() throws Exception {
+ // TestAllTypes and TestAllExtensions should have compatible wire formats,
+ // so if we serialize a TestAllExtensions then parse it as TestAllTypes
+ // it should work.
+
+ TestAllExtensionsLite message = TestUtilLite.getAllLiteExtensionsSet();
+ ByteString rawBytes = message.toByteString();
+ assertEquals(rawBytes.size(), message.getSerializedSize());
+
+ TestAllTypes message2 = TestAllTypes.parseFrom(rawBytes);
+
+ TestUtil.assertAllFieldsSet(message2);
+ }
+
+ public void testSerializePackedExtensionsLite() throws Exception {
+ // TestPackedTypes and TestPackedExtensions should have compatible wire
+ // formats; check that they serialize to the same string.
+ TestPackedExtensionsLite message = TestUtilLite.getLitePackedExtensionsSet();
+ ByteString rawBytes = message.toByteString();
+
+ TestPackedTypes message2 = TestUtil.getPackedSet();
+ ByteString rawBytes2 = message2.toByteString();
+
+ assertEquals(rawBytes, rawBytes2);
+ }
+
+ public void testParseExtensionsLite() throws Exception {
+ // TestAllTypes and TestAllExtensions should have compatible wire formats,
+ // so if we serialize a TestAllTypes then parse it as TestAllExtensions
+ // it should work.
+
+ TestAllTypes message = TestUtil.getAllSet();
+ ByteString rawBytes = message.toByteString();
+
+ ExtensionRegistryLite registryLite = TestUtilLite.getExtensionRegistryLite();
+
+ TestAllExtensionsLite message2 = TestAllExtensionsLite.parseFrom(rawBytes, registryLite);
+ TestUtil.assertAllExtensionsSet(message2);
+ message2 = TestAllExtensionsLite.parseFrom(message.toByteArray(), registryLite);
+ TestUtil.assertAllExtensionsSet(message2);
+ }
+
+ public void testParsePackedExtensionsLite() throws Exception {
+ // Ensure that packed extensions can be properly parsed.
+ TestPackedExtensionsLite message = TestUtilLite.getLitePackedExtensionsSet();
+ ByteString rawBytes = message.toByteString();
+
+ ExtensionRegistryLite registry = TestUtilLite.getExtensionRegistryLite();
+
+ TestPackedExtensionsLite message2 = TestPackedExtensionsLite.parseFrom(rawBytes, registry);
+ TestUtil.assertPackedExtensionsSet(message2);
+ message2 = TestPackedExtensionsLite.parseFrom(message.toByteArray(), registry);
+ TestUtil.assertPackedExtensionsSet(message2);
+ }
+
+ public void testSerialization() throws Exception {
+ TestAllTypes message = TestUtil.getAllSet();
+
+ ByteString rawBytes = message.toByteString();
+ assertEquals(rawBytes.size(), message.getSerializedSize());
+
+ TestAllTypes message2 = TestAllTypes.parseFrom(rawBytes);
+
+ TestUtil.assertAllFieldsSet(message2);
+ }
+
+ public void testSerializationPacked() throws Exception {
+ TestPackedTypes message = TestUtil.getPackedSet();
+
+ ByteString rawBytes = message.toByteString();
+ assertEquals(rawBytes.size(), message.getSerializedSize());
+
+ TestPackedTypes message2 = TestPackedTypes.parseFrom(rawBytes);
+
+ TestUtil.assertPackedFieldsSet(message2);
+ }
+
+ public void testSerializeExtensions() throws Exception {
+ // TestAllTypes and TestAllExtensions should have compatible wire formats,
+ // so if we serialize a TestAllExtensions then parse it as TestAllTypes
+ // it should work.
+
+ TestAllExtensions message = TestUtil.getAllExtensionsSet();
+ ByteString rawBytes = message.toByteString();
+ assertEquals(rawBytes.size(), message.getSerializedSize());
+
+ TestAllTypes message2 = TestAllTypes.parseFrom(rawBytes);
+
+ TestUtil.assertAllFieldsSet(message2);
+ }
+
+ public void testSerializePackedExtensions() throws Exception {
+ // TestPackedTypes and TestPackedExtensions should have compatible wire
+ // formats; check that they serialize to the same string.
+ TestPackedExtensions message = TestUtil.getPackedExtensionsSet();
+ ByteString rawBytes = message.toByteString();
+
+ TestPackedTypes message2 = TestUtil.getPackedSet();
+ ByteString rawBytes2 = message2.toByteString();
+
+ assertEquals(rawBytes, rawBytes2);
+ }
+
+ public void testSerializationPackedWithoutGetSerializedSize() throws Exception {
+ // Write directly to an OutputStream, without invoking getSerializedSize()
+ // This used to be a bug where the size of a packed field was incorrect,
+ // since getSerializedSize() was never invoked.
+ TestPackedTypes message = TestUtil.getPackedSet();
+
+ // Directly construct a CodedOutputStream around the actual OutputStream,
+ // in case writeTo(OutputStream output) invokes getSerializedSize();
+ ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+ CodedOutputStream codedOutput = CodedOutputStream.newInstance(outputStream);
+
+ message.writeTo(codedOutput);
+
+ codedOutput.flush();
+
+ TestPackedTypes message2 = TestPackedTypes.parseFrom(outputStream.toByteArray());
+
+ TestUtil.assertPackedFieldsSet(message2);
+ }
+
+ public void testParseExtensions() throws Exception {
+ // TestAllTypes and TestAllExtensions should have compatible wire formats,
+ // so if we serialize a TestAllTypes then parse it as TestAllExtensions
+ // it should work.
+
+ TestAllTypes message = TestUtil.getAllSet();
+ ByteString rawBytes = message.toByteString();
+
+ ExtensionRegistryLite registry = TestUtil.getExtensionRegistry();
+
+ TestAllExtensions message2 = TestAllExtensions.parseFrom(rawBytes, registry);
+
+ TestUtil.assertAllExtensionsSet(message2);
+ }
+
+ public void testParsePackedExtensions() throws Exception {
+ // Ensure that packed extensions can be properly parsed.
+ TestPackedExtensions message = TestUtil.getPackedExtensionsSet();
+ ByteString rawBytes = message.toByteString();
+
+ ExtensionRegistryLite registry = TestUtil.getExtensionRegistry();
+
+ TestPackedExtensions message2 = TestPackedExtensions.parseFrom(rawBytes, registry);
+
+ TestUtil.assertPackedExtensionsSet(message2);
+ }
+
+ public void testSerializeDelimited() throws Exception {
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ TestUtil.getAllSet().writeDelimitedTo(output);
+ output.write(12);
+ TestUtil.getPackedSet().writeDelimitedTo(output);
+ output.write(34);
+
+ ByteArrayInputStream input = new ByteArrayInputStream(output.toByteArray());
+
+ TestUtil.assertAllFieldsSet(TestAllTypes.parseDelimitedFrom(input));
+ assertEquals(12, input.read());
+ TestUtil.assertPackedFieldsSet(TestPackedTypes.parseDelimitedFrom(input));
+ assertEquals(34, input.read());
+ assertEquals(-1, input.read());
+
+ // We're at EOF, so parsing again should return null.
+ assertNull(TestAllTypes.parseDelimitedFrom(input));
+ }
+
+ private ExtensionRegistryLite getTestFieldOrderingsRegistry() {
+ ExtensionRegistryLite result = ExtensionRegistryLite.newInstance();
+ result.add(UnittestProto.myExtensionInt);
+ result.add(UnittestProto.myExtensionString);
+ return result;
+ }
+
+ public void testParseMultipleExtensionRanges() throws Exception {
+ // Make sure we can parse a message that contains multiple extensions
+ // ranges.
+ TestFieldOrderings source =
+ TestFieldOrderings.newBuilder()
+ .setMyInt(1)
+ .setMyString("foo")
+ .setMyFloat(1.0F)
+ .setExtension(UnittestProto.myExtensionInt, 23)
+ .setExtension(UnittestProto.myExtensionString, "bar")
+ .build();
+ TestFieldOrderings dest =
+ TestFieldOrderings.parseFrom(source.toByteString(), getTestFieldOrderingsRegistry());
+ assertEquals(source, dest);
+ }
+
+ private static ExtensionRegistryLite getTestExtensionInsideTableRegistry() {
+ ExtensionRegistryLite result = ExtensionRegistryLite.newInstance();
+ result.add(UnittestProto.testExtensionInsideTableExtension);
+ return result;
+ }
+
+ public void testExtensionInsideTable() throws Exception {
+ // Make sure the extension within the range of table is parsed correctly in experimental
+ // runtime.
+ TestExtensionInsideTable source =
+ TestExtensionInsideTable.newBuilder()
+ .setField1(1)
+ .setExtension(UnittestProto.testExtensionInsideTableExtension, 23)
+ .build();
+ TestExtensionInsideTable dest =
+ TestExtensionInsideTable.parseFrom(
+ source.toByteString(), getTestExtensionInsideTableRegistry());
+ assertEquals(source, dest);
+ }
+
+ private static final int UNKNOWN_TYPE_ID = 1550055;
+ private static final int TYPE_ID_1 = 1545008;
+ private static final int TYPE_ID_2 = 1547769;
+
+ public void testSerializeMessageSetEagerly() throws Exception {
+ testSerializeMessageSetWithFlag(true);
+ }
+
+ public void testSerializeMessageSetNotEagerly() throws Exception {
+ testSerializeMessageSetWithFlag(false);
+ }
+
+ private void testSerializeMessageSetWithFlag(boolean eagerParsing) throws Exception {
+ ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+ CodedOutputStream output = CodedOutputStream.newInstance(byteArrayOutputStream);
+ output.writeRawMessageSetExtension(UNKNOWN_TYPE_ID, ByteString.copyFromUtf8("bar"));
+ output.flush();
+ byte[] messageSetBytes = byteArrayOutputStream.toByteArray();
+
+ ExtensionRegistryLite.setEagerlyParseMessageSets(eagerParsing);
+ // Set up a TestMessageSet with two known messages and an unknown one.
+ TestMessageSet messageSet =
+ TestMessageSet.newBuilder()
+ .setExtension(
+ TestMessageSetExtension1.messageSetExtension,
+ TestMessageSetExtension1.newBuilder().setI(123).build())
+ .setExtension(
+ TestMessageSetExtension2.messageSetExtension,
+ TestMessageSetExtension2.newBuilder().setStr("foo").build())
+ .mergeFrom(messageSetBytes)
+ .build();
+
+ ByteString data = messageSet.toByteString();
+
+ // Parse back using RawMessageSet and check the contents.
+ RawMessageSet raw = RawMessageSet.parseFrom(data);
+
+ assertEquals(3, raw.getItemCount());
+ assertEquals(TYPE_ID_1, raw.getItem(0).getTypeId());
+ assertEquals(TYPE_ID_2, raw.getItem(1).getTypeId());
+ assertEquals(UNKNOWN_TYPE_ID, raw.getItem(2).getTypeId());
+
+ TestMessageSetExtension1 message1 =
+ TestMessageSetExtension1.parseFrom(raw.getItem(0).getMessage());
+ assertEquals(123, message1.getI());
+
+ TestMessageSetExtension2 message2 =
+ TestMessageSetExtension2.parseFrom(raw.getItem(1).getMessage());
+ assertEquals("foo", message2.getStr());
+
+ assertEquals("bar", raw.getItem(2).getMessage().toStringUtf8());
+ }
+
+ public void testParseMessageSetEagerly() throws Exception {
+ testParseMessageSetWithFlag(true);
+ }
+
+ public void testParseMessageSetNotEagerly() throws Exception {
+ testParseMessageSetWithFlag(false);
+ }
+
+ private void testParseMessageSetWithFlag(boolean eagerParsing) throws Exception {
+ ExtensionRegistryLite.setEagerlyParseMessageSets(eagerParsing);
+ ExtensionRegistryLite extensionRegistry = ExtensionRegistryLite.newInstance();
+ extensionRegistry.add(TestMessageSetExtension1.messageSetExtension);
+ extensionRegistry.add(TestMessageSetExtension2.messageSetExtension);
+
+ // Set up a RawMessageSet with two known messages and an unknown one.
+ RawMessageSet raw =
+ RawMessageSet.newBuilder()
+ .addItem(
+ RawMessageSet.Item.newBuilder()
+ .setTypeId(TYPE_ID_1)
+ .setMessage(
+ TestMessageSetExtension1.newBuilder().setI(123).build().toByteString())
+ .build())
+ .addItem(
+ RawMessageSet.Item.newBuilder()
+ .setTypeId(TYPE_ID_2)
+ .setMessage(
+ TestMessageSetExtension2.newBuilder().setStr("foo").build().toByteString())
+ .build())
+ .addItem(
+ RawMessageSet.Item.newBuilder()
+ .setTypeId(UNKNOWN_TYPE_ID)
+ .setMessage(ByteString.copyFromUtf8("bar"))
+ .build())
+ .build();
+
+ ByteString data = raw.toByteString();
+
+ // Parse as a TestMessageSet and check the contents.
+ TestMessageSet messageSet = TestMessageSet.parseFrom(data, extensionRegistry);
+
+ assertEquals(123, messageSet.getExtension(TestMessageSetExtension1.messageSetExtension).getI());
+ assertEquals(
+ "foo", messageSet.getExtension(TestMessageSetExtension2.messageSetExtension).getStr());
+ }
+
+ public void testParseMessageSetExtensionEagerly() throws Exception {
+ testParseMessageSetExtensionWithFlag(true);
+ }
+
+ public void testParseMessageSetExtensionNotEagerly() throws Exception {
+ testParseMessageSetExtensionWithFlag(false);
+ }
+
+ private void testParseMessageSetExtensionWithFlag(boolean eagerParsing) throws Exception {
+ ExtensionRegistryLite.setEagerlyParseMessageSets(eagerParsing);
+ ExtensionRegistryLite extensionRegistry = ExtensionRegistryLite.newInstance();
+ extensionRegistry.add(TestMessageSetExtension1.messageSetExtension);
+
+ // Set up a RawMessageSet with a known messages.
+ int typeId1 = 1545008;
+ RawMessageSet raw =
+ RawMessageSet.newBuilder()
+ .addItem(
+ RawMessageSet.Item.newBuilder()
+ .setTypeId(typeId1)
+ .setMessage(
+ TestMessageSetExtension1.newBuilder().setI(123).build().toByteString())
+ .build())
+ .build();
+
+ ByteString data = raw.toByteString();
+
+ // Parse as a TestMessageSet and check the contents.
+ TestMessageSet messageSet = TestMessageSet.parseFrom(data, extensionRegistry);
+ assertEquals(123, messageSet.getExtension(TestMessageSetExtension1.messageSetExtension).getI());
+ }
+
+ public void testMergeLazyMessageSetExtensionEagerly() throws Exception {
+ testMergeLazyMessageSetExtensionWithFlag(true);
+ }
+
+ public void testMergeLazyMessageSetExtensionNotEagerly() throws Exception {
+ testMergeLazyMessageSetExtensionWithFlag(false);
+ }
+
+ private void testMergeLazyMessageSetExtensionWithFlag(boolean eagerParsing) throws Exception {
+ ExtensionRegistryLite.setEagerlyParseMessageSets(eagerParsing);
+ ExtensionRegistryLite extensionRegistry = ExtensionRegistryLite.newInstance();
+ extensionRegistry.add(TestMessageSetExtension1.messageSetExtension);
+
+ // Set up a RawMessageSet with a known messages.
+ int typeId1 = 1545008;
+ RawMessageSet raw =
+ RawMessageSet.newBuilder()
+ .addItem(
+ RawMessageSet.Item.newBuilder()
+ .setTypeId(typeId1)
+ .setMessage(
+ TestMessageSetExtension1.newBuilder().setI(123).build().toByteString())
+ .build())
+ .build();
+
+ ByteString data = raw.toByteString();
+
+ // Parse as a TestMessageSet and store value into lazy field
+ TestMessageSet messageSet = TestMessageSet.parseFrom(data, extensionRegistry);
+ // Merge lazy field check the contents.
+ messageSet = messageSet.toBuilder().mergeFrom(data, extensionRegistry).build();
+ assertEquals(123, messageSet.getExtension(TestMessageSetExtension1.messageSetExtension).getI());
+ }
+
+ public void testMergeMessageSetExtensionEagerly() throws Exception {
+ testMergeMessageSetExtensionWithFlag(true);
+ }
+
+ public void testMergeMessageSetExtensionNotEagerly() throws Exception {
+ testMergeMessageSetExtensionWithFlag(false);
+ }
+
+ private void testMergeMessageSetExtensionWithFlag(boolean eagerParsing) throws Exception {
+ ExtensionRegistryLite.setEagerlyParseMessageSets(eagerParsing);
+ ExtensionRegistryLite extensionRegistry = ExtensionRegistryLite.newInstance();
+ extensionRegistry.add(TestMessageSetExtension1.messageSetExtension);
+
+ // Set up a RawMessageSet with a known messages.
+ int typeId1 = 1545008;
+ RawMessageSet raw =
+ RawMessageSet.newBuilder()
+ .addItem(
+ RawMessageSet.Item.newBuilder()
+ .setTypeId(typeId1)
+ .setMessage(
+ TestMessageSetExtension1.newBuilder().setI(123).build().toByteString())
+ .build())
+ .build();
+
+ // Serialize RawMessageSet unnormally (message value before type id)
+ ByteString.CodedBuilder out = ByteString.newCodedBuilder(raw.getSerializedSize());
+ CodedOutputStream output = out.getCodedOutput();
+ List<RawMessageSet.Item> items = raw.getItemList();
+ for (RawMessageSet.Item item : items) {
+ output.writeTag(1, WireFormat.WIRETYPE_START_GROUP);
+ output.writeBytes(3, item.getMessage());
+ output.writeInt32(2, item.getTypeId());
+ output.writeTag(1, WireFormat.WIRETYPE_END_GROUP);
+ }
+ ByteString data = out.build();
+
+ // Merge bytes into TestMessageSet and check the contents.
+ TestMessageSet messageSet =
+ TestMessageSet.newBuilder().mergeFrom(data, extensionRegistry).build();
+ assertEquals(123, messageSet.getExtension(TestMessageSetExtension1.messageSetExtension).getI());
+ }
+
+ // ================================================================
+ // oneof
+ public void testOneofWireFormat() throws Exception {
+ TestOneof2.Builder builder = TestOneof2.newBuilder();
+ TestUtil.setOneof(builder);
+ TestOneof2 message = builder.build();
+ ByteString rawBytes = message.toByteString();
+
+ assertEquals(rawBytes.size(), message.getSerializedSize());
+
+ TestOneof2 message2 = TestOneof2.parseFrom(rawBytes);
+ TestUtil.assertOneofSet(message2);
+ }
+
+ public void testOneofOnlyLastSet() throws Exception {
+ TestOneofBackwardsCompatible source =
+ TestOneofBackwardsCompatible.newBuilder().setFooInt(100).setFooString("101").build();
+
+ ByteString rawBytes = source.toByteString();
+ TestOneof2 message = TestOneof2.parseFrom(rawBytes);
+ assertFalse(message.hasFooInt());
+ assertTrue(message.hasFooString());
+ }
+
+ private void assertInvalidWireFormat(
+ MessageLite defaultInstance, byte[] data, int offset, int length) {
+ // Test all combinations: (builder vs parser) x (byte[] vs. InputStream).
+ try {
+ defaultInstance.newBuilderForType().mergeFrom(data, offset, length);
+ fail("Expected exception");
+ } catch (InvalidProtocolBufferException e) {
+ // Pass.
+ }
+ try {
+ defaultInstance.getParserForType().parseFrom(data, offset, length);
+ fail("Expected exception");
+ } catch (InvalidProtocolBufferException e) {
+ // Pass.
+ }
+ try {
+ InputStream input = new ByteArrayInputStream(data, offset, length);
+ defaultInstance.newBuilderForType().mergeFrom(input);
+ fail("Expected exception");
+ } catch (IOException e) {
+ // Pass.
+ }
+ try {
+ InputStream input = new ByteArrayInputStream(data, offset, length);
+ defaultInstance.getParserForType().parseFrom(input);
+ fail("Expected exception");
+ } catch (IOException e) {
+ // Pass.
+ }
+ }
+
+ private void assertInvalidWireFormat(MessageLite defaultInstance, byte[] data) {
+ assertInvalidWireFormat(defaultInstance, data, 0, data.length);
+ }
+
+ private void assertInvalidWireFormat(byte[] data) {
+ assertInvalidWireFormat(TestAllTypes.getDefaultInstance(), data);
+ assertInvalidWireFormat(UnittestProto3.TestAllTypes.getDefaultInstance(), data);
+ }
+
+ public void testParserRejectInvalidTag() throws Exception {
+ byte[] invalidTags =
+ new byte[] {
+ // Zero tag is not allowed.
+ 0,
+ // Invalid wire types.
+ (byte) WireFormat.makeTag(1, 6),
+ (byte) WireFormat.makeTag(1, 7),
+ // Field number 0 is not allowed.
+ (byte) WireFormat.makeTag(0, WireFormat.WIRETYPE_VARINT),
+ };
+ for (byte invalidTag : invalidTags) {
+ // Add a trailing 0 to make sure the parsing actually fails on the tag.
+ byte[] data = new byte[] {invalidTag, 0};
+ assertInvalidWireFormat(data);
+
+ // Invalid tag in an unknown group field.
+ data =
+ new byte[] {
+ (byte) WireFormat.makeTag(1, WireFormat.WIRETYPE_START_GROUP),
+ invalidTag,
+ 0,
+ (byte) WireFormat.makeTag(1, WireFormat.WIRETYPE_END_GROUP),
+ };
+ assertInvalidWireFormat(data);
+
+ // Invalid tag in a MessageSet item.
+ data =
+ new byte[] {
+ (byte) WireFormat.MESSAGE_SET_ITEM_TAG,
+ (byte) WireFormat.MESSAGE_SET_TYPE_ID_TAG,
+ 100, // TYPE_ID = 100
+ (byte) WireFormat.MESSAGE_SET_MESSAGE_TAG,
+ 0, // empty payload
+ invalidTag,
+ 0,
+ (byte) WireFormat.MESSAGE_SET_ITEM_END_TAG,
+ };
+ assertInvalidWireFormat(TestMessageSet.getDefaultInstance(), data);
+
+ // Invalid tag inside a MessageSet item's unknown group.
+ data =
+ new byte[] {
+ (byte) WireFormat.MESSAGE_SET_ITEM_TAG,
+ (byte) WireFormat.MESSAGE_SET_TYPE_ID_TAG,
+ 100, // TYPE_ID = 100
+ (byte) WireFormat.MESSAGE_SET_MESSAGE_TAG,
+ 0, // empty payload
+ (byte) WireFormat.makeTag(4, WireFormat.WIRETYPE_START_GROUP),
+ invalidTag,
+ 0,
+ (byte) WireFormat.makeTag(4, WireFormat.WIRETYPE_END_GROUP),
+ (byte) WireFormat.MESSAGE_SET_ITEM_END_TAG,
+ };
+ assertInvalidWireFormat(TestMessageSet.getDefaultInstance(), data);
+
+ // Invalid tag inside a map field.
+ data =
+ new byte[] {
+ (byte) WireFormat.makeTag(1, WireFormat.WIRETYPE_LENGTH_DELIMITED), 2, invalidTag, 0,
+ };
+ assertInvalidWireFormat(TestMap.getDefaultInstance(), data);
+ }
+ }
+
+ public void testUnmatchedGroupTag() throws Exception {
+ int startTag = WireFormat.makeTag(16, WireFormat.WIRETYPE_START_GROUP);
+ byte[] data =
+ new byte[] {
+ (byte) ((startTag & 0x7F) | 0x80), (byte) ((startTag >>> 7) & 0x7F),
+ };
+ assertInvalidWireFormat(data);
+
+ // Unmatched group tags inside a MessageSet item.
+ data =
+ new byte[] {
+ (byte) WireFormat.MESSAGE_SET_ITEM_TAG,
+ (byte) WireFormat.MESSAGE_SET_TYPE_ID_TAG,
+ 100, // TYPE_ID = 100
+ (byte) WireFormat.MESSAGE_SET_MESSAGE_TAG,
+ 0, // empty payload
+ (byte) WireFormat.makeTag(4, WireFormat.WIRETYPE_START_GROUP),
+ };
+ assertInvalidWireFormat(TestMessageSet.getDefaultInstance(), data);
+ }
+
+ private void assertAccepted(MessageLite defaultInstance, byte[] data) throws Exception {
+ MessageLite message1 = defaultInstance.newBuilderForType().mergeFrom(data).build();
+ MessageLite message2 = defaultInstance.getParserForType().parseFrom(data);
+ MessageLite message3 =
+ defaultInstance.newBuilderForType().mergeFrom(new ByteArrayInputStream(data)).build();
+ MessageLite message4 =
+ defaultInstance.getParserForType().parseFrom(new ByteArrayInputStream(data));
+ assertEquals(message1, message2);
+ assertEquals(message2, message3);
+ assertEquals(message3, message4);
+ }
+
+ public void testUnmatchedWireType() throws Exception {
+ // Build a payload with all fields from 1 to 128 being varints. Parsing it into TestAllTypes
+ // or other message types should succeed even though the wire type doesn't match for some
+ // fields.
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ CodedOutputStream codedOutput = CodedOutputStream.newInstance(output);
+ for (int i = 1; i <= 128; i++) {
+ codedOutput.writeInt32(i, 0);
+ }
+ codedOutput.flush();
+ byte[] data = output.toByteArray();
+ // It can be parsed into any message type that doesn't have required fields.
+ assertAccepted(TestAllTypes.getDefaultInstance(), data);
+ assertAccepted(UnittestProto3.TestAllTypes.getDefaultInstance(), data);
+ assertAccepted(TestMap.getDefaultInstance(), data);
+ assertAccepted(MapForProto2TestProto.TestMap.getDefaultInstance(), data);
+ }
+
+ public void testParseTruncatedPackedFields() throws Exception {
+ TestPackedTypes all = TestUtil.getPackedSet();
+ TestPackedTypes[] messages =
+ new TestPackedTypes[] {
+ TestPackedTypes.newBuilder().addAllPackedInt32(all.getPackedInt32List()).build(),
+ TestPackedTypes.newBuilder().addAllPackedInt64(all.getPackedInt64List()).build(),
+ TestPackedTypes.newBuilder().addAllPackedUint32(all.getPackedUint32List()).build(),
+ TestPackedTypes.newBuilder().addAllPackedUint64(all.getPackedUint64List()).build(),
+ TestPackedTypes.newBuilder().addAllPackedSint32(all.getPackedSint32List()).build(),
+ TestPackedTypes.newBuilder().addAllPackedSint64(all.getPackedSint64List()).build(),
+ TestPackedTypes.newBuilder().addAllPackedFixed32(all.getPackedFixed32List()).build(),
+ TestPackedTypes.newBuilder().addAllPackedFixed64(all.getPackedFixed64List()).build(),
+ TestPackedTypes.newBuilder().addAllPackedSfixed32(all.getPackedSfixed32List()).build(),
+ TestPackedTypes.newBuilder().addAllPackedSfixed64(all.getPackedSfixed64List()).build(),
+ TestPackedTypes.newBuilder().addAllPackedFloat(all.getPackedFloatList()).build(),
+ TestPackedTypes.newBuilder().addAllPackedDouble(all.getPackedDoubleList()).build(),
+ TestPackedTypes.newBuilder().addAllPackedEnum(all.getPackedEnumList()).build(),
+ };
+ for (TestPackedTypes message : messages) {
+ byte[] data = message.toByteArray();
+ // Parsing truncated payload should fail.
+ for (int i = 1; i < data.length; i++) {
+ assertInvalidWireFormat(TestPackedTypes.getDefaultInstance(), data, 0, i);
+ }
+ }
+ }
+
+ public void testParsePackedFieldsWithIncorrectLength() throws Exception {
+ // Set the length-prefix to 1 with a 4-bytes payload to test what happens when reading a packed
+ // element moves the reading position past the given length limit. It should result in an
+ // InvalidProtocolBufferException but an implementation may forget to check it especially for
+ // packed varint fields.
+ byte[] data =
+ new byte[] {
+ 0,
+ 0, // first two bytes is reserved for the tag.
+ 1, // length is 1
+ (byte) 0x80,
+ (byte) 0x80,
+ (byte) 0x80,
+ (byte) 0x01, // a 4-bytes varint
+ };
+ // All fields that can read a 4-bytes varint (all varint fields and fixed 32-bit fields).
+ int[] fieldNumbers =
+ new int[] {
+ TestPackedTypes.PACKED_INT32_FIELD_NUMBER,
+ TestPackedTypes.PACKED_INT64_FIELD_NUMBER,
+ TestPackedTypes.PACKED_UINT32_FIELD_NUMBER,
+ TestPackedTypes.PACKED_UINT64_FIELD_NUMBER,
+ TestPackedTypes.PACKED_SINT32_FIELD_NUMBER,
+ TestPackedTypes.PACKED_SINT64_FIELD_NUMBER,
+ TestPackedTypes.PACKED_FIXED32_FIELD_NUMBER,
+ TestPackedTypes.PACKED_SFIXED32_FIELD_NUMBER,
+ TestPackedTypes.PACKED_FLOAT_FIELD_NUMBER,
+ TestPackedTypes.PACKED_BOOL_FIELD_NUMBER,
+ TestPackedTypes.PACKED_ENUM_FIELD_NUMBER,
+ };
+ for (int number : fieldNumbers) {
+ // Set the tag.
+ data[0] =
+ (byte) ((WireFormat.makeTag(number, WireFormat.WIRETYPE_LENGTH_DELIMITED) & 0x7F) | 0x80);
+ data[1] =
+ (byte) ((WireFormat.makeTag(number, WireFormat.WIRETYPE_LENGTH_DELIMITED) >>> 7) & 0x7F);
+ assertInvalidWireFormat(TestPackedTypes.getDefaultInstance(), data);
+ }
+
+ // Data with 8-bytes payload to test some fixed 64-bit fields.
+ byte[] data8Bytes =
+ new byte[] {
+ 0,
+ 0, // first two bytes is reserved for the tag.
+ 1, // length is 1
+ (byte) 0x80,
+ (byte) 0x80,
+ (byte) 0x80,
+ (byte) 0x80,
+ (byte) 0x80,
+ (byte) 0x80,
+ (byte) 0x80,
+ (byte) 0x01, // a 8-bytes varint
+ };
+ // All fields that can only read 8-bytes data.
+ int[] fieldNumbers8Bytes =
+ new int[] {
+ TestPackedTypes.PACKED_FIXED64_FIELD_NUMBER,
+ TestPackedTypes.PACKED_SFIXED64_FIELD_NUMBER,
+ TestPackedTypes.PACKED_DOUBLE_FIELD_NUMBER,
+ };
+ for (int number : fieldNumbers8Bytes) {
+ // Set the tag.
+ data8Bytes[0] =
+ (byte) ((WireFormat.makeTag(number, WireFormat.WIRETYPE_LENGTH_DELIMITED) & 0x7F) | 0x80);
+ data8Bytes[1] =
+ (byte) ((WireFormat.makeTag(number, WireFormat.WIRETYPE_LENGTH_DELIMITED) >>> 7) & 0x7F);
+ assertInvalidWireFormat(TestPackedTypes.getDefaultInstance(), data8Bytes);
+ }
+ }
+
+ public void testParseVarintMinMax() throws Exception {
+ TestAllTypes message =
+ TestAllTypes.newBuilder()
+ .setOptionalInt32(Integer.MIN_VALUE)
+ .addRepeatedInt32(Integer.MAX_VALUE)
+ .setOptionalInt64(Long.MIN_VALUE)
+ .addRepeatedInt64(Long.MAX_VALUE)
+ .build();
+ TestAllTypes parsed = TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals(Integer.MIN_VALUE, parsed.getOptionalInt32());
+ assertEquals(Integer.MAX_VALUE, parsed.getRepeatedInt32(0));
+ assertEquals(Long.MIN_VALUE, parsed.getOptionalInt64());
+ assertEquals(Long.MAX_VALUE, parsed.getRepeatedInt64(0));
+ }
+
+ public void testParseAllVarintBits() throws Exception {
+ for (int i = 0; i < 32; i++) {
+ final int value = 1 << i;
+ TestAllTypes message = TestAllTypes.newBuilder().setOptionalInt32(value).build();
+ TestAllTypes parsed = TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals(value, parsed.getOptionalInt32());
+ }
+ for (int i = 0; i < 64; i++) {
+ final long value = 1L << i;
+ TestAllTypes message = TestAllTypes.newBuilder().setOptionalInt64(value).build();
+ TestAllTypes parsed = TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals(value, parsed.getOptionalInt64());
+ }
+ }
+
+ public void testParseEmptyUnknownLengthDelimitedField() throws Exception {
+ byte[] data =
+ new byte[] {(byte) WireFormat.makeTag(1, WireFormat.WIRETYPE_LENGTH_DELIMITED), 0};
+ TestAllTypes parsed = TestAllTypes.parseFrom(data);
+ assertTrue(Arrays.equals(data, parsed.toByteArray()));
+ }
+
+ public void testParseEmptyString() throws Exception {
+ TestAllTypes message = TestAllTypes.newBuilder().setOptionalString("").build();
+ TestAllTypes parsed = TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals("", parsed.getOptionalString());
+ }
+
+ public void testParseEmptyStringProto3() throws Exception {
+ TestAllTypes message = TestAllTypes.newBuilder().setOptionalString("").build();
+ // Note that we are parsing from a proto2 proto to a proto3 proto because empty string field is
+ // not serialized in proto3.
+ UnittestProto3.TestAllTypes parsed =
+ UnittestProto3.TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals("", parsed.getOptionalString());
+ }
+
+ public void testParseEmptyBytes() throws Exception {
+ TestAllTypes message = TestAllTypes.newBuilder().setOptionalBytes(ByteString.EMPTY).build();
+ TestAllTypes parsed = TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals(ByteString.EMPTY, parsed.getOptionalBytes());
+ }
+
+ public void testParseEmptyRepeatedStringField() throws Exception {
+ TestAllTypes message =
+ TestAllTypes.newBuilder()
+ .addRepeatedString("")
+ .addRepeatedString("")
+ .addRepeatedString("0")
+ .build();
+ TestAllTypes parsed = TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals(3, parsed.getRepeatedStringCount());
+ assertEquals("", parsed.getRepeatedString(0));
+ assertEquals("", parsed.getRepeatedString(1));
+ assertEquals("0", parsed.getRepeatedString(2));
+ }
+
+ public void testParseEmptyRepeatedStringFieldProto3() throws Exception {
+ TestAllTypes message =
+ TestAllTypes.newBuilder()
+ .addRepeatedString("")
+ .addRepeatedString("")
+ .addRepeatedString("0")
+ .addRepeatedBytes(ByteString.EMPTY)
+ .build();
+ UnittestProto3.TestAllTypes parsed =
+ UnittestProto3.TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals(3, parsed.getRepeatedStringCount());
+ assertEquals("", parsed.getRepeatedString(0));
+ assertEquals("", parsed.getRepeatedString(1));
+ assertEquals("0", parsed.getRepeatedString(2));
+ }
+
+ public void testParseEmptyRepeatedBytesField() throws Exception {
+ ByteString oneByte = ByteString.copyFrom(new byte[] {1});
+ TestAllTypes message =
+ TestAllTypes.newBuilder()
+ .addRepeatedBytes(ByteString.EMPTY)
+ .addRepeatedBytes(ByteString.EMPTY)
+ .addRepeatedBytes(oneByte)
+ .build();
+ TestAllTypes parsed = TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals(3, parsed.getRepeatedBytesCount());
+ assertEquals(ByteString.EMPTY, parsed.getRepeatedBytes(0));
+ assertEquals(ByteString.EMPTY, parsed.getRepeatedBytes(1));
+ assertEquals(oneByte, parsed.getRepeatedBytes(2));
+ }
+
+ public void testSkipUnknownFieldInMessageSetItem() throws Exception {
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ // MessageSet item's start tag.
+ output.write((byte) WireFormat.MESSAGE_SET_ITEM_TAG);
+ // Put all field types into the item.
+ TestUtil.getAllSet().writeTo(output);
+ // Closing the item with the real payload and closing tag.
+ output.write(
+ new byte[] {
+ (byte) WireFormat.MESSAGE_SET_TYPE_ID_TAG,
+ 100, // TYPE_ID = 100
+ (byte) WireFormat.MESSAGE_SET_MESSAGE_TAG,
+ 0, // empty payload
+ (byte) WireFormat.MESSAGE_SET_ITEM_END_TAG,
+ });
+ byte[] data = output.toByteArray();
+ TestMessageSet parsed = TestMessageSet.parseFrom(data);
+
+ // Convert to RawMessageSet for inspection.
+ RawMessageSet raw = RawMessageSet.parseFrom(parsed.toByteArray());
+ assertEquals(1, raw.getItemCount());
+ assertEquals(100, raw.getItem(0).getTypeId());
+ assertEquals(0, raw.getItem(0).getMessage().size());
+ }
+
+ public void testProto2UnknownEnumValuesInOptionalField() throws Exception {
+ // Proto2 doesn't allow setting unknown enum values so we use proto3 to build a message with
+ // unknown enum values
+ UnittestProto3.TestAllTypes message =
+ UnittestProto3.TestAllTypes.newBuilder().setOptionalNestedEnumValue(4321).build();
+ TestAllTypes parsed = TestAllTypes.parseFrom(message.toByteArray());
+ assertFalse(parsed.hasOptionalNestedEnum());
+ // Make sure unknown enum values are preserved.
+ UnittestProto3.TestAllTypes actual =
+ UnittestProto3.TestAllTypes.parseFrom(parsed.toByteArray());
+ assertEquals(4321, actual.getOptionalNestedEnumValue());
+ }
+
+ public void testProto2UnknownEnumValuesInRepeatedField() throws Exception {
+ // Proto2 doesn't allow setting unknown enum values so we use proto3 to build a message with
+ // unknown enum values
+ UnittestProto3.TestAllTypes message =
+ UnittestProto3.TestAllTypes.newBuilder().addRepeatedNestedEnumValue(5432).build();
+ TestAllTypes parsed = TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals(0, parsed.getRepeatedNestedEnumCount());
+ // Make sure unknown enum values are preserved.
+ UnittestProto3.TestAllTypes actual =
+ UnittestProto3.TestAllTypes.parseFrom(parsed.toByteArray());
+ assertEquals(1, actual.getRepeatedNestedEnumCount());
+ assertEquals(5432, actual.getRepeatedNestedEnumValue(0));
+ }
+
+ public void testProto2UnknownEnumValuesInMapField() throws Exception {
+ // Proto2 doesn't allow setting unknown enum values so we use proto3 to build a message with
+ // unknown enum values
+ TestMap message = TestMap.newBuilder().putInt32ToEnumFieldValue(1, 4321).build();
+ MapForProto2TestProto.TestMap parsed =
+ MapForProto2TestProto.TestMap.parseFrom(message.toByteArray());
+ assertEquals(0, parsed.getInt32ToEnumFieldMap().size());
+ // Make sure unknown enum values are preserved.
+ TestMap actual = TestMap.parseFrom(parsed.toByteArray());
+ assertEquals(1, actual.getInt32ToEnumFieldMap().size());
+ assertEquals(4321, actual.getInt32ToEnumFieldValueOrThrow(1));
+ }
+
+ public void testProto2UnknownEnumValuesInOneof() throws Exception {
+ // Proto2 doesn't allow setting unknown enum values so we use proto3 to build a message with
+ // unknown enum values
+ UnittestProto3.TestOneof2 message =
+ UnittestProto3.TestOneof2.newBuilder().setFooEnumValue(1234).build();
+ TestOneof2 parsed = TestOneof2.parseFrom(message.toByteArray());
+ assertFalse(parsed.hasFooEnum());
+ // Make sure unknown enum values are preserved.
+ UnittestProto3.TestOneof2 actual = UnittestProto3.TestOneof2.parseFrom(parsed.toByteArray());
+ assertEquals(1234, actual.getFooEnumValue());
+ }
+
+ public void testProto2UnknownEnumValuesInExtension() throws Exception {
+ ExtensionRegistryLite extensionRegistry = TestUtilLite.getExtensionRegistryLite();
+ // Raw bytes for "[.optional_foreign_enum_extension_lite]: 10"
+ final byte[] rawBytes = new byte[]{-80, 1, 10};
+ TestAllExtensionsLite testAllExtensionsLite =
+ TestAllExtensionsLite.parseFrom(rawBytes, extensionRegistry);
+ assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO,
+ testAllExtensionsLite.getExtension(optionalForeignEnumExtensionLite));
+ final byte[] resultRawBytes = testAllExtensionsLite.toByteArray();
+ assertEquals(rawBytes.length, resultRawBytes.length);
+ for (int i = 0; i < rawBytes.length; i++) {
+ assertEquals(rawBytes[i], resultRawBytes[i]);
+ }
+ }
+
+ public void testProto3UnknownEnumValuesInOptionalField() throws Exception {
+ UnittestProto3.TestAllTypes message =
+ UnittestProto3.TestAllTypes.newBuilder().setOptionalNestedEnumValue(4321).build();
+ UnittestProto3.TestAllTypes parsed =
+ UnittestProto3.TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals(4321, parsed.getOptionalNestedEnumValue());
+ }
+
+ public void testProto3UnknownEnumValuesInRepeatedField() throws Exception {
+ UnittestProto3.TestAllTypes message =
+ UnittestProto3.TestAllTypes.newBuilder().addRepeatedNestedEnumValue(5432).build();
+ UnittestProto3.TestAllTypes parsed =
+ UnittestProto3.TestAllTypes.parseFrom(message.toByteArray());
+ assertEquals(1, parsed.getRepeatedNestedEnumCount());
+ assertEquals(5432, parsed.getRepeatedNestedEnumValue(0));
+ }
+
+ public void testProto3UnknownEnumValuesInMapField() throws Exception {
+ TestMap message = TestMap.newBuilder().putInt32ToEnumFieldValue(1, 4321).build();
+ TestMap parsed = TestMap.parseFrom(message.toByteArray());
+ assertEquals(1, parsed.getInt32ToEnumFieldMap().size());
+ assertEquals(4321, parsed.getInt32ToEnumFieldValueOrThrow(1));
+ }
+
+ public void testProto3UnknownEnumValuesInOneof() throws Exception {
+ UnittestProto3.TestOneof2 message =
+ UnittestProto3.TestOneof2.newBuilder().setFooEnumValue(1234).build();
+ UnittestProto3.TestOneof2 parsed = UnittestProto3.TestOneof2.parseFrom(message.toByteArray());
+ assertEquals(1234, parsed.getFooEnumValue());
+ }
+
+ public void testProto3MessageFieldMergeBehavior() throws Exception {
+ UnittestProto3.NestedTestAllTypes message1 =
+ UnittestProto3.NestedTestAllTypes.newBuilder()
+ .setPayload(
+ UnittestProto3.TestAllTypes.newBuilder()
+ .setOptionalInt32(1234)
+ .setOptionalInt64(5678))
+ .build();
+ UnittestProto3.NestedTestAllTypes message2 =
+ UnittestProto3.NestedTestAllTypes.newBuilder()
+ .setPayload(
+ UnittestProto3.TestAllTypes.newBuilder()
+ .setOptionalInt32(4321)
+ .setOptionalUint32(8765))
+ .build();
+
+ UnittestProto3.NestedTestAllTypes merged =
+ UnittestProto3.NestedTestAllTypes.newBuilder()
+ .mergeFrom(message1.toByteArray())
+ .mergeFrom(message2.toByteArray())
+ .build();
+ // Field values coming later in the stream override earlier values.
+ assertEquals(4321, merged.getPayload().getOptionalInt32());
+ // Field values present in either message should be present in the merged result.
+ assertEquals(5678, merged.getPayload().getOptionalInt64());
+ assertEquals(8765, merged.getPayload().getOptionalUint32());
+ }
+
+ public void testMergeFromPartialByteArray() throws Exception {
+ byte[] data = TestUtil.getAllSet().toByteArray();
+ byte[] dataWithPaddings = new byte[data.length + 2];
+ System.arraycopy(data, 0, dataWithPaddings, 1, data.length);
+ // Parsing will fail if the builder (or parser) interprets offset or length incorrectly.
+ TestAllTypes.newBuilder().mergeFrom(dataWithPaddings, 1, data.length);
+ TestAllTypes.parser().parseFrom(dataWithPaddings, 1, data.length);
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/WrappersLiteOfMethodTest.java b/java/core/src/test/java/com/google/protobuf/WrappersLiteOfMethodTest.java
new file mode 100755
index 0000000..4a3c764
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/WrappersLiteOfMethodTest.java
@@ -0,0 +1,61 @@
+// 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.wrapperstest.WrappersTestProto.TopLevelMessage;
+import junit.framework.TestCase;
+
+public class WrappersLiteOfMethodTest extends TestCase {
+
+ public void testOf() throws Exception {
+ TopLevelMessage.Builder builder = TopLevelMessage.newBuilder();
+ builder.setFieldDouble(DoubleValue.of(2.333));
+ builder.setFieldFloat(FloatValue.of(2.333f));
+ builder.setFieldInt32(Int32Value.of(2333));
+ builder.setFieldInt64(Int64Value.of(23333333333333L));
+ builder.setFieldUint32(UInt32Value.of(2333));
+ builder.setFieldUint64(UInt64Value.of(23333333333333L));
+ builder.setFieldBool(BoolValue.of(true));
+ builder.setFieldString(StringValue.of("23333"));
+ builder.setFieldBytes(BytesValue.of(ByteString.wrap("233".getBytes(Internal.UTF_8))));
+
+ TopLevelMessage message = builder.build();
+ assertTrue(2.333 == message.getFieldDouble().getValue());
+ assertTrue(2.333f == message.getFieldFloat().getValue());
+ assertTrue(2333 == message.getFieldInt32().getValue());
+ assertTrue(23333333333333L == message.getFieldInt64().getValue());
+ assertTrue(2333 == message.getFieldUint32().getValue());
+ assertTrue(23333333333333L == message.getFieldUint64().getValue());
+ assertTrue(true == message.getFieldBool().getValue());
+ assertTrue(message.getFieldString().getValue().equals("23333"));
+ assertTrue(message.getFieldBytes().getValue().toStringUtf8().equals("233"));
+ }
+}
diff --git a/java/core/src/test/java/com/google/protobuf/WrappersOfMethodTest.java b/java/core/src/test/java/com/google/protobuf/WrappersOfMethodTest.java
new file mode 100755
index 0000000..f0d662d
--- /dev/null
+++ b/java/core/src/test/java/com/google/protobuf/WrappersOfMethodTest.java
@@ -0,0 +1,61 @@
+// 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.wrapperstest.WrappersTestProto.TopLevelMessage;
+import junit.framework.TestCase;
+
+public class WrappersOfMethodTest extends TestCase {
+
+ public void testOf() throws Exception {
+ TopLevelMessage.Builder builder = TopLevelMessage.newBuilder();
+ builder.setFieldDouble(DoubleValue.of(2.333));
+ builder.setFieldFloat(FloatValue.of(2.333f));
+ builder.setFieldInt32(Int32Value.of(2333));
+ builder.setFieldInt64(Int64Value.of(23333333333333L));
+ builder.setFieldUint32(UInt32Value.of(2333));
+ builder.setFieldUint64(UInt64Value.of(23333333333333L));
+ builder.setFieldBool(BoolValue.of(true));
+ builder.setFieldString(StringValue.of("23333"));
+ builder.setFieldBytes(BytesValue.of(ByteString.wrap("233".getBytes(Internal.UTF_8))));
+
+ TopLevelMessage message = builder.build();
+ assertTrue(2.333 == message.getFieldDouble().getValue());
+ assertTrue(2.333f == message.getFieldFloat().getValue());
+ assertTrue(2333 == message.getFieldInt32().getValue());
+ assertTrue(23333333333333L == message.getFieldInt64().getValue());
+ assertTrue(2333 == message.getFieldUint32().getValue());
+ assertTrue(23333333333333L == message.getFieldUint64().getValue());
+ assertTrue(true == message.getFieldBool().getValue());
+ assertTrue(message.getFieldString().getValue().equals("23333"));
+ assertTrue(message.getFieldBytes().getValue().toStringUtf8().equals("233"));
+ }
+}
diff --git a/java/core/src/test/proto/com/google/protobuf/cached_field_size_test.proto b/java/core/src/test/proto/com/google/protobuf/cached_field_size_test.proto
new file mode 100755
index 0000000..ce78b34
--- /dev/null
+++ b/java/core/src/test/proto/com/google/protobuf/cached_field_size_test.proto
@@ -0,0 +1,45 @@
+// 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.
+
+// A regression test for b/74087933
+syntax = "proto2";
+
+package protobuf_unittest;
+
+option optimize_for = CODE_SIZE;
+option java_multiple_files = true;
+
+import "google/protobuf/unittest.proto";
+import "google/protobuf/unittest_proto3.proto";
+
+message TestCachedFieldSizeMessage {
+ optional protobuf_unittest.TestPackedTypes proto2_child = 1;
+ optional proto3_unittest.TestPackedTypes proto3_child = 2;
+}
diff --git a/java/core/src/test/proto/com/google/protobuf/message_lite_extension_util_test.proto b/java/core/src/test/proto/com/google/protobuf/message_lite_extension_util_test.proto
new file mode 100755
index 0000000..f985ab0
--- /dev/null
+++ b/java/core/src/test/proto/com/google/protobuf/message_lite_extension_util_test.proto
@@ -0,0 +1,47 @@
+// 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.
+
+// Proto definitions used to test MessageLiteExtensionUtil
+syntax = "proto2";
+
+package protobuf_unittest;
+
+option java_outer_classname = "MessageLiteExtensionTestProtos";
+
+message Car {
+ optional string make = 1;
+ extensions 1000 to max;
+}
+
+extend Car {
+ optional bool turbo = 1001;
+ optional bool self_driving = 1002;
+ optional string plate = 9999;
+}
diff --git a/java/core/src/test/proto/com/google/protobuf/nested_extension.proto b/java/core/src/test/proto/com/google/protobuf/nested_extension.proto
index 037040b..2da6d08 100644
--- a/java/core/src/test/proto/com/google/protobuf/nested_extension.proto
+++ b/java/core/src/test/proto/com/google/protobuf/nested_extension.proto
@@ -35,10 +35,10 @@
syntax = "proto2";
-import "com/google/protobuf/non_nested_extension.proto";
-
package protobuf_unittest;
+import "com/google/protobuf/non_nested_extension.proto";
+
message MyNestedExtension {
extend MessageToBeExtended {
diff --git a/java/core/src/test/proto/com/google/protobuf/nested_extension_lite.proto b/java/core/src/test/proto/com/google/protobuf/nested_extension_lite.proto
index 40d0f19..024097c 100644
--- a/java/core/src/test/proto/com/google/protobuf/nested_extension_lite.proto
+++ b/java/core/src/test/proto/com/google/protobuf/nested_extension_lite.proto
@@ -38,10 +38,10 @@
package protobuf_unittest;
-option optimize_for = LITE_RUNTIME;
-
import "com/google/protobuf/non_nested_extension_lite.proto";
+option optimize_for = LITE_RUNTIME;
+
message MyNestedExtensionLite {
extend MessageLiteToBeExtended {
optional MessageLiteToBeExtended recursiveExtensionLite = 3;
diff --git a/java/core/src/test/proto/com/google/protobuf/packed_field_test.proto b/java/core/src/test/proto/com/google/protobuf/packed_field_test.proto
new file mode 100755
index 0000000..7935322
--- /dev/null
+++ b/java/core/src/test/proto/com/google/protobuf/packed_field_test.proto
@@ -0,0 +1,76 @@
+// 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.
+
+syntax = "proto3";
+
+package packed_field_test;
+
+option java_package = "com.google.protobuf";
+option java_outer_classname = "PackedFieldTestProto";
+
+message TestAllTypes {
+ enum NestedEnum {
+ FOO = 0;
+ BAR = 1;
+ BAZ = 2;
+ }
+
+ repeated int32 repeated_int32 = 31;
+ repeated int64 repeated_int64 = 32;
+ repeated uint32 repeated_uint32 = 33;
+ repeated uint64 repeated_uint64 = 34;
+ repeated sint32 repeated_sint32 = 35;
+ repeated sint64 repeated_sint64 = 36;
+ repeated fixed32 repeated_fixed32 = 37;
+ repeated fixed64 repeated_fixed64 = 38;
+ repeated sfixed32 repeated_sfixed32 = 39;
+ repeated sfixed64 repeated_sfixed64 = 40;
+ repeated float repeated_float = 41;
+ repeated double repeated_double = 42;
+ repeated bool repeated_bool = 43;
+ repeated NestedEnum repeated_nested_enum = 51;
+}
+
+message TestUnpackedTypes {
+ repeated int32 repeated_int32 = 1 [packed = false];
+ repeated int64 repeated_int64 = 2 [packed = false];
+ repeated uint32 repeated_uint32 = 3 [packed = false];
+ repeated uint64 repeated_uint64 = 4 [packed = false];
+ repeated sint32 repeated_sint32 = 5 [packed = false];
+ repeated sint64 repeated_sint64 = 6 [packed = false];
+ repeated fixed32 repeated_fixed32 = 7 [packed = false];
+ repeated fixed64 repeated_fixed64 = 8 [packed = false];
+ repeated sfixed32 repeated_sfixed32 = 9 [packed = false];
+ repeated sfixed64 repeated_sfixed64 = 10 [packed = false];
+ repeated float repeated_float = 11 [packed = false];
+ repeated double repeated_double = 12 [packed = false];
+ repeated bool repeated_bool = 13 [packed = false];
+ repeated TestAllTypes.NestedEnum repeated_nested_enum = 14 [packed = false];
+}
diff --git a/java/core/src/test/proto/com/google/protobuf/proto2_message.proto b/java/core/src/test/proto/com/google/protobuf/proto2_message.proto
new file mode 100755
index 0000000..005a911
--- /dev/null
+++ b/java/core/src/test/proto/com/google/protobuf/proto2_message.proto
@@ -0,0 +1,429 @@
+// 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.
+
+// LINT: ALLOW_GROUPS
+syntax = "proto2";
+
+option java_package = "com.google.protobuf.testing";
+option java_outer_classname = "Proto2Testing";
+package protobuf.experimental;
+
+
+message Proto2SpecialFieldName {
+ optional double regular_name = 1;
+ optional int32 cached_size = 2;
+ optional int64 serialized_size = 3;
+ optional string class = 4;
+}
+
+message Proto2Message {
+
+ enum TestEnum {
+ ZERO = 0;
+ ONE = 1;
+ TWO = 2;
+ }
+
+ optional double field_double_1 = 1;
+ optional float field_float_2 = 2;
+ optional int64 field_int64_3 = 3;
+ optional uint64 field_uint64_4 = 4;
+ optional int32 field_int32_5 = 5;
+ optional fixed64 field_fixed64_6 = 6;
+ optional fixed32 field_fixed32_7 = 7;
+ optional bool field_bool_8 = 8;
+ optional string field_string_9 = 9;
+ optional Proto2Message field_message_10 = 10;
+ optional bytes field_bytes_11 = 11;
+ optional uint32 field_uint32_12 = 12;
+ optional TestEnum field_enum_13 = 13;
+ optional sfixed32 field_sfixed32_14 = 14;
+ optional sfixed64 field_sfixed64_15 = 15;
+ optional sint32 field_sint32_16 = 16;
+ optional sint64 field_sint64_17 = 17;
+ repeated double field_double_list_18 = 18 [packed = false];
+ repeated float field_float_list_19 = 19 [packed = false];
+ repeated int64 field_int64_list_20 = 20 [packed = false];
+ repeated uint64 field_uint64_list_21 = 21 [packed = false];
+ repeated int32 field_int32_list_22 = 22 [packed = false];
+ repeated fixed64 field_fixed64_list_23 = 23 [packed = false];
+ repeated fixed32 field_fixed32_list_24 = 24 [packed = false];
+ repeated bool field_bool_list_25 = 25 [packed = false];
+ repeated string field_string_list_26 = 26 [packed = false];
+ repeated Proto2Message field_message_list_27 = 27 [packed = false];
+ repeated bytes field_bytes_list_28 = 28 [packed = false];
+ repeated uint32 field_uint32_list_29 = 29 [packed = false];
+ repeated TestEnum field_enum_list_30 = 30 [packed = false];
+ repeated sfixed32 field_sfixed32_list_31 = 31 [packed = false];
+ repeated sfixed64 field_sfixed64_list_32 = 32 [packed = false];
+ repeated sint32 field_sint32_list_33 = 33 [packed = false];
+ repeated sint64 field_sint64_list_34 = 34 [packed = false];
+ repeated double field_double_list_packed_35 = 35 [packed = true];
+ repeated float field_float_list_packed_36 = 36 [packed = true];
+ repeated int64 field_int64_list_packed_37 = 37 [packed = true];
+ repeated uint64 field_uint64_list_packed_38 = 38 [packed = true];
+ repeated int32 field_int32_list_packed_39 = 39 [packed = true];
+ repeated fixed64 field_fixed64_list_packed_40 = 40 [packed = true];
+ repeated fixed32 field_fixed32_list_packed_41 = 41 [packed = true];
+ repeated bool field_bool_list_packed_42 = 42 [packed = true];
+ repeated uint32 field_uint32_list_packed_43 = 43 [packed = true];
+ repeated TestEnum field_enum_list_packed_44 = 44 [packed = true];
+ repeated sfixed32 field_sfixed32_list_packed_45 = 45 [packed = true];
+ repeated sfixed64 field_sfixed64_list_packed_46 = 46 [packed = true];
+ repeated sint32 field_sint32_list_packed_47 = 47 [packed = true];
+ repeated sint64 field_sint64_list_packed_48 = 48 [packed = true];
+ optional group FieldGroup49 = 49 {
+ optional int32 field_int32_50 = 50;
+ }
+ repeated group FieldGroupList51 = 51 {
+ optional int32 field_int32_52 = 52;
+ }
+ oneof test_oneof {
+ double field_double_53 = 53;
+ float field_float_54 = 54;
+ int64 field_int64_55 = 55;
+ uint64 field_uint64_56 = 56;
+ int32 field_int32_57 = 57;
+ fixed64 field_fixed64_58 = 58;
+ fixed32 field_fixed32_59 = 59;
+ bool field_bool_60 = 60;
+ string field_string_61 = 61;
+ Proto2Message field_message_62 = 62;
+ bytes field_bytes_63 = 63;
+ uint32 field_uint32_64 = 64;
+ sfixed32 field_sfixed32_65 = 65;
+ sfixed64 field_sfixed64_66 = 66;
+ sint32 field_sint32_67 = 67;
+ sint64 field_sint64_68 = 68;
+ group FieldGroup69 = 69 {
+ optional int32 field_int32_70 = 70;
+ }
+ }
+
+ message RequiredNestedMessage {
+ optional int32 value = 1;
+ }
+
+ required double field_required_double_71 = 71;
+ required float field_required_float_72 = 72;
+ required int64 field_required_int64_73 = 73;
+ required uint64 field_required_uint64_74 = 74;
+ required int32 field_required_int32_75 = 75;
+ required fixed64 field_required_fixed64_76 = 76;
+ required fixed32 field_required_fixed32_77 = 77;
+ required bool field_required_bool_78 = 78;
+ required string field_required_string_79 = 79;
+ required RequiredNestedMessage field_required_message_80 = 80;
+ required bytes field_required_bytes_81 = 81;
+ required uint32 field_required_uint32_82 = 82;
+ required TestEnum field_required_enum_83 = 83;
+ required sfixed32 field_required_sfixed32_84 = 84;
+ required sfixed64 field_required_sfixed64_85 = 85;
+ required sint32 field_required_sint32_86 = 86;
+ required sint64 field_required_sint64_87 = 87;
+ required group FieldRequiredGroup88 = 88 {
+ optional int32 field_int32_89 = 89;
+ }
+}
+
+message Proto2Empty {}
+
+message Proto2MessageWithExtensions {
+ extensions 1 to 10000;
+}
+
+extend Proto2MessageWithExtensions {
+ optional double field_double_1 = 1;
+ optional float field_float_2 = 2;
+ optional int64 field_int64_3 = 3;
+ optional uint64 field_uint64_4 = 4;
+ optional int32 field_int32_5 = 5;
+ optional fixed64 field_fixed64_6 = 6;
+ optional fixed32 field_fixed32_7 = 7;
+ optional bool field_bool_8 = 8;
+ optional string field_string_9 = 9;
+ optional Proto2Message field_message_10 = 10;
+ optional bytes field_bytes_11 = 11;
+ optional uint32 field_uint32_12 = 12;
+ optional Proto2Message.TestEnum field_enum_13 = 13;
+ optional sfixed32 field_sfixed32_14 = 14;
+ optional sfixed64 field_sfixed64_15 = 15;
+ optional sint32 field_sint32_16 = 16;
+ optional sint64 field_sint64_17 = 17;
+
+ repeated double field_double_list_18 = 18 [packed = false];
+ repeated float field_float_list_19 = 19 [packed = false];
+ repeated int64 field_int64_list_20 = 20 [packed = false];
+ repeated uint64 field_uint64_list_21 = 21 [packed = false];
+ repeated int32 field_int32_list_22 = 22 [packed = false];
+ repeated fixed64 field_fixed64_list_23 = 23 [packed = false];
+ repeated fixed32 field_fixed32_list_24 = 24 [packed = false];
+ repeated bool field_bool_list_25 = 25 [packed = false];
+ repeated string field_string_list_26 = 26 [packed = false];
+ repeated Proto2Message field_message_list_27 = 27 [packed = false];
+ repeated bytes field_bytes_list_28 = 28 [packed = false];
+ repeated uint32 field_uint32_list_29 = 29 [packed = false];
+ repeated Proto2Message.TestEnum field_enum_list_30 = 30 [packed = false];
+ repeated sfixed32 field_sfixed32_list_31 = 31 [packed = false];
+ repeated sfixed64 field_sfixed64_list_32 = 32 [packed = false];
+ repeated sint32 field_sint32_list_33 = 33 [packed = false];
+ repeated sint64 field_sint64_list_34 = 34 [packed = false];
+
+ repeated double field_double_list_packed_35 = 35 [packed = true];
+ repeated float field_float_list_packed_36 = 36 [packed = true];
+ repeated int64 field_int64_list_packed_37 = 37 [packed = true];
+ repeated uint64 field_uint64_list_packed_38 = 38 [packed = true];
+ repeated int32 field_int32_list_packed_39 = 39 [packed = true];
+ repeated fixed64 field_fixed64_list_packed_40 = 40 [packed = true];
+ repeated fixed32 field_fixed32_list_packed_41 = 41 [packed = true];
+ repeated bool field_bool_list_packed_42 = 42 [packed = true];
+ repeated uint32 field_uint32_list_packed_43 = 43 [packed = true];
+ repeated Proto2Message.TestEnum field_enum_list_packed_44 = 44
+ [packed = true];
+ repeated sfixed32 field_sfixed32_list_packed_45 = 45 [packed = true];
+ repeated sfixed64 field_sfixed64_list_packed_46 = 46 [packed = true];
+ repeated sint32 field_sint32_list_packed_47 = 47 [packed = true];
+ repeated sint64 field_sint64_list_packed_48 = 48 [packed = true];
+
+ optional group FieldGroup49 = 49 {
+ optional int32 field_int32_50 = 50;
+ }
+
+ repeated group FieldGroupList51 = 51 {
+ optional int32 field_int32_52 = 52;
+ }
+}
+
+message Proto2MessageWithMaps {
+ map<bool, bool> field_map_bool_bool_1 = 1;
+ map<bool, bytes> field_map_bool_bytes_2 = 2;
+ map<bool, double> field_map_bool_double_3 = 3;
+ map<bool, Proto2Message.TestEnum> field_map_bool_enum_4 = 4;
+ map<bool, fixed32> field_map_bool_fixed32_5 = 5;
+ map<bool, fixed64> field_map_bool_fixed64_6 = 6;
+ map<bool, float> field_map_bool_float_7 = 7;
+ map<bool, int32> field_map_bool_int32_8 = 8;
+ map<bool, int64> field_map_bool_int64_9 = 9;
+ map<bool, Proto2Message> field_map_bool_message_10 = 10;
+ map<bool, sfixed32> field_map_bool_sfixed32_11 = 11;
+ map<bool, sfixed64> field_map_bool_sfixed64_12 = 12;
+ map<bool, sint32> field_map_bool_sint32_13 = 13;
+ map<bool, sint64> field_map_bool_sint64_14 = 14;
+ map<bool, string> field_map_bool_string_15 = 15;
+ map<bool, uint32> field_map_bool_uint32_16 = 16;
+ map<bool, uint64> field_map_bool_uint64_17 = 17;
+ map<fixed32, bool> field_map_fixed32_bool_18 = 18;
+ map<fixed32, bytes> field_map_fixed32_bytes_19 = 19;
+ map<fixed32, double> field_map_fixed32_double_20 = 20;
+ map<fixed32, Proto2Message.TestEnum> field_map_fixed32_enum_21 = 21;
+ map<fixed32, fixed32> field_map_fixed32_fixed32_22 = 22;
+ map<fixed32, fixed64> field_map_fixed32_fixed64_23 = 23;
+ map<fixed32, float> field_map_fixed32_float_24 = 24;
+ map<fixed32, int32> field_map_fixed32_int32_25 = 25;
+ map<fixed32, int64> field_map_fixed32_int64_26 = 26;
+ map<fixed32, Proto2Message> field_map_fixed32_message_27 = 27;
+ map<fixed32, sfixed32> field_map_fixed32_sfixed32_28 = 28;
+ map<fixed32, sfixed64> field_map_fixed32_sfixed64_29 = 29;
+ map<fixed32, sint32> field_map_fixed32_sint32_30 = 30;
+ map<fixed32, sint64> field_map_fixed32_sint64_31 = 31;
+ map<fixed32, string> field_map_fixed32_string_32 = 32;
+ map<fixed32, uint32> field_map_fixed32_uint32_33 = 33;
+ map<fixed32, uint64> field_map_fixed32_uint64_34 = 34;
+ map<fixed64, bool> field_map_fixed64_bool_35 = 35;
+ map<fixed64, bytes> field_map_fixed64_bytes_36 = 36;
+ map<fixed64, double> field_map_fixed64_double_37 = 37;
+ map<fixed64, Proto2Message.TestEnum> field_map_fixed64_enum_38 = 38;
+ map<fixed64, fixed32> field_map_fixed64_fixed32_39 = 39;
+ map<fixed64, fixed64> field_map_fixed64_fixed64_40 = 40;
+ map<fixed64, float> field_map_fixed64_float_41 = 41;
+ map<fixed64, int32> field_map_fixed64_int32_42 = 42;
+ map<fixed64, int64> field_map_fixed64_int64_43 = 43;
+ map<fixed64, Proto2Message> field_map_fixed64_message_44 = 44;
+ map<fixed64, sfixed32> field_map_fixed64_sfixed32_45 = 45;
+ map<fixed64, sfixed64> field_map_fixed64_sfixed64_46 = 46;
+ map<fixed64, sint32> field_map_fixed64_sint32_47 = 47;
+ map<fixed64, sint64> field_map_fixed64_sint64_48 = 48;
+ map<fixed64, string> field_map_fixed64_string_49 = 49;
+ map<fixed64, uint32> field_map_fixed64_uint32_50 = 50;
+ map<fixed64, uint64> field_map_fixed64_uint64_51 = 51;
+ map<int32, bool> field_map_int32_bool_52 = 52;
+ map<int32, bytes> field_map_int32_bytes_53 = 53;
+ map<int32, double> field_map_int32_double_54 = 54;
+ map<int32, Proto2Message.TestEnum> field_map_int32_enum_55 = 55;
+ map<int32, fixed32> field_map_int32_fixed32_56 = 56;
+ map<int32, fixed64> field_map_int32_fixed64_57 = 57;
+ map<int32, float> field_map_int32_float_58 = 58;
+ map<int32, int32> field_map_int32_int32_59 = 59;
+ map<int32, int64> field_map_int32_int64_60 = 60;
+ map<int32, Proto2Message> field_map_int32_message_61 = 61;
+ map<int32, sfixed32> field_map_int32_sfixed32_62 = 62;
+ map<int32, sfixed64> field_map_int32_sfixed64_63 = 63;
+ map<int32, sint32> field_map_int32_sint32_64 = 64;
+ map<int32, sint64> field_map_int32_sint64_65 = 65;
+ map<int32, string> field_map_int32_string_66 = 66;
+ map<int32, uint32> field_map_int32_uint32_67 = 67;
+ map<int32, uint64> field_map_int32_uint64_68 = 68;
+ map<int64, bool> field_map_int64_bool_69 = 69;
+ map<int64, bytes> field_map_int64_bytes_70 = 70;
+ map<int64, double> field_map_int64_double_71 = 71;
+ map<int64, Proto2Message.TestEnum> field_map_int64_enum_72 = 72;
+ map<int64, fixed32> field_map_int64_fixed32_73 = 73;
+ map<int64, fixed64> field_map_int64_fixed64_74 = 74;
+ map<int64, float> field_map_int64_float_75 = 75;
+ map<int64, int32> field_map_int64_int32_76 = 76;
+ map<int64, int64> field_map_int64_int64_77 = 77;
+ map<int64, Proto2Message> field_map_int64_message_78 = 78;
+ map<int64, sfixed32> field_map_int64_sfixed32_79 = 79;
+ map<int64, sfixed64> field_map_int64_sfixed64_80 = 80;
+ map<int64, sint32> field_map_int64_sint32_81 = 81;
+ map<int64, sint64> field_map_int64_sint64_82 = 82;
+ map<int64, string> field_map_int64_string_83 = 83;
+ map<int64, uint32> field_map_int64_uint32_84 = 84;
+ map<int64, uint64> field_map_int64_uint64_85 = 85;
+ map<sfixed32, bool> field_map_sfixed32_bool_86 = 86;
+ map<sfixed32, bytes> field_map_sfixed32_bytes_87 = 87;
+ map<sfixed32, double> field_map_sfixed32_double_88 = 88;
+ map<sfixed32, Proto2Message.TestEnum> field_map_sfixed32_enum_89 = 89;
+ map<sfixed32, fixed32> field_map_sfixed32_fixed32_90 = 90;
+ map<sfixed32, fixed64> field_map_sfixed32_fixed64_91 = 91;
+ map<sfixed32, float> field_map_sfixed32_float_92 = 92;
+ map<sfixed32, int32> field_map_sfixed32_int32_93 = 93;
+ map<sfixed32, int64> field_map_sfixed32_int64_94 = 94;
+ map<sfixed32, Proto2Message> field_map_sfixed32_message_95 = 95;
+ map<sfixed32, sfixed32> field_map_sfixed32_sfixed32_96 = 96;
+ map<sfixed32, sfixed64> field_map_sfixed32_sfixed64_97 = 97;
+ map<sfixed32, sint32> field_map_sfixed32_sint32_98 = 98;
+ map<sfixed32, sint64> field_map_sfixed32_sint64_99 = 99;
+ map<sfixed32, string> field_map_sfixed32_string_100 = 100;
+ map<sfixed32, uint32> field_map_sfixed32_uint32_101 = 101;
+ map<sfixed32, uint64> field_map_sfixed32_uint64_102 = 102;
+ map<sfixed64, bool> field_map_sfixed64_bool_103 = 103;
+ map<sfixed64, bytes> field_map_sfixed64_bytes_104 = 104;
+ map<sfixed64, double> field_map_sfixed64_double_105 = 105;
+ map<sfixed64, Proto2Message.TestEnum> field_map_sfixed64_enum_106 = 106;
+ map<sfixed64, fixed32> field_map_sfixed64_fixed32_107 = 107;
+ map<sfixed64, fixed64> field_map_sfixed64_fixed64_108 = 108;
+ map<sfixed64, float> field_map_sfixed64_float_109 = 109;
+ map<sfixed64, int32> field_map_sfixed64_int32_110 = 110;
+ map<sfixed64, int64> field_map_sfixed64_int64_111 = 111;
+ map<sfixed64, Proto2Message> field_map_sfixed64_message_112 = 112;
+ map<sfixed64, sfixed32> field_map_sfixed64_sfixed32_113 = 113;
+ map<sfixed64, sfixed64> field_map_sfixed64_sfixed64_114 = 114;
+ map<sfixed64, sint32> field_map_sfixed64_sint32_115 = 115;
+ map<sfixed64, sint64> field_map_sfixed64_sint64_116 = 116;
+ map<sfixed64, string> field_map_sfixed64_string_117 = 117;
+ map<sfixed64, uint32> field_map_sfixed64_uint32_118 = 118;
+ map<sfixed64, uint64> field_map_sfixed64_uint64_119 = 119;
+ map<sint32, bool> field_map_sint32_bool_120 = 120;
+ map<sint32, bytes> field_map_sint32_bytes_121 = 121;
+ map<sint32, double> field_map_sint32_double_122 = 122;
+ map<sint32, Proto2Message.TestEnum> field_map_sint32_enum_123 = 123;
+ map<sint32, fixed32> field_map_sint32_fixed32_124 = 124;
+ map<sint32, fixed64> field_map_sint32_fixed64_125 = 125;
+ map<sint32, float> field_map_sint32_float_126 = 126;
+ map<sint32, int32> field_map_sint32_int32_127 = 127;
+ map<sint32, int64> field_map_sint32_int64_128 = 128;
+ map<sint32, Proto2Message> field_map_sint32_message_129 = 129;
+ map<sint32, sfixed32> field_map_sint32_sfixed32_130 = 130;
+ map<sint32, sfixed64> field_map_sint32_sfixed64_131 = 131;
+ map<sint32, sint32> field_map_sint32_sint32_132 = 132;
+ map<sint32, sint64> field_map_sint32_sint64_133 = 133;
+ map<sint32, string> field_map_sint32_string_134 = 134;
+ map<sint32, uint32> field_map_sint32_uint32_135 = 135;
+ map<sint32, uint64> field_map_sint32_uint64_136 = 136;
+ map<sint64, bool> field_map_sint64_bool_137 = 137;
+ map<sint64, bytes> field_map_sint64_bytes_138 = 138;
+ map<sint64, double> field_map_sint64_double_139 = 139;
+ map<sint64, Proto2Message.TestEnum> field_map_sint64_enum_140 = 140;
+ map<sint64, fixed32> field_map_sint64_fixed32_141 = 141;
+ map<sint64, fixed64> field_map_sint64_fixed64_142 = 142;
+ map<sint64, float> field_map_sint64_float_143 = 143;
+ map<sint64, int32> field_map_sint64_int32_144 = 144;
+ map<sint64, int64> field_map_sint64_int64_145 = 145;
+ map<sint64, Proto2Message> field_map_sint64_message_146 = 146;
+ map<sint64, sfixed32> field_map_sint64_sfixed32_147 = 147;
+ map<sint64, sfixed64> field_map_sint64_sfixed64_148 = 148;
+ map<sint64, sint32> field_map_sint64_sint32_149 = 149;
+ map<sint64, sint64> field_map_sint64_sint64_150 = 150;
+ map<sint64, string> field_map_sint64_string_151 = 151;
+ map<sint64, uint32> field_map_sint64_uint32_152 = 152;
+ map<sint64, uint64> field_map_sint64_uint64_153 = 153;
+ map<string, bool> field_map_string_bool_154 = 154;
+ map<string, bytes> field_map_string_bytes_155 = 155;
+ map<string, double> field_map_string_double_156 = 156;
+ map<string, Proto2Message.TestEnum> field_map_string_enum_157 = 157;
+ map<string, fixed32> field_map_string_fixed32_158 = 158;
+ map<string, fixed64> field_map_string_fixed64_159 = 159;
+ map<string, float> field_map_string_float_160 = 160;
+ map<string, int32> field_map_string_int32_161 = 161;
+ map<string, int64> field_map_string_int64_162 = 162;
+ map<string, Proto2Message> field_map_string_message_163 = 163;
+ map<string, sfixed32> field_map_string_sfixed32_164 = 164;
+ map<string, sfixed64> field_map_string_sfixed64_165 = 165;
+ map<string, sint32> field_map_string_sint32_166 = 166;
+ map<string, sint64> field_map_string_sint64_167 = 167;
+ map<string, string> field_map_string_string_168 = 168;
+ map<string, uint32> field_map_string_uint32_169 = 169;
+ map<string, uint64> field_map_string_uint64_170 = 170;
+ map<uint32, bool> field_map_uint32_bool_171 = 171;
+ map<uint32, bytes> field_map_uint32_bytes_172 = 172;
+ map<uint32, double> field_map_uint32_double_173 = 173;
+ map<uint32, Proto2Message.TestEnum> field_map_uint32_enum_174 = 174;
+ map<uint32, fixed32> field_map_uint32_fixed32_175 = 175;
+ map<uint32, fixed64> field_map_uint32_fixed64_176 = 176;
+ map<uint32, float> field_map_uint32_float_177 = 177;
+ map<uint32, int32> field_map_uint32_int32_178 = 178;
+ map<uint32, int64> field_map_uint32_int64_179 = 179;
+ map<uint32, Proto2Message> field_map_uint32_message_180 = 180;
+ map<uint32, sfixed32> field_map_uint32_sfixed32_181 = 181;
+ map<uint32, sfixed64> field_map_uint32_sfixed64_182 = 182;
+ map<uint32, sint32> field_map_uint32_sint32_183 = 183;
+ map<uint32, sint64> field_map_uint32_sint64_184 = 184;
+ map<uint32, string> field_map_uint32_string_185 = 185;
+ map<uint32, uint32> field_map_uint32_uint32_186 = 186;
+ map<uint32, uint64> field_map_uint32_uint64_187 = 187;
+ map<uint64, bool> field_map_uint64_bool_188 = 188;
+ map<uint64, bytes> field_map_uint64_bytes_189 = 189;
+ map<uint64, double> field_map_uint64_double_190 = 190;
+ map<uint64, Proto2Message.TestEnum> field_map_uint64_enum_191 = 191;
+ map<uint64, fixed32> field_map_uint64_fixed32_192 = 192;
+ map<uint64, fixed64> field_map_uint64_fixed64_193 = 193;
+ map<uint64, float> field_map_uint64_float_194 = 194;
+ map<uint64, int32> field_map_uint64_int32_195 = 195;
+ map<uint64, int64> field_map_uint64_int64_196 = 196;
+ map<uint64, Proto2Message> field_map_uint64_message_197 = 197;
+ map<uint64, sfixed32> field_map_uint64_sfixed32_198 = 198;
+ map<uint64, sfixed64> field_map_uint64_sfixed64_199 = 199;
+ map<uint64, sint32> field_map_uint64_sint32_200 = 200;
+ map<uint64, sint64> field_map_uint64_sint64_201 = 201;
+ map<uint64, string> field_map_uint64_string_202 = 202;
+ map<uint64, uint32> field_map_uint64_uint32_203 = 203;
+ map<uint64, uint64> field_map_uint64_uint64_204 = 204;
+}
diff --git a/java/core/src/test/proto/com/google/protobuf/proto2_message_lite.proto b/java/core/src/test/proto/com/google/protobuf/proto2_message_lite.proto
new file mode 100755
index 0000000..8385dfd
--- /dev/null
+++ b/java/core/src/test/proto/com/google/protobuf/proto2_message_lite.proto
@@ -0,0 +1,422 @@
+// 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.
+
+// LINT: ALLOW_GROUPS
+syntax = "proto2";
+
+option java_package = "com.google.protobuf.testing";
+option java_outer_classname = "Proto2TestingLite";
+package protobuf.experimental.lite;
+
+
+message Proto2MessageLite {
+
+ enum TestEnum {
+ ZERO = 0;
+ ONE = 1;
+ TWO = 2;
+ }
+
+ optional double field_double_1 = 1;
+ optional float field_float_2 = 2;
+ optional int64 field_int64_3 = 3;
+ optional uint64 field_uint64_4 = 4;
+ optional int32 field_int32_5 = 5;
+ optional fixed64 field_fixed64_6 = 6;
+ optional fixed32 field_fixed32_7 = 7;
+ optional bool field_bool_8 = 8;
+ optional string field_string_9 = 9;
+ optional Proto2MessageLite field_message_10 = 10;
+ optional bytes field_bytes_11 = 11;
+ optional uint32 field_uint32_12 = 12;
+ optional TestEnum field_enum_13 = 13;
+ optional sfixed32 field_sfixed32_14 = 14;
+ optional sfixed64 field_sfixed64_15 = 15;
+ optional sint32 field_sint32_16 = 16;
+ optional sint64 field_sint64_17 = 17;
+ repeated double field_double_list_18 = 18 [packed = false];
+ repeated float field_float_list_19 = 19 [packed = false];
+ repeated int64 field_int64_list_20 = 20 [packed = false];
+ repeated uint64 field_uint64_list_21 = 21 [packed = false];
+ repeated int32 field_int32_list_22 = 22 [packed = false];
+ repeated fixed64 field_fixed64_list_23 = 23 [packed = false];
+ repeated fixed32 field_fixed32_list_24 = 24 [packed = false];
+ repeated bool field_bool_list_25 = 25 [packed = false];
+ repeated string field_string_list_26 = 26 [packed = false];
+ repeated Proto2MessageLite field_message_list_27 = 27 [packed = false];
+ repeated bytes field_bytes_list_28 = 28 [packed = false];
+ repeated uint32 field_uint32_list_29 = 29 [packed = false];
+ repeated TestEnum field_enum_list_30 = 30 [packed = false];
+ repeated sfixed32 field_sfixed32_list_31 = 31 [packed = false];
+ repeated sfixed64 field_sfixed64_list_32 = 32 [packed = false];
+ repeated sint32 field_sint32_list_33 = 33 [packed = false];
+ repeated sint64 field_sint64_list_34 = 34 [packed = false];
+ repeated double field_double_list_packed_35 = 35 [packed = true];
+ repeated float field_float_list_packed_36 = 36 [packed = true];
+ repeated int64 field_int64_list_packed_37 = 37 [packed = true];
+ repeated uint64 field_uint64_list_packed_38 = 38 [packed = true];
+ repeated int32 field_int32_list_packed_39 = 39 [packed = true];
+ repeated fixed64 field_fixed64_list_packed_40 = 40 [packed = true];
+ repeated fixed32 field_fixed32_list_packed_41 = 41 [packed = true];
+ repeated bool field_bool_list_packed_42 = 42 [packed = true];
+ repeated uint32 field_uint32_list_packed_43 = 43 [packed = true];
+ repeated TestEnum field_enum_list_packed_44 = 44 [packed = true];
+ repeated sfixed32 field_sfixed32_list_packed_45 = 45 [packed = true];
+ repeated sfixed64 field_sfixed64_list_packed_46 = 46 [packed = true];
+ repeated sint32 field_sint32_list_packed_47 = 47 [packed = true];
+ repeated sint64 field_sint64_list_packed_48 = 48 [packed = true];
+ optional group FieldGroup49 = 49 {
+ optional int32 field_int32_50 = 50;
+ }
+ repeated group FieldGroupList51 = 51 {
+ optional int32 field_int32_52 = 52;
+ }
+ oneof test_oneof {
+ double field_double_53 = 53;
+ float field_float_54 = 54;
+ int64 field_int64_55 = 55;
+ uint64 field_uint64_56 = 56;
+ int32 field_int32_57 = 57;
+ fixed64 field_fixed64_58 = 58;
+ fixed32 field_fixed32_59 = 59;
+ bool field_bool_60 = 60;
+ string field_string_61 = 61;
+ Proto2MessageLite field_message_62 = 62;
+ bytes field_bytes_63 = 63;
+ uint32 field_uint32_64 = 64;
+ sfixed32 field_sfixed32_65 = 65;
+ sfixed64 field_sfixed64_66 = 66;
+ sint32 field_sint32_67 = 67;
+ sint64 field_sint64_68 = 68;
+ group FieldGroup69 = 69 {
+ optional int32 field_int32_70 = 70;
+ }
+ }
+
+ message RequiredNestedMessage {
+ optional int32 value = 1;
+ }
+
+ required double field_required_double_71 = 71;
+ required float field_required_float_72 = 72;
+ required int64 field_required_int64_73 = 73;
+ required uint64 field_required_uint64_74 = 74;
+ required int32 field_required_int32_75 = 75;
+ required fixed64 field_required_fixed64_76 = 76;
+ required fixed32 field_required_fixed32_77 = 77;
+ required bool field_required_bool_78 = 78;
+ required string field_required_string_79 = 79;
+ required RequiredNestedMessage field_required_message_80 = 80;
+ required bytes field_required_bytes_81 = 81;
+ required uint32 field_required_uint32_82 = 82;
+ required TestEnum field_required_enum_83 = 83;
+ required sfixed32 field_required_sfixed32_84 = 84;
+ required sfixed64 field_required_sfixed64_85 = 85;
+ required sint32 field_required_sint32_86 = 86;
+ required sint64 field_required_sint64_87 = 87;
+ required group FieldRequiredGroup88 = 88 {
+ optional int32 field_int32_89 = 89;
+ }
+}
+
+message Proto2EmptyLite {}
+
+message Proto2MessageLiteWithExtensions {
+ extensions 1 to max;
+}
+
+extend Proto2MessageLiteWithExtensions {
+ optional double field_double_1 = 1;
+ optional float field_float_2 = 2;
+ optional int64 field_int64_3 = 3;
+ optional uint64 field_uint64_4 = 4;
+ optional int32 field_int32_5 = 5;
+ optional fixed64 field_fixed64_6 = 6;
+ optional fixed32 field_fixed32_7 = 7;
+ optional bool field_bool_8 = 8;
+ optional string field_string_9 = 9;
+ optional Proto2MessageLite field_message_10 = 10;
+ optional bytes field_bytes_11 = 11;
+ optional uint32 field_uint32_12 = 12;
+ optional Proto2MessageLite.TestEnum field_enum_13 = 13;
+ optional sfixed32 field_sfixed32_14 = 14;
+ optional sfixed64 field_sfixed64_15 = 15;
+ optional sint32 field_sint32_16 = 16;
+ optional sint64 field_sint64_17 = 17;
+
+ repeated double field_double_list_18 = 18 [packed = false];
+ repeated float field_float_list_19 = 19 [packed = false];
+ repeated int64 field_int64_list_20 = 20 [packed = false];
+ repeated uint64 field_uint64_list_21 = 21 [packed = false];
+ repeated int32 field_int32_list_22 = 22 [packed = false];
+ repeated fixed64 field_fixed64_list_23 = 23 [packed = false];
+ repeated fixed32 field_fixed32_list_24 = 24 [packed = false];
+ repeated bool field_bool_list_25 = 25 [packed = false];
+ repeated string field_string_list_26 = 26 [packed = false];
+ repeated Proto2MessageLite field_message_list_27 = 27 [packed = false];
+ repeated bytes field_bytes_list_28 = 28 [packed = false];
+ repeated uint32 field_uint32_list_29 = 29 [packed = false];
+ repeated Proto2MessageLite.TestEnum field_enum_list_30 = 30 [packed = false];
+ repeated sfixed32 field_sfixed32_list_31 = 31 [packed = false];
+ repeated sfixed64 field_sfixed64_list_32 = 32 [packed = false];
+ repeated sint32 field_sint32_list_33 = 33 [packed = false];
+ repeated sint64 field_sint64_list_34 = 34 [packed = false];
+
+ repeated double field_double_list_packed_35 = 35 [packed = true];
+ repeated float field_float_list_packed_36 = 36 [packed = true];
+ repeated int64 field_int64_list_packed_37 = 37 [packed = true];
+ repeated uint64 field_uint64_list_packed_38 = 38 [packed = true];
+ repeated int32 field_int32_list_packed_39 = 39 [packed = true];
+ repeated fixed64 field_fixed64_list_packed_40 = 40 [packed = true];
+ repeated fixed32 field_fixed32_list_packed_41 = 41 [packed = true];
+ repeated bool field_bool_list_packed_42 = 42 [packed = true];
+ repeated uint32 field_uint32_list_packed_43 = 43 [packed = true];
+ repeated Proto2MessageLite.TestEnum field_enum_list_packed_44 = 44
+ [packed = true];
+ repeated sfixed32 field_sfixed32_list_packed_45 = 45 [packed = true];
+ repeated sfixed64 field_sfixed64_list_packed_46 = 46 [packed = true];
+ repeated sint32 field_sint32_list_packed_47 = 47 [packed = true];
+ repeated sint64 field_sint64_list_packed_48 = 48 [packed = true];
+
+ optional group FieldGroup49 = 49 {
+ optional int32 field_int32_50 = 50;
+ }
+
+ repeated group FieldGroupList51 = 51 {
+ optional int32 field_int32_52 = 52;
+ }
+}
+
+message Proto2MessageLiteWithMaps {
+ map<bool, bool> field_map_bool_bool_1 = 1;
+ map<bool, bytes> field_map_bool_bytes_2 = 2;
+ map<bool, double> field_map_bool_double_3 = 3;
+ map<bool, Proto2MessageLite.TestEnum> field_map_bool_enum_4 = 4;
+ map<bool, fixed32> field_map_bool_fixed32_5 = 5;
+ map<bool, fixed64> field_map_bool_fixed64_6 = 6;
+ map<bool, float> field_map_bool_float_7 = 7;
+ map<bool, int32> field_map_bool_int32_8 = 8;
+ map<bool, int64> field_map_bool_int64_9 = 9;
+ map<bool, Proto2MessageLite> field_map_bool_message_10 = 10;
+ map<bool, sfixed32> field_map_bool_sfixed32_11 = 11;
+ map<bool, sfixed64> field_map_bool_sfixed64_12 = 12;
+ map<bool, sint32> field_map_bool_sint32_13 = 13;
+ map<bool, sint64> field_map_bool_sint64_14 = 14;
+ map<bool, string> field_map_bool_string_15 = 15;
+ map<bool, uint32> field_map_bool_uint32_16 = 16;
+ map<bool, uint64> field_map_bool_uint64_17 = 17;
+ map<fixed32, bool> field_map_fixed32_bool_18 = 18;
+ map<fixed32, bytes> field_map_fixed32_bytes_19 = 19;
+ map<fixed32, double> field_map_fixed32_double_20 = 20;
+ map<fixed32, Proto2MessageLite.TestEnum> field_map_fixed32_enum_21 = 21;
+ map<fixed32, fixed32> field_map_fixed32_fixed32_22 = 22;
+ map<fixed32, fixed64> field_map_fixed32_fixed64_23 = 23;
+ map<fixed32, float> field_map_fixed32_float_24 = 24;
+ map<fixed32, int32> field_map_fixed32_int32_25 = 25;
+ map<fixed32, int64> field_map_fixed32_int64_26 = 26;
+ map<fixed32, Proto2MessageLite> field_map_fixed32_message_27 = 27;
+ map<fixed32, sfixed32> field_map_fixed32_sfixed32_28 = 28;
+ map<fixed32, sfixed64> field_map_fixed32_sfixed64_29 = 29;
+ map<fixed32, sint32> field_map_fixed32_sint32_30 = 30;
+ map<fixed32, sint64> field_map_fixed32_sint64_31 = 31;
+ map<fixed32, string> field_map_fixed32_string_32 = 32;
+ map<fixed32, uint32> field_map_fixed32_uint32_33 = 33;
+ map<fixed32, uint64> field_map_fixed32_uint64_34 = 34;
+ map<fixed64, bool> field_map_fixed64_bool_35 = 35;
+ map<fixed64, bytes> field_map_fixed64_bytes_36 = 36;
+ map<fixed64, double> field_map_fixed64_double_37 = 37;
+ map<fixed64, Proto2MessageLite.TestEnum> field_map_fixed64_enum_38 = 38;
+ map<fixed64, fixed32> field_map_fixed64_fixed32_39 = 39;
+ map<fixed64, fixed64> field_map_fixed64_fixed64_40 = 40;
+ map<fixed64, float> field_map_fixed64_float_41 = 41;
+ map<fixed64, int32> field_map_fixed64_int32_42 = 42;
+ map<fixed64, int64> field_map_fixed64_int64_43 = 43;
+ map<fixed64, Proto2MessageLite> field_map_fixed64_message_44 = 44;
+ map<fixed64, sfixed32> field_map_fixed64_sfixed32_45 = 45;
+ map<fixed64, sfixed64> field_map_fixed64_sfixed64_46 = 46;
+ map<fixed64, sint32> field_map_fixed64_sint32_47 = 47;
+ map<fixed64, sint64> field_map_fixed64_sint64_48 = 48;
+ map<fixed64, string> field_map_fixed64_string_49 = 49;
+ map<fixed64, uint32> field_map_fixed64_uint32_50 = 50;
+ map<fixed64, uint64> field_map_fixed64_uint64_51 = 51;
+ map<int32, bool> field_map_int32_bool_52 = 52;
+ map<int32, bytes> field_map_int32_bytes_53 = 53;
+ map<int32, double> field_map_int32_double_54 = 54;
+ map<int32, Proto2MessageLite.TestEnum> field_map_int32_enum_55 = 55;
+ map<int32, fixed32> field_map_int32_fixed32_56 = 56;
+ map<int32, fixed64> field_map_int32_fixed64_57 = 57;
+ map<int32, float> field_map_int32_float_58 = 58;
+ map<int32, int32> field_map_int32_int32_59 = 59;
+ map<int32, int64> field_map_int32_int64_60 = 60;
+ map<int32, Proto2MessageLite> field_map_int32_message_61 = 61;
+ map<int32, sfixed32> field_map_int32_sfixed32_62 = 62;
+ map<int32, sfixed64> field_map_int32_sfixed64_63 = 63;
+ map<int32, sint32> field_map_int32_sint32_64 = 64;
+ map<int32, sint64> field_map_int32_sint64_65 = 65;
+ map<int32, string> field_map_int32_string_66 = 66;
+ map<int32, uint32> field_map_int32_uint32_67 = 67;
+ map<int32, uint64> field_map_int32_uint64_68 = 68;
+ map<int64, bool> field_map_int64_bool_69 = 69;
+ map<int64, bytes> field_map_int64_bytes_70 = 70;
+ map<int64, double> field_map_int64_double_71 = 71;
+ map<int64, Proto2MessageLite.TestEnum> field_map_int64_enum_72 = 72;
+ map<int64, fixed32> field_map_int64_fixed32_73 = 73;
+ map<int64, fixed64> field_map_int64_fixed64_74 = 74;
+ map<int64, float> field_map_int64_float_75 = 75;
+ map<int64, int32> field_map_int64_int32_76 = 76;
+ map<int64, int64> field_map_int64_int64_77 = 77;
+ map<int64, Proto2MessageLite> field_map_int64_message_78 = 78;
+ map<int64, sfixed32> field_map_int64_sfixed32_79 = 79;
+ map<int64, sfixed64> field_map_int64_sfixed64_80 = 80;
+ map<int64, sint32> field_map_int64_sint32_81 = 81;
+ map<int64, sint64> field_map_int64_sint64_82 = 82;
+ map<int64, string> field_map_int64_string_83 = 83;
+ map<int64, uint32> field_map_int64_uint32_84 = 84;
+ map<int64, uint64> field_map_int64_uint64_85 = 85;
+ map<sfixed32, bool> field_map_sfixed32_bool_86 = 86;
+ map<sfixed32, bytes> field_map_sfixed32_bytes_87 = 87;
+ map<sfixed32, double> field_map_sfixed32_double_88 = 88;
+ map<sfixed32, Proto2MessageLite.TestEnum> field_map_sfixed32_enum_89 = 89;
+ map<sfixed32, fixed32> field_map_sfixed32_fixed32_90 = 90;
+ map<sfixed32, fixed64> field_map_sfixed32_fixed64_91 = 91;
+ map<sfixed32, float> field_map_sfixed32_float_92 = 92;
+ map<sfixed32, int32> field_map_sfixed32_int32_93 = 93;
+ map<sfixed32, int64> field_map_sfixed32_int64_94 = 94;
+ map<sfixed32, Proto2MessageLite> field_map_sfixed32_message_95 = 95;
+ map<sfixed32, sfixed32> field_map_sfixed32_sfixed32_96 = 96;
+ map<sfixed32, sfixed64> field_map_sfixed32_sfixed64_97 = 97;
+ map<sfixed32, sint32> field_map_sfixed32_sint32_98 = 98;
+ map<sfixed32, sint64> field_map_sfixed32_sint64_99 = 99;
+ map<sfixed32, string> field_map_sfixed32_string_100 = 100;
+ map<sfixed32, uint32> field_map_sfixed32_uint32_101 = 101;
+ map<sfixed32, uint64> field_map_sfixed32_uint64_102 = 102;
+ map<sfixed64, bool> field_map_sfixed64_bool_103 = 103;
+ map<sfixed64, bytes> field_map_sfixed64_bytes_104 = 104;
+ map<sfixed64, double> field_map_sfixed64_double_105 = 105;
+ map<sfixed64, Proto2MessageLite.TestEnum> field_map_sfixed64_enum_106 = 106;
+ map<sfixed64, fixed32> field_map_sfixed64_fixed32_107 = 107;
+ map<sfixed64, fixed64> field_map_sfixed64_fixed64_108 = 108;
+ map<sfixed64, float> field_map_sfixed64_float_109 = 109;
+ map<sfixed64, int32> field_map_sfixed64_int32_110 = 110;
+ map<sfixed64, int64> field_map_sfixed64_int64_111 = 111;
+ map<sfixed64, Proto2MessageLite> field_map_sfixed64_message_112 = 112;
+ map<sfixed64, sfixed32> field_map_sfixed64_sfixed32_113 = 113;
+ map<sfixed64, sfixed64> field_map_sfixed64_sfixed64_114 = 114;
+ map<sfixed64, sint32> field_map_sfixed64_sint32_115 = 115;
+ map<sfixed64, sint64> field_map_sfixed64_sint64_116 = 116;
+ map<sfixed64, string> field_map_sfixed64_string_117 = 117;
+ map<sfixed64, uint32> field_map_sfixed64_uint32_118 = 118;
+ map<sfixed64, uint64> field_map_sfixed64_uint64_119 = 119;
+ map<sint32, bool> field_map_sint32_bool_120 = 120;
+ map<sint32, bytes> field_map_sint32_bytes_121 = 121;
+ map<sint32, double> field_map_sint32_double_122 = 122;
+ map<sint32, Proto2MessageLite.TestEnum> field_map_sint32_enum_123 = 123;
+ map<sint32, fixed32> field_map_sint32_fixed32_124 = 124;
+ map<sint32, fixed64> field_map_sint32_fixed64_125 = 125;
+ map<sint32, float> field_map_sint32_float_126 = 126;
+ map<sint32, int32> field_map_sint32_int32_127 = 127;
+ map<sint32, int64> field_map_sint32_int64_128 = 128;
+ map<sint32, Proto2MessageLite> field_map_sint32_message_129 = 129;
+ map<sint32, sfixed32> field_map_sint32_sfixed32_130 = 130;
+ map<sint32, sfixed64> field_map_sint32_sfixed64_131 = 131;
+ map<sint32, sint32> field_map_sint32_sint32_132 = 132;
+ map<sint32, sint64> field_map_sint32_sint64_133 = 133;
+ map<sint32, string> field_map_sint32_string_134 = 134;
+ map<sint32, uint32> field_map_sint32_uint32_135 = 135;
+ map<sint32, uint64> field_map_sint32_uint64_136 = 136;
+ map<sint64, bool> field_map_sint64_bool_137 = 137;
+ map<sint64, bytes> field_map_sint64_bytes_138 = 138;
+ map<sint64, double> field_map_sint64_double_139 = 139;
+ map<sint64, Proto2MessageLite.TestEnum> field_map_sint64_enum_140 = 140;
+ map<sint64, fixed32> field_map_sint64_fixed32_141 = 141;
+ map<sint64, fixed64> field_map_sint64_fixed64_142 = 142;
+ map<sint64, float> field_map_sint64_float_143 = 143;
+ map<sint64, int32> field_map_sint64_int32_144 = 144;
+ map<sint64, int64> field_map_sint64_int64_145 = 145;
+ map<sint64, Proto2MessageLite> field_map_sint64_message_146 = 146;
+ map<sint64, sfixed32> field_map_sint64_sfixed32_147 = 147;
+ map<sint64, sfixed64> field_map_sint64_sfixed64_148 = 148;
+ map<sint64, sint32> field_map_sint64_sint32_149 = 149;
+ map<sint64, sint64> field_map_sint64_sint64_150 = 150;
+ map<sint64, string> field_map_sint64_string_151 = 151;
+ map<sint64, uint32> field_map_sint64_uint32_152 = 152;
+ map<sint64, uint64> field_map_sint64_uint64_153 = 153;
+ map<string, bool> field_map_string_bool_154 = 154;
+ map<string, bytes> field_map_string_bytes_155 = 155;
+ map<string, double> field_map_string_double_156 = 156;
+ map<string, Proto2MessageLite.TestEnum> field_map_string_enum_157 = 157;
+ map<string, fixed32> field_map_string_fixed32_158 = 158;
+ map<string, fixed64> field_map_string_fixed64_159 = 159;
+ map<string, float> field_map_string_float_160 = 160;
+ map<string, int32> field_map_string_int32_161 = 161;
+ map<string, int64> field_map_string_int64_162 = 162;
+ map<string, Proto2MessageLite> field_map_string_message_163 = 163;
+ map<string, sfixed32> field_map_string_sfixed32_164 = 164;
+ map<string, sfixed64> field_map_string_sfixed64_165 = 165;
+ map<string, sint32> field_map_string_sint32_166 = 166;
+ map<string, sint64> field_map_string_sint64_167 = 167;
+ map<string, string> field_map_string_string_168 = 168;
+ map<string, uint32> field_map_string_uint32_169 = 169;
+ map<string, uint64> field_map_string_uint64_170 = 170;
+ map<uint32, bool> field_map_uint32_bool_171 = 171;
+ map<uint32, bytes> field_map_uint32_bytes_172 = 172;
+ map<uint32, double> field_map_uint32_double_173 = 173;
+ map<uint32, Proto2MessageLite.TestEnum> field_map_uint32_enum_174 = 174;
+ map<uint32, fixed32> field_map_uint32_fixed32_175 = 175;
+ map<uint32, fixed64> field_map_uint32_fixed64_176 = 176;
+ map<uint32, float> field_map_uint32_float_177 = 177;
+ map<uint32, int32> field_map_uint32_int32_178 = 178;
+ map<uint32, int64> field_map_uint32_int64_179 = 179;
+ map<uint32, Proto2MessageLite> field_map_uint32_message_180 = 180;
+ map<uint32, sfixed32> field_map_uint32_sfixed32_181 = 181;
+ map<uint32, sfixed64> field_map_uint32_sfixed64_182 = 182;
+ map<uint32, sint32> field_map_uint32_sint32_183 = 183;
+ map<uint32, sint64> field_map_uint32_sint64_184 = 184;
+ map<uint32, string> field_map_uint32_string_185 = 185;
+ map<uint32, uint32> field_map_uint32_uint32_186 = 186;
+ map<uint32, uint64> field_map_uint32_uint64_187 = 187;
+ map<uint64, bool> field_map_uint64_bool_188 = 188;
+ map<uint64, bytes> field_map_uint64_bytes_189 = 189;
+ map<uint64, double> field_map_uint64_double_190 = 190;
+ map<uint64, Proto2MessageLite.TestEnum> field_map_uint64_enum_191 = 191;
+ map<uint64, fixed32> field_map_uint64_fixed32_192 = 192;
+ map<uint64, fixed64> field_map_uint64_fixed64_193 = 193;
+ map<uint64, float> field_map_uint64_float_194 = 194;
+ map<uint64, int32> field_map_uint64_int32_195 = 195;
+ map<uint64, int64> field_map_uint64_int64_196 = 196;
+ map<uint64, Proto2MessageLite> field_map_uint64_message_197 = 197;
+ map<uint64, sfixed32> field_map_uint64_sfixed32_198 = 198;
+ map<uint64, sfixed64> field_map_uint64_sfixed64_199 = 199;
+ map<uint64, sint32> field_map_uint64_sint32_200 = 200;
+ map<uint64, sint64> field_map_uint64_sint64_201 = 201;
+ map<uint64, string> field_map_uint64_string_202 = 202;
+ map<uint64, uint32> field_map_uint64_uint32_203 = 203;
+ map<uint64, uint64> field_map_uint64_uint64_204 = 204;
+}
diff --git a/java/core/src/test/proto/com/google/protobuf/proto3_message.proto b/java/core/src/test/proto/com/google/protobuf/proto3_message.proto
new file mode 100755
index 0000000..01c7deb
--- /dev/null
+++ b/java/core/src/test/proto/com/google/protobuf/proto3_message.proto
@@ -0,0 +1,326 @@
+// 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.
+
+syntax = "proto3";
+
+option java_package = "com.google.protobuf.testing";
+option java_outer_classname = "Proto3Testing";
+package protobuf.experimental;
+
+message Proto3SpecialFieldName {
+ double regular_name = 1;
+ int32 cached_size = 2;
+ int64 serialized_size = 3;
+ string class = 4;
+}
+
+message Proto3Message {
+ enum TestEnum {
+ ZERO = 0;
+ ONE = 1;
+ TWO = 2;
+ }
+
+ double field_double_1 = 1;
+ float field_float_2 = 2;
+ int64 field_int64_3 = 3;
+ uint64 field_uint64_4 = 4;
+ int32 field_int32_5 = 5;
+ fixed64 field_fixed64_6 = 6;
+ fixed32 field_fixed32_7 = 7;
+ bool field_bool_8 = 8;
+ string field_string_9 = 9;
+ Proto3Message field_message_10 = 10;
+ bytes field_bytes_11 = 11;
+ uint32 field_uint32_12 = 12;
+ TestEnum field_enum_13 = 13;
+ sfixed32 field_sfixed32_14 = 14;
+ sfixed64 field_sfixed64_15 = 15;
+ sint32 field_sint32_16 = 16;
+ sint64 field_sint64_17 = 17;
+ repeated double field_double_list_18 = 18 [packed = false];
+ repeated float field_float_list_19 = 19 [packed = false];
+ repeated int64 field_int64_list_20 = 20 [packed = false];
+ repeated uint64 field_uint64_list_21 = 21 [packed = false];
+ repeated int32 field_int32_list_22 = 22 [packed = false];
+ repeated fixed64 field_fixed64_list_23 = 23 [packed = false];
+ repeated fixed32 field_fixed32_list_24 = 24 [packed = false];
+ repeated bool field_bool_list_25 = 25 [packed = false];
+ repeated string field_string_list_26 = 26 [packed = false];
+ repeated Proto3Message field_message_list_27 = 27 [packed = false];
+ repeated bytes field_bytes_list_28 = 28 [packed = false];
+ repeated uint32 field_uint32_list_29 = 29 [packed = false];
+ repeated TestEnum field_enum_list_30 = 30 [packed = false];
+ repeated sfixed32 field_sfixed32_list_31 = 31 [packed = false];
+ repeated sfixed64 field_sfixed64_list_32 = 32 [packed = false];
+ repeated sint32 field_sint32_list_33 = 33 [packed = false];
+ repeated sint64 field_sint64_list_34 = 34 [packed = false];
+ repeated double field_double_list_packed_35 = 35 [packed = true];
+ repeated float field_float_list_packed_36 = 36 [packed = true];
+ repeated int64 field_int64_list_packed_37 = 37 [packed = true];
+ repeated uint64 field_uint64_list_packed_38 = 38 [packed = true];
+ repeated int32 field_int32_list_packed_39 = 39 [packed = true];
+ repeated fixed64 field_fixed64_list_packed_40 = 40 [packed = true];
+ repeated fixed32 field_fixed32_list_packed_41 = 41 [packed = true];
+ repeated bool field_bool_list_packed_42 = 42 [packed = true];
+ repeated uint32 field_uint32_list_packed_43 = 43 [packed = true];
+ repeated TestEnum field_enum_list_packed_44 = 44 [packed = true];
+ repeated sfixed32 field_sfixed32_list_packed_45 = 45 [packed = true];
+ repeated sfixed64 field_sfixed64_list_packed_46 = 46 [packed = true];
+ repeated sint32 field_sint32_list_packed_47 = 47 [packed = true];
+ repeated sint64 field_sint64_list_packed_48 = 48 [packed = true];
+ oneof test_oneof {
+ double field_double_53 = 53;
+ float field_float_54 = 54;
+ int64 field_int64_55 = 55;
+ uint64 field_uint64_56 = 56;
+ int32 field_int32_57 = 57;
+ fixed64 field_fixed64_58 = 58;
+ fixed32 field_fixed32_59 = 59;
+ bool field_bool_60 = 60;
+ string field_string_61 = 61;
+ Proto3Message field_message_62 = 62;
+ bytes field_bytes_63 = 63;
+ uint32 field_uint32_64 = 64;
+ sfixed32 field_sfixed32_65 = 65;
+ sfixed64 field_sfixed64_66 = 66;
+ sint32 field_sint32_67 = 67;
+ sint64 field_sint64_68 = 68;
+ }
+}
+
+message Proto3Empty {}
+
+message Proto3MessageWithMaps {
+ map<bool, bool> field_map_bool_bool_1 = 1;
+ map<bool, bytes> field_map_bool_bytes_2 = 2;
+ map<bool, double> field_map_bool_double_3 = 3;
+ map<bool, Proto3Message.TestEnum> field_map_bool_enum_4 = 4;
+ map<bool, fixed32> field_map_bool_fixed32_5 = 5;
+ map<bool, fixed64> field_map_bool_fixed64_6 = 6;
+ map<bool, float> field_map_bool_float_7 = 7;
+ map<bool, int32> field_map_bool_int32_8 = 8;
+ map<bool, int64> field_map_bool_int64_9 = 9;
+ map<bool, Proto3Message> field_map_bool_message_10 = 10;
+ map<bool, sfixed32> field_map_bool_sfixed32_11 = 11;
+ map<bool, sfixed64> field_map_bool_sfixed64_12 = 12;
+ map<bool, sint32> field_map_bool_sint32_13 = 13;
+ map<bool, sint64> field_map_bool_sint64_14 = 14;
+ map<bool, string> field_map_bool_string_15 = 15;
+ map<bool, uint32> field_map_bool_uint32_16 = 16;
+ map<bool, uint64> field_map_bool_uint64_17 = 17;
+ map<fixed32, bool> field_map_fixed32_bool_18 = 18;
+ map<fixed32, bytes> field_map_fixed32_bytes_19 = 19;
+ map<fixed32, double> field_map_fixed32_double_20 = 20;
+ map<fixed32, Proto3Message.TestEnum> field_map_fixed32_enum_21 = 21;
+ map<fixed32, fixed32> field_map_fixed32_fixed32_22 = 22;
+ map<fixed32, fixed64> field_map_fixed32_fixed64_23 = 23;
+ map<fixed32, float> field_map_fixed32_float_24 = 24;
+ map<fixed32, int32> field_map_fixed32_int32_25 = 25;
+ map<fixed32, int64> field_map_fixed32_int64_26 = 26;
+ map<fixed32, Proto3Message> field_map_fixed32_message_27 = 27;
+ map<fixed32, sfixed32> field_map_fixed32_sfixed32_28 = 28;
+ map<fixed32, sfixed64> field_map_fixed32_sfixed64_29 = 29;
+ map<fixed32, sint32> field_map_fixed32_sint32_30 = 30;
+ map<fixed32, sint64> field_map_fixed32_sint64_31 = 31;
+ map<fixed32, string> field_map_fixed32_string_32 = 32;
+ map<fixed32, uint32> field_map_fixed32_uint32_33 = 33;
+ map<fixed32, uint64> field_map_fixed32_uint64_34 = 34;
+ map<fixed64, bool> field_map_fixed64_bool_35 = 35;
+ map<fixed64, bytes> field_map_fixed64_bytes_36 = 36;
+ map<fixed64, double> field_map_fixed64_double_37 = 37;
+ map<fixed64, Proto3Message.TestEnum> field_map_fixed64_enum_38 = 38;
+ map<fixed64, fixed32> field_map_fixed64_fixed32_39 = 39;
+ map<fixed64, fixed64> field_map_fixed64_fixed64_40 = 40;
+ map<fixed64, float> field_map_fixed64_float_41 = 41;
+ map<fixed64, int32> field_map_fixed64_int32_42 = 42;
+ map<fixed64, int64> field_map_fixed64_int64_43 = 43;
+ map<fixed64, Proto3Message> field_map_fixed64_message_44 = 44;
+ map<fixed64, sfixed32> field_map_fixed64_sfixed32_45 = 45;
+ map<fixed64, sfixed64> field_map_fixed64_sfixed64_46 = 46;
+ map<fixed64, sint32> field_map_fixed64_sint32_47 = 47;
+ map<fixed64, sint64> field_map_fixed64_sint64_48 = 48;
+ map<fixed64, string> field_map_fixed64_string_49 = 49;
+ map<fixed64, uint32> field_map_fixed64_uint32_50 = 50;
+ map<fixed64, uint64> field_map_fixed64_uint64_51 = 51;
+ map<int32, bool> field_map_int32_bool_52 = 52;
+ map<int32, bytes> field_map_int32_bytes_53 = 53;
+ map<int32, double> field_map_int32_double_54 = 54;
+ map<int32, Proto3Message.TestEnum> field_map_int32_enum_55 = 55;
+ map<int32, fixed32> field_map_int32_fixed32_56 = 56;
+ map<int32, fixed64> field_map_int32_fixed64_57 = 57;
+ map<int32, float> field_map_int32_float_58 = 58;
+ map<int32, int32> field_map_int32_int32_59 = 59;
+ map<int32, int64> field_map_int32_int64_60 = 60;
+ map<int32, Proto3Message> field_map_int32_message_61 = 61;
+ map<int32, sfixed32> field_map_int32_sfixed32_62 = 62;
+ map<int32, sfixed64> field_map_int32_sfixed64_63 = 63;
+ map<int32, sint32> field_map_int32_sint32_64 = 64;
+ map<int32, sint64> field_map_int32_sint64_65 = 65;
+ map<int32, string> field_map_int32_string_66 = 66;
+ map<int32, uint32> field_map_int32_uint32_67 = 67;
+ map<int32, uint64> field_map_int32_uint64_68 = 68;
+ map<int64, bool> field_map_int64_bool_69 = 69;
+ map<int64, bytes> field_map_int64_bytes_70 = 70;
+ map<int64, double> field_map_int64_double_71 = 71;
+ map<int64, Proto3Message.TestEnum> field_map_int64_enum_72 = 72;
+ map<int64, fixed32> field_map_int64_fixed32_73 = 73;
+ map<int64, fixed64> field_map_int64_fixed64_74 = 74;
+ map<int64, float> field_map_int64_float_75 = 75;
+ map<int64, int32> field_map_int64_int32_76 = 76;
+ map<int64, int64> field_map_int64_int64_77 = 77;
+ map<int64, Proto3Message> field_map_int64_message_78 = 78;
+ map<int64, sfixed32> field_map_int64_sfixed32_79 = 79;
+ map<int64, sfixed64> field_map_int64_sfixed64_80 = 80;
+ map<int64, sint32> field_map_int64_sint32_81 = 81;
+ map<int64, sint64> field_map_int64_sint64_82 = 82;
+ map<int64, string> field_map_int64_string_83 = 83;
+ map<int64, uint32> field_map_int64_uint32_84 = 84;
+ map<int64, uint64> field_map_int64_uint64_85 = 85;
+ map<sfixed32, bool> field_map_sfixed32_bool_86 = 86;
+ map<sfixed32, bytes> field_map_sfixed32_bytes_87 = 87;
+ map<sfixed32, double> field_map_sfixed32_double_88 = 88;
+ map<sfixed32, Proto3Message.TestEnum> field_map_sfixed32_enum_89 = 89;
+ map<sfixed32, fixed32> field_map_sfixed32_fixed32_90 = 90;
+ map<sfixed32, fixed64> field_map_sfixed32_fixed64_91 = 91;
+ map<sfixed32, float> field_map_sfixed32_float_92 = 92;
+ map<sfixed32, int32> field_map_sfixed32_int32_93 = 93;
+ map<sfixed32, int64> field_map_sfixed32_int64_94 = 94;
+ map<sfixed32, Proto3Message> field_map_sfixed32_message_95 = 95;
+ map<sfixed32, sfixed32> field_map_sfixed32_sfixed32_96 = 96;
+ map<sfixed32, sfixed64> field_map_sfixed32_sfixed64_97 = 97;
+ map<sfixed32, sint32> field_map_sfixed32_sint32_98 = 98;
+ map<sfixed32, sint64> field_map_sfixed32_sint64_99 = 99;
+ map<sfixed32, string> field_map_sfixed32_string_100 = 100;
+ map<sfixed32, uint32> field_map_sfixed32_uint32_101 = 101;
+ map<sfixed32, uint64> field_map_sfixed32_uint64_102 = 102;
+ map<sfixed64, bool> field_map_sfixed64_bool_103 = 103;
+ map<sfixed64, bytes> field_map_sfixed64_bytes_104 = 104;
+ map<sfixed64, double> field_map_sfixed64_double_105 = 105;
+ map<sfixed64, Proto3Message.TestEnum> field_map_sfixed64_enum_106 = 106;
+ map<sfixed64, fixed32> field_map_sfixed64_fixed32_107 = 107;
+ map<sfixed64, fixed64> field_map_sfixed64_fixed64_108 = 108;
+ map<sfixed64, float> field_map_sfixed64_float_109 = 109;
+ map<sfixed64, int32> field_map_sfixed64_int32_110 = 110;
+ map<sfixed64, int64> field_map_sfixed64_int64_111 = 111;
+ map<sfixed64, Proto3Message> field_map_sfixed64_message_112 = 112;
+ map<sfixed64, sfixed32> field_map_sfixed64_sfixed32_113 = 113;
+ map<sfixed64, sfixed64> field_map_sfixed64_sfixed64_114 = 114;
+ map<sfixed64, sint32> field_map_sfixed64_sint32_115 = 115;
+ map<sfixed64, sint64> field_map_sfixed64_sint64_116 = 116;
+ map<sfixed64, string> field_map_sfixed64_string_117 = 117;
+ map<sfixed64, uint32> field_map_sfixed64_uint32_118 = 118;
+ map<sfixed64, uint64> field_map_sfixed64_uint64_119 = 119;
+ map<sint32, bool> field_map_sint32_bool_120 = 120;
+ map<sint32, bytes> field_map_sint32_bytes_121 = 121;
+ map<sint32, double> field_map_sint32_double_122 = 122;
+ map<sint32, Proto3Message.TestEnum> field_map_sint32_enum_123 = 123;
+ map<sint32, fixed32> field_map_sint32_fixed32_124 = 124;
+ map<sint32, fixed64> field_map_sint32_fixed64_125 = 125;
+ map<sint32, float> field_map_sint32_float_126 = 126;
+ map<sint32, int32> field_map_sint32_int32_127 = 127;
+ map<sint32, int64> field_map_sint32_int64_128 = 128;
+ map<sint32, Proto3Message> field_map_sint32_message_129 = 129;
+ map<sint32, sfixed32> field_map_sint32_sfixed32_130 = 130;
+ map<sint32, sfixed64> field_map_sint32_sfixed64_131 = 131;
+ map<sint32, sint32> field_map_sint32_sint32_132 = 132;
+ map<sint32, sint64> field_map_sint32_sint64_133 = 133;
+ map<sint32, string> field_map_sint32_string_134 = 134;
+ map<sint32, uint32> field_map_sint32_uint32_135 = 135;
+ map<sint32, uint64> field_map_sint32_uint64_136 = 136;
+ map<sint64, bool> field_map_sint64_bool_137 = 137;
+ map<sint64, bytes> field_map_sint64_bytes_138 = 138;
+ map<sint64, double> field_map_sint64_double_139 = 139;
+ map<sint64, Proto3Message.TestEnum> field_map_sint64_enum_140 = 140;
+ map<sint64, fixed32> field_map_sint64_fixed32_141 = 141;
+ map<sint64, fixed64> field_map_sint64_fixed64_142 = 142;
+ map<sint64, float> field_map_sint64_float_143 = 143;
+ map<sint64, int32> field_map_sint64_int32_144 = 144;
+ map<sint64, int64> field_map_sint64_int64_145 = 145;
+ map<sint64, Proto3Message> field_map_sint64_message_146 = 146;
+ map<sint64, sfixed32> field_map_sint64_sfixed32_147 = 147;
+ map<sint64, sfixed64> field_map_sint64_sfixed64_148 = 148;
+ map<sint64, sint32> field_map_sint64_sint32_149 = 149;
+ map<sint64, sint64> field_map_sint64_sint64_150 = 150;
+ map<sint64, string> field_map_sint64_string_151 = 151;
+ map<sint64, uint32> field_map_sint64_uint32_152 = 152;
+ map<sint64, uint64> field_map_sint64_uint64_153 = 153;
+ map<string, bool> field_map_string_bool_154 = 154;
+ map<string, bytes> field_map_string_bytes_155 = 155;
+ map<string, double> field_map_string_double_156 = 156;
+ map<string, Proto3Message.TestEnum> field_map_string_enum_157 = 157;
+ map<string, fixed32> field_map_string_fixed32_158 = 158;
+ map<string, fixed64> field_map_string_fixed64_159 = 159;
+ map<string, float> field_map_string_float_160 = 160;
+ map<string, int32> field_map_string_int32_161 = 161;
+ map<string, int64> field_map_string_int64_162 = 162;
+ map<string, Proto3Message> field_map_string_message_163 = 163;
+ map<string, sfixed32> field_map_string_sfixed32_164 = 164;
+ map<string, sfixed64> field_map_string_sfixed64_165 = 165;
+ map<string, sint32> field_map_string_sint32_166 = 166;
+ map<string, sint64> field_map_string_sint64_167 = 167;
+ map<string, string> field_map_string_string_168 = 168;
+ map<string, uint32> field_map_string_uint32_169 = 169;
+ map<string, uint64> field_map_string_uint64_170 = 170;
+ map<uint32, bool> field_map_uint32_bool_171 = 171;
+ map<uint32, bytes> field_map_uint32_bytes_172 = 172;
+ map<uint32, double> field_map_uint32_double_173 = 173;
+ map<uint32, Proto3Message.TestEnum> field_map_uint32_enum_174 = 174;
+ map<uint32, fixed32> field_map_uint32_fixed32_175 = 175;
+ map<uint32, fixed64> field_map_uint32_fixed64_176 = 176;
+ map<uint32, float> field_map_uint32_float_177 = 177;
+ map<uint32, int32> field_map_uint32_int32_178 = 178;
+ map<uint32, int64> field_map_uint32_int64_179 = 179;
+ map<uint32, Proto3Message> field_map_uint32_message_180 = 180;
+ map<uint32, sfixed32> field_map_uint32_sfixed32_181 = 181;
+ map<uint32, sfixed64> field_map_uint32_sfixed64_182 = 182;
+ map<uint32, sint32> field_map_uint32_sint32_183 = 183;
+ map<uint32, sint64> field_map_uint32_sint64_184 = 184;
+ map<uint32, string> field_map_uint32_string_185 = 185;
+ map<uint32, uint32> field_map_uint32_uint32_186 = 186;
+ map<uint32, uint64> field_map_uint32_uint64_187 = 187;
+ map<uint64, bool> field_map_uint64_bool_188 = 188;
+ map<uint64, bytes> field_map_uint64_bytes_189 = 189;
+ map<uint64, double> field_map_uint64_double_190 = 190;
+ map<uint64, Proto3Message.TestEnum> field_map_uint64_enum_191 = 191;
+ map<uint64, fixed32> field_map_uint64_fixed32_192 = 192;
+ map<uint64, fixed64> field_map_uint64_fixed64_193 = 193;
+ map<uint64, float> field_map_uint64_float_194 = 194;
+ map<uint64, int32> field_map_uint64_int32_195 = 195;
+ map<uint64, int64> field_map_uint64_int64_196 = 196;
+ map<uint64, Proto3Message> field_map_uint64_message_197 = 197;
+ map<uint64, sfixed32> field_map_uint64_sfixed32_198 = 198;
+ map<uint64, sfixed64> field_map_uint64_sfixed64_199 = 199;
+ map<uint64, sint32> field_map_uint64_sint32_200 = 200;
+ map<uint64, sint64> field_map_uint64_sint64_201 = 201;
+ map<uint64, string> field_map_uint64_string_202 = 202;
+ map<uint64, uint32> field_map_uint64_uint32_203 = 203;
+ map<uint64, uint64> field_map_uint64_uint64_204 = 204;
+}
diff --git a/java/core/src/test/proto/com/google/protobuf/proto3_message_lite.proto b/java/core/src/test/proto/com/google/protobuf/proto3_message_lite.proto
new file mode 100755
index 0000000..ed364ec
--- /dev/null
+++ b/java/core/src/test/proto/com/google/protobuf/proto3_message_lite.proto
@@ -0,0 +1,319 @@
+// 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.
+
+syntax = "proto3";
+
+option java_package = "com.google.protobuf.testing";
+option java_outer_classname = "Proto3TestingLite";
+package protobuf.experimental;
+
+message Proto3MessageLite {
+ enum TestEnum {
+ ZERO = 0;
+ ONE = 1;
+ TWO = 2;
+ }
+
+ double field_double_1 = 1;
+ float field_float_2 = 2;
+ int64 field_int64_3 = 3;
+ uint64 field_uint64_4 = 4;
+ int32 field_int32_5 = 5;
+ fixed64 field_fixed64_6 = 6;
+ fixed32 field_fixed32_7 = 7;
+ bool field_bool_8 = 8;
+ string field_string_9 = 9;
+ Proto3MessageLite field_message_10 = 10;
+ bytes field_bytes_11 = 11;
+ uint32 field_uint32_12 = 12;
+ TestEnum field_enum_13 = 13;
+ sfixed32 field_sfixed32_14 = 14;
+ sfixed64 field_sfixed64_15 = 15;
+ sint32 field_sint32_16 = 16;
+ sint64 field_sint64_17 = 17;
+ repeated double field_double_list_18 = 18 [packed = false];
+ repeated float field_float_list_19 = 19 [packed = false];
+ repeated int64 field_int64_list_20 = 20 [packed = false];
+ repeated uint64 field_uint64_list_21 = 21 [packed = false];
+ repeated int32 field_int32_list_22 = 22 [packed = false];
+ repeated fixed64 field_fixed64_list_23 = 23 [packed = false];
+ repeated fixed32 field_fixed32_list_24 = 24 [packed = false];
+ repeated bool field_bool_list_25 = 25 [packed = false];
+ repeated string field_string_list_26 = 26 [packed = false];
+ repeated Proto3MessageLite field_message_list_27 = 27 [packed = false];
+ repeated bytes field_bytes_list_28 = 28 [packed = false];
+ repeated uint32 field_uint32_list_29 = 29 [packed = false];
+ repeated TestEnum field_enum_list_30 = 30 [packed = false];
+ repeated sfixed32 field_sfixed32_list_31 = 31 [packed = false];
+ repeated sfixed64 field_sfixed64_list_32 = 32 [packed = false];
+ repeated sint32 field_sint32_list_33 = 33 [packed = false];
+ repeated sint64 field_sint64_list_34 = 34 [packed = false];
+ repeated double field_double_list_packed_35 = 35 [packed = true];
+ repeated float field_float_list_packed_36 = 36 [packed = true];
+ repeated int64 field_int64_list_packed_37 = 37 [packed = true];
+ repeated uint64 field_uint64_list_packed_38 = 38 [packed = true];
+ repeated int32 field_int32_list_packed_39 = 39 [packed = true];
+ repeated fixed64 field_fixed64_list_packed_40 = 40 [packed = true];
+ repeated fixed32 field_fixed32_list_packed_41 = 41 [packed = true];
+ repeated bool field_bool_list_packed_42 = 42 [packed = true];
+ repeated uint32 field_uint32_list_packed_43 = 43 [packed = true];
+ repeated TestEnum field_enum_list_packed_44 = 44 [packed = true];
+ repeated sfixed32 field_sfixed32_list_packed_45 = 45 [packed = true];
+ repeated sfixed64 field_sfixed64_list_packed_46 = 46 [packed = true];
+ repeated sint32 field_sint32_list_packed_47 = 47 [packed = true];
+ repeated sint64 field_sint64_list_packed_48 = 48 [packed = true];
+ oneof test_oneof {
+ double field_double_53 = 53;
+ float field_float_54 = 54;
+ int64 field_int64_55 = 55;
+ uint64 field_uint64_56 = 56;
+ int32 field_int32_57 = 57;
+ fixed64 field_fixed64_58 = 58;
+ fixed32 field_fixed32_59 = 59;
+ bool field_bool_60 = 60;
+ string field_string_61 = 61;
+ Proto3MessageLite field_message_62 = 62;
+ bytes field_bytes_63 = 63;
+ uint32 field_uint32_64 = 64;
+ sfixed32 field_sfixed32_65 = 65;
+ sfixed64 field_sfixed64_66 = 66;
+ sint32 field_sint32_67 = 67;
+ sint64 field_sint64_68 = 68;
+ }
+}
+
+message Proto3EmptyLite {}
+
+message Proto3MessageLiteWithMaps {
+ map<bool, bool> field_map_bool_bool_1 = 1;
+ map<bool, bytes> field_map_bool_bytes_2 = 2;
+ map<bool, double> field_map_bool_double_3 = 3;
+ map<bool, Proto3MessageLite.TestEnum> field_map_bool_enum_4 = 4;
+ map<bool, fixed32> field_map_bool_fixed32_5 = 5;
+ map<bool, fixed64> field_map_bool_fixed64_6 = 6;
+ map<bool, float> field_map_bool_float_7 = 7;
+ map<bool, int32> field_map_bool_int32_8 = 8;
+ map<bool, int64> field_map_bool_int64_9 = 9;
+ map<bool, Proto3MessageLite> field_map_bool_message_10 = 10;
+ map<bool, sfixed32> field_map_bool_sfixed32_11 = 11;
+ map<bool, sfixed64> field_map_bool_sfixed64_12 = 12;
+ map<bool, sint32> field_map_bool_sint32_13 = 13;
+ map<bool, sint64> field_map_bool_sint64_14 = 14;
+ map<bool, string> field_map_bool_string_15 = 15;
+ map<bool, uint32> field_map_bool_uint32_16 = 16;
+ map<bool, uint64> field_map_bool_uint64_17 = 17;
+ map<fixed32, bool> field_map_fixed32_bool_18 = 18;
+ map<fixed32, bytes> field_map_fixed32_bytes_19 = 19;
+ map<fixed32, double> field_map_fixed32_double_20 = 20;
+ map<fixed32, Proto3MessageLite.TestEnum> field_map_fixed32_enum_21 = 21;
+ map<fixed32, fixed32> field_map_fixed32_fixed32_22 = 22;
+ map<fixed32, fixed64> field_map_fixed32_fixed64_23 = 23;
+ map<fixed32, float> field_map_fixed32_float_24 = 24;
+ map<fixed32, int32> field_map_fixed32_int32_25 = 25;
+ map<fixed32, int64> field_map_fixed32_int64_26 = 26;
+ map<fixed32, Proto3MessageLite> field_map_fixed32_message_27 = 27;
+ map<fixed32, sfixed32> field_map_fixed32_sfixed32_28 = 28;
+ map<fixed32, sfixed64> field_map_fixed32_sfixed64_29 = 29;
+ map<fixed32, sint32> field_map_fixed32_sint32_30 = 30;
+ map<fixed32, sint64> field_map_fixed32_sint64_31 = 31;
+ map<fixed32, string> field_map_fixed32_string_32 = 32;
+ map<fixed32, uint32> field_map_fixed32_uint32_33 = 33;
+ map<fixed32, uint64> field_map_fixed32_uint64_34 = 34;
+ map<fixed64, bool> field_map_fixed64_bool_35 = 35;
+ map<fixed64, bytes> field_map_fixed64_bytes_36 = 36;
+ map<fixed64, double> field_map_fixed64_double_37 = 37;
+ map<fixed64, Proto3MessageLite.TestEnum> field_map_fixed64_enum_38 = 38;
+ map<fixed64, fixed32> field_map_fixed64_fixed32_39 = 39;
+ map<fixed64, fixed64> field_map_fixed64_fixed64_40 = 40;
+ map<fixed64, float> field_map_fixed64_float_41 = 41;
+ map<fixed64, int32> field_map_fixed64_int32_42 = 42;
+ map<fixed64, int64> field_map_fixed64_int64_43 = 43;
+ map<fixed64, Proto3MessageLite> field_map_fixed64_message_44 = 44;
+ map<fixed64, sfixed32> field_map_fixed64_sfixed32_45 = 45;
+ map<fixed64, sfixed64> field_map_fixed64_sfixed64_46 = 46;
+ map<fixed64, sint32> field_map_fixed64_sint32_47 = 47;
+ map<fixed64, sint64> field_map_fixed64_sint64_48 = 48;
+ map<fixed64, string> field_map_fixed64_string_49 = 49;
+ map<fixed64, uint32> field_map_fixed64_uint32_50 = 50;
+ map<fixed64, uint64> field_map_fixed64_uint64_51 = 51;
+ map<int32, bool> field_map_int32_bool_52 = 52;
+ map<int32, bytes> field_map_int32_bytes_53 = 53;
+ map<int32, double> field_map_int32_double_54 = 54;
+ map<int32, Proto3MessageLite.TestEnum> field_map_int32_enum_55 = 55;
+ map<int32, fixed32> field_map_int32_fixed32_56 = 56;
+ map<int32, fixed64> field_map_int32_fixed64_57 = 57;
+ map<int32, float> field_map_int32_float_58 = 58;
+ map<int32, int32> field_map_int32_int32_59 = 59;
+ map<int32, int64> field_map_int32_int64_60 = 60;
+ map<int32, Proto3MessageLite> field_map_int32_message_61 = 61;
+ map<int32, sfixed32> field_map_int32_sfixed32_62 = 62;
+ map<int32, sfixed64> field_map_int32_sfixed64_63 = 63;
+ map<int32, sint32> field_map_int32_sint32_64 = 64;
+ map<int32, sint64> field_map_int32_sint64_65 = 65;
+ map<int32, string> field_map_int32_string_66 = 66;
+ map<int32, uint32> field_map_int32_uint32_67 = 67;
+ map<int32, uint64> field_map_int32_uint64_68 = 68;
+ map<int64, bool> field_map_int64_bool_69 = 69;
+ map<int64, bytes> field_map_int64_bytes_70 = 70;
+ map<int64, double> field_map_int64_double_71 = 71;
+ map<int64, Proto3MessageLite.TestEnum> field_map_int64_enum_72 = 72;
+ map<int64, fixed32> field_map_int64_fixed32_73 = 73;
+ map<int64, fixed64> field_map_int64_fixed64_74 = 74;
+ map<int64, float> field_map_int64_float_75 = 75;
+ map<int64, int32> field_map_int64_int32_76 = 76;
+ map<int64, int64> field_map_int64_int64_77 = 77;
+ map<int64, Proto3MessageLite> field_map_int64_message_78 = 78;
+ map<int64, sfixed32> field_map_int64_sfixed32_79 = 79;
+ map<int64, sfixed64> field_map_int64_sfixed64_80 = 80;
+ map<int64, sint32> field_map_int64_sint32_81 = 81;
+ map<int64, sint64> field_map_int64_sint64_82 = 82;
+ map<int64, string> field_map_int64_string_83 = 83;
+ map<int64, uint32> field_map_int64_uint32_84 = 84;
+ map<int64, uint64> field_map_int64_uint64_85 = 85;
+ map<sfixed32, bool> field_map_sfixed32_bool_86 = 86;
+ map<sfixed32, bytes> field_map_sfixed32_bytes_87 = 87;
+ map<sfixed32, double> field_map_sfixed32_double_88 = 88;
+ map<sfixed32, Proto3MessageLite.TestEnum> field_map_sfixed32_enum_89 = 89;
+ map<sfixed32, fixed32> field_map_sfixed32_fixed32_90 = 90;
+ map<sfixed32, fixed64> field_map_sfixed32_fixed64_91 = 91;
+ map<sfixed32, float> field_map_sfixed32_float_92 = 92;
+ map<sfixed32, int32> field_map_sfixed32_int32_93 = 93;
+ map<sfixed32, int64> field_map_sfixed32_int64_94 = 94;
+ map<sfixed32, Proto3MessageLite> field_map_sfixed32_message_95 = 95;
+ map<sfixed32, sfixed32> field_map_sfixed32_sfixed32_96 = 96;
+ map<sfixed32, sfixed64> field_map_sfixed32_sfixed64_97 = 97;
+ map<sfixed32, sint32> field_map_sfixed32_sint32_98 = 98;
+ map<sfixed32, sint64> field_map_sfixed32_sint64_99 = 99;
+ map<sfixed32, string> field_map_sfixed32_string_100 = 100;
+ map<sfixed32, uint32> field_map_sfixed32_uint32_101 = 101;
+ map<sfixed32, uint64> field_map_sfixed32_uint64_102 = 102;
+ map<sfixed64, bool> field_map_sfixed64_bool_103 = 103;
+ map<sfixed64, bytes> field_map_sfixed64_bytes_104 = 104;
+ map<sfixed64, double> field_map_sfixed64_double_105 = 105;
+ map<sfixed64, Proto3MessageLite.TestEnum> field_map_sfixed64_enum_106 = 106;
+ map<sfixed64, fixed32> field_map_sfixed64_fixed32_107 = 107;
+ map<sfixed64, fixed64> field_map_sfixed64_fixed64_108 = 108;
+ map<sfixed64, float> field_map_sfixed64_float_109 = 109;
+ map<sfixed64, int32> field_map_sfixed64_int32_110 = 110;
+ map<sfixed64, int64> field_map_sfixed64_int64_111 = 111;
+ map<sfixed64, Proto3MessageLite> field_map_sfixed64_message_112 = 112;
+ map<sfixed64, sfixed32> field_map_sfixed64_sfixed32_113 = 113;
+ map<sfixed64, sfixed64> field_map_sfixed64_sfixed64_114 = 114;
+ map<sfixed64, sint32> field_map_sfixed64_sint32_115 = 115;
+ map<sfixed64, sint64> field_map_sfixed64_sint64_116 = 116;
+ map<sfixed64, string> field_map_sfixed64_string_117 = 117;
+ map<sfixed64, uint32> field_map_sfixed64_uint32_118 = 118;
+ map<sfixed64, uint64> field_map_sfixed64_uint64_119 = 119;
+ map<sint32, bool> field_map_sint32_bool_120 = 120;
+ map<sint32, bytes> field_map_sint32_bytes_121 = 121;
+ map<sint32, double> field_map_sint32_double_122 = 122;
+ map<sint32, Proto3MessageLite.TestEnum> field_map_sint32_enum_123 = 123;
+ map<sint32, fixed32> field_map_sint32_fixed32_124 = 124;
+ map<sint32, fixed64> field_map_sint32_fixed64_125 = 125;
+ map<sint32, float> field_map_sint32_float_126 = 126;
+ map<sint32, int32> field_map_sint32_int32_127 = 127;
+ map<sint32, int64> field_map_sint32_int64_128 = 128;
+ map<sint32, Proto3MessageLite> field_map_sint32_message_129 = 129;
+ map<sint32, sfixed32> field_map_sint32_sfixed32_130 = 130;
+ map<sint32, sfixed64> field_map_sint32_sfixed64_131 = 131;
+ map<sint32, sint32> field_map_sint32_sint32_132 = 132;
+ map<sint32, sint64> field_map_sint32_sint64_133 = 133;
+ map<sint32, string> field_map_sint32_string_134 = 134;
+ map<sint32, uint32> field_map_sint32_uint32_135 = 135;
+ map<sint32, uint64> field_map_sint32_uint64_136 = 136;
+ map<sint64, bool> field_map_sint64_bool_137 = 137;
+ map<sint64, bytes> field_map_sint64_bytes_138 = 138;
+ map<sint64, double> field_map_sint64_double_139 = 139;
+ map<sint64, Proto3MessageLite.TestEnum> field_map_sint64_enum_140 = 140;
+ map<sint64, fixed32> field_map_sint64_fixed32_141 = 141;
+ map<sint64, fixed64> field_map_sint64_fixed64_142 = 142;
+ map<sint64, float> field_map_sint64_float_143 = 143;
+ map<sint64, int32> field_map_sint64_int32_144 = 144;
+ map<sint64, int64> field_map_sint64_int64_145 = 145;
+ map<sint64, Proto3MessageLite> field_map_sint64_message_146 = 146;
+ map<sint64, sfixed32> field_map_sint64_sfixed32_147 = 147;
+ map<sint64, sfixed64> field_map_sint64_sfixed64_148 = 148;
+ map<sint64, sint32> field_map_sint64_sint32_149 = 149;
+ map<sint64, sint64> field_map_sint64_sint64_150 = 150;
+ map<sint64, string> field_map_sint64_string_151 = 151;
+ map<sint64, uint32> field_map_sint64_uint32_152 = 152;
+ map<sint64, uint64> field_map_sint64_uint64_153 = 153;
+ map<string, bool> field_map_string_bool_154 = 154;
+ map<string, bytes> field_map_string_bytes_155 = 155;
+ map<string, double> field_map_string_double_156 = 156;
+ map<string, Proto3MessageLite.TestEnum> field_map_string_enum_157 = 157;
+ map<string, fixed32> field_map_string_fixed32_158 = 158;
+ map<string, fixed64> field_map_string_fixed64_159 = 159;
+ map<string, float> field_map_string_float_160 = 160;
+ map<string, int32> field_map_string_int32_161 = 161;
+ map<string, int64> field_map_string_int64_162 = 162;
+ map<string, Proto3MessageLite> field_map_string_message_163 = 163;
+ map<string, sfixed32> field_map_string_sfixed32_164 = 164;
+ map<string, sfixed64> field_map_string_sfixed64_165 = 165;
+ map<string, sint32> field_map_string_sint32_166 = 166;
+ map<string, sint64> field_map_string_sint64_167 = 167;
+ map<string, string> field_map_string_string_168 = 168;
+ map<string, uint32> field_map_string_uint32_169 = 169;
+ map<string, uint64> field_map_string_uint64_170 = 170;
+ map<uint32, bool> field_map_uint32_bool_171 = 171;
+ map<uint32, bytes> field_map_uint32_bytes_172 = 172;
+ map<uint32, double> field_map_uint32_double_173 = 173;
+ map<uint32, Proto3MessageLite.TestEnum> field_map_uint32_enum_174 = 174;
+ map<uint32, fixed32> field_map_uint32_fixed32_175 = 175;
+ map<uint32, fixed64> field_map_uint32_fixed64_176 = 176;
+ map<uint32, float> field_map_uint32_float_177 = 177;
+ map<uint32, int32> field_map_uint32_int32_178 = 178;
+ map<uint32, int64> field_map_uint32_int64_179 = 179;
+ map<uint32, Proto3MessageLite> field_map_uint32_message_180 = 180;
+ map<uint32, sfixed32> field_map_uint32_sfixed32_181 = 181;
+ map<uint32, sfixed64> field_map_uint32_sfixed64_182 = 182;
+ map<uint32, sint32> field_map_uint32_sint32_183 = 183;
+ map<uint32, sint64> field_map_uint32_sint64_184 = 184;
+ map<uint32, string> field_map_uint32_string_185 = 185;
+ map<uint32, uint32> field_map_uint32_uint32_186 = 186;
+ map<uint32, uint64> field_map_uint32_uint64_187 = 187;
+ map<uint64, bool> field_map_uint64_bool_188 = 188;
+ map<uint64, bytes> field_map_uint64_bytes_189 = 189;
+ map<uint64, double> field_map_uint64_double_190 = 190;
+ map<uint64, Proto3MessageLite.TestEnum> field_map_uint64_enum_191 = 191;
+ map<uint64, fixed32> field_map_uint64_fixed32_192 = 192;
+ map<uint64, fixed64> field_map_uint64_fixed64_193 = 193;
+ map<uint64, float> field_map_uint64_float_194 = 194;
+ map<uint64, int32> field_map_uint64_int32_195 = 195;
+ map<uint64, int64> field_map_uint64_int64_196 = 196;
+ map<uint64, Proto3MessageLite> field_map_uint64_message_197 = 197;
+ map<uint64, sfixed32> field_map_uint64_sfixed32_198 = 198;
+ map<uint64, sfixed64> field_map_uint64_sfixed64_199 = 199;
+ map<uint64, sint32> field_map_uint64_sint32_200 = 200;
+ map<uint64, sint64> field_map_uint64_sint64_201 = 201;
+ map<uint64, string> field_map_uint64_string_202 = 202;
+ map<uint64, uint32> field_map_uint64_uint32_203 = 203;
+ map<uint64, uint64> field_map_uint64_uint64_204 = 204;
+}
diff --git a/java/core/src/test/proto/com/google/protobuf/wrappers_test.proto b/java/core/src/test/proto/com/google/protobuf/wrappers_test.proto
new file mode 100755
index 0000000..f151edf
--- /dev/null
+++ b/java/core/src/test/proto/com/google/protobuf/wrappers_test.proto
@@ -0,0 +1,49 @@
+// 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.
+
+syntax = "proto3";
+
+package wrappers_test;
+option java_package = "com.google.protobuf.wrapperstest";
+option java_outer_classname = "WrappersTestProto";
+import "google/protobuf/wrappers.proto";
+
+message TopLevelMessage {
+ int32 field1 = 1;
+ .google.protobuf.DoubleValue field_double = 2;
+ .google.protobuf.FloatValue field_float = 3;
+ .google.protobuf.Int64Value field_int64 = 4;
+ .google.protobuf.UInt64Value field_uint64 = 5;
+ .google.protobuf.Int32Value field_int32 = 6;
+ .google.protobuf.UInt32Value field_uint32 = 7;
+ .google.protobuf.BoolValue field_bool = 8;
+ .google.protobuf.StringValue field_string = 9;
+ .google.protobuf.BytesValue field_bytes = 10;
+}
diff --git a/java/core/src/test/java/com/google/protobuf/LiteTest.java b/java/lite/src/test/java/com/google/protobuf/LiteTest.java
old mode 100644
new mode 100755
similarity index 98%
rename from java/core/src/test/java/com/google/protobuf/LiteTest.java
rename to java/lite/src/test/java/com/google/protobuf/LiteTest.java
index 89213a7..960b203
--- a/java/core/src/test/java/com/google/protobuf/LiteTest.java
+++ b/java/lite/src/test/java/com/google/protobuf/LiteTest.java
@@ -50,6 +50,8 @@
import com.google.protobuf.UnittestLite.TestNestedExtensionLite;
import map_lite_test.MapTestProto.TestMap;
import map_lite_test.MapTestProto.TestMap.MessageValue;
+import protobuf_unittest.NestedExtensionLite;
+import protobuf_unittest.NonNestedExtensionLite;
import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Bar;
import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.BarPrime;
import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Foo;
@@ -2338,6 +2340,26 @@
}
}
+ public void testExtensionRenamesKeywords() {
+ assertTrue(NonNestedExtensionLite.package_ instanceof GeneratedMessageLite.GeneratedExtension);
+ assertTrue(
+ NestedExtensionLite.MyNestedExtensionLite.private_
+ instanceof GeneratedMessageLite.GeneratedExtension);
+
+ NonNestedExtensionLite.MessageLiteToBeExtended msg =
+ NonNestedExtensionLite.MessageLiteToBeExtended.newBuilder()
+ .setExtension(NonNestedExtensionLite.package_, true)
+ .build();
+ assertTrue(msg.getExtension(NonNestedExtensionLite.package_));
+
+ msg =
+ NonNestedExtensionLite.MessageLiteToBeExtended.newBuilder()
+ .setExtension(NestedExtensionLite.MyNestedExtensionLite.private_, 2.4)
+ .build();
+ assertEquals(
+ 2.4, msg.getExtension(NestedExtensionLite.MyNestedExtensionLite.private_), 0.001);
+ }
+
private static final class OneTimeIterableList<T> extends ArrayList<T> {
private boolean wasIterated = false;
diff --git a/java/lite/src/test/java/com/google/protobuf/Proto2MessageLiteInfoFactory.java b/java/lite/src/test/java/com/google/protobuf/Proto2MessageLiteInfoFactory.java
new file mode 100755
index 0000000..4a1d89b
--- /dev/null
+++ b/java/lite/src/test/java/com/google/protobuf/Proto2MessageLiteInfoFactory.java
@@ -0,0 +1,1327 @@
+// 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.forFieldWithEnumVerifier;
+import static com.google.protobuf.FieldInfo.forMapField;
+import static com.google.protobuf.FieldInfo.forOneofMemberField;
+import static com.google.protobuf.FieldInfo.forProto2OptionalField;
+import static com.google.protobuf.FieldInfo.forProto2RequiredField;
+import static com.google.protobuf.FieldInfo.forRepeatedMessageField;
+
+import com.google.protobuf.testing.Proto2TestingLite;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2EmptyLite;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLite;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLite.FieldGroup49;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLite.FieldGroup69;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLite.FieldGroupList51;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLite.FieldRequiredGroup88;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLite.RequiredNestedMessage;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLite.TestEnum;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLiteWithExtensions;
+import com.google.protobuf.testing.Proto2TestingLite.Proto2MessageLiteWithMaps;
+import java.lang.reflect.Field;
+
+/** A factory that generates a hard-coded info for {@link Proto2MessageLite}. */
+public final class Proto2MessageLiteInfoFactory implements MessageInfoFactory {
+ private static final Proto2MessageLiteInfoFactory instanceForRawMessageInfo =
+ new Proto2MessageLiteInfoFactory(true);
+ private static final Proto2MessageLiteInfoFactory instanceForStructuralMessageInfo =
+ new Proto2MessageLiteInfoFactory(false);
+
+ public static Proto2MessageLiteInfoFactory getInstanceForRawMessageInfo() {
+ return instanceForRawMessageInfo;
+ }
+
+ public static Proto2MessageLiteInfoFactory getInstanceForStructuralMessageInfo() {
+ return instanceForStructuralMessageInfo;
+ }
+
+ private final boolean produceRawMessageInfo;
+
+ private Proto2MessageLiteInfoFactory(boolean produceRawMessageInfo) {
+ this.produceRawMessageInfo = produceRawMessageInfo;
+ }
+
+ @Override
+ public boolean isSupported(Class<?> clazz) {
+ return true;
+ }
+
+ @Override
+ public MessageInfo messageInfoFor(Class<?> clazz) {
+ return produceRawMessageInfo ? rawMessageInfoFor(clazz) : structuralMessageInfoFor(clazz);
+ }
+
+ private MessageInfo rawMessageInfoFor(Class<?> clazz) {
+ if (Proto2MessageLite.class.isAssignableFrom(clazz)) {
+ return newRawMessageInfoForProto2MessageLite();
+ } else {
+ throw new IllegalArgumentException("Unsupported class: " + clazz.getName());
+ }
+ }
+
+ private MessageInfo newRawMessageInfoForProto2MessageLite() {
+ java.lang.Object[] objects =
+ new java.lang.Object[] {
+ "testOneof_",
+ "testOneofCase_",
+ "bitField0_",
+ "bitField1_",
+ "fieldDouble1_",
+ "fieldFloat2_",
+ "fieldInt643_",
+ "fieldUint644_",
+ "fieldInt325_",
+ "fieldFixed646_",
+ "fieldFixed327_",
+ "fieldBool8_",
+ "fieldString9_",
+ "fieldMessage10_",
+ "fieldBytes11_",
+ "fieldUint3212_",
+ "fieldEnum13_",
+ Proto2MessageLite.TestEnum.internalGetVerifier(),
+ "fieldSfixed3214_",
+ "fieldSfixed6415_",
+ "fieldSint3216_",
+ "fieldSint6417_",
+ "fieldDoubleList18_",
+ "fieldFloatList19_",
+ "fieldInt64List20_",
+ "fieldUint64List21_",
+ "fieldInt32List22_",
+ "fieldFixed64List23_",
+ "fieldFixed32List24_",
+ "fieldBoolList25_",
+ "fieldStringList26_",
+ "fieldMessageList27_",
+ Proto2MessageLite.class,
+ "fieldBytesList28_",
+ "fieldUint32List29_",
+ "fieldEnumList30_",
+ Proto2MessageLite.TestEnum.internalGetVerifier(),
+ "fieldSfixed32List31_",
+ "fieldSfixed64List32_",
+ "fieldSint32List33_",
+ "fieldSint64List34_",
+ "fieldDoubleListPacked35_",
+ "fieldFloatListPacked36_",
+ "fieldInt64ListPacked37_",
+ "fieldUint64ListPacked38_",
+ "fieldInt32ListPacked39_",
+ "fieldFixed64ListPacked40_",
+ "fieldFixed32ListPacked41_",
+ "fieldBoolListPacked42_",
+ "fieldUint32ListPacked43_",
+ "fieldEnumListPacked44_",
+ Proto2MessageLite.TestEnum.internalGetVerifier(),
+ "fieldSfixed32ListPacked45_",
+ "fieldSfixed64ListPacked46_",
+ "fieldSint32ListPacked47_",
+ "fieldSint64ListPacked48_",
+ "fieldGroup49_",
+ "fieldGroupList51_",
+ Proto2MessageLite.FieldGroupList51.class,
+ Proto2MessageLite.class,
+ Proto2MessageLite.FieldGroup69.class,
+ "fieldRequiredDouble71_",
+ "fieldRequiredFloat72_",
+ "fieldRequiredInt6473_",
+ "fieldRequiredUint6474_",
+ "fieldRequiredInt3275_",
+ "fieldRequiredFixed6476_",
+ "fieldRequiredFixed3277_",
+ "fieldRequiredBool78_",
+ "fieldRequiredString79_",
+ "fieldRequiredMessage80_",
+ "fieldRequiredBytes81_",
+ "fieldRequiredUint3282_",
+ "fieldRequiredEnum83_",
+ Proto2MessageLite.TestEnum.internalGetVerifier(),
+ "fieldRequiredSfixed3284_",
+ "fieldRequiredSfixed6485_",
+ "fieldRequiredSint3286_",
+ "fieldRequiredSint6487_",
+ "fieldRequiredGroup88_",
+ };
+ // To update this after a proto change, run protoc on proto2_message_lite.proto and copy over
+ // the content of the generated buildMessageInfo() method here.
+ java.lang.String info =
+ "\u0001U\u0001\u0002\u0001XU\u0000 \u0015\u0001\u0000\u0000\u0002\u0001\u0001\u0003"
+ + "\u0002\u0002\u0004\u0003\u0003\u0005\u0004\u0004\u0006\u0005\u0005\u0007\u0006\u0006"
+ + "\b\u0007\u0007\t\b\b\n\u0409\t\u000b\n\n\f\u000b\u000b\r\f\f\u000e\r\r\u000f\u000e"
+ + "\u000e\u0010\u000f\u000f\u0011\u0010\u0010\u0012\u0012\u0013\u0013\u0014\u0014\u0015"
+ + "\u0015\u0016\u0016\u0017\u0017\u0018\u0018\u0019\u0019\u001a\u001a\u001b\u041b\u001c"
+ + "\u001c\u001d\u001d\u001e\u001e\u001f\u001f !!\"\"##$$%%&&\'\'(())**++,,--..//00"
+ + "1\u0011\u00113153\u000064\u000075\u000086\u000097\u0000:8\u0000;9\u0000<:\u0000="
+ + ";\u0000>\u043c\u0000?=\u0000@>\u0000A@\u0000BA\u0000CB\u0000DC\u0000ED\u0000G\u0500"
+ + "#H\u0501$I\u0502%J\u0503&K\u0504\'L\u0505(M\u0506)N\u0507*O\u0508+P\u0509,Q\u050a"
+ + "-R\u050b.S\u050c/T\u050d0U\u050e1V\u050f2W\u05103X\u05114";
+ return new RawMessageInfo(Proto2MessageLite.getDefaultInstance(), info, objects);
+ }
+
+ private MessageInfo structuralMessageInfoFor(Class<?> clazz) {
+ if (Proto2MessageLite.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto2MessageLite();
+ } else if (FieldGroup49.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForFieldGroup49();
+ } else if (FieldGroupList51.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForFieldGroupList51();
+ } else if (FieldGroup69.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForFieldGroup69();
+ } else if (FieldRequiredGroup88.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForFieldRequiredGroup88();
+ } else if (RequiredNestedMessage.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForRequiredNestedMessage();
+ } else if (Proto2EmptyLite.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto2EmptyLite();
+ } else if (Proto2MessageLiteWithExtensions.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto2MessageLiteWithExtensions();
+ } else if (Proto2TestingLite.FieldGroup49.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForExtensionFieldGroup49();
+ } else if (Proto2TestingLite.FieldGroupList51.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForExtensionFieldGroupList51();
+ } else if (Proto2TestingLite.Proto2MessageLiteWithMaps.class.isAssignableFrom(clazz)) {
+ return newMessageInfoForProto2MessageLiteWithMaps();
+ } else {
+ throw new IllegalArgumentException("Unsupported class: " + clazz.getName());
+ }
+ }
+
+ /**
+ * Creates a new hard-coded info for {@link Proto2MessageLite}. Each time this is called, we
+ * manually go through the entire process of what a message would do if it self-registered its own
+ * info, including looking up each field by name. This is done for benchmarking purposes, so that
+ * we get a more accurate representation of the time it takes to perform this process.
+ */
+ private static StructuralMessageInfo newMessageInfoForProto2MessageLite() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(48);
+ builder.withCheckInitialized(
+ new int[] {
+ 10, 27, 62, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ });
+ lookupFieldsByName(builder);
+ return builder.build();
+ }
+
+ private static void lookupFieldsByName(StructuralMessageInfo.Builder builder) {
+ Field bitField0 = field(Proto2MessageLite.class, "bitField0_");
+
+ builder.withDefaultInstance(Proto2MessageLite.getDefaultInstance());
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldDouble1_"),
+ 1,
+ FieldType.DOUBLE,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldFloat2_"),
+ 2,
+ FieldType.FLOAT,
+ bitField0,
+ 0x00000002,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldInt643_"),
+ 3,
+ FieldType.INT64,
+ bitField0,
+ 0x00000004,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldUint644_"),
+ 4,
+ FieldType.UINT64,
+ bitField0,
+ 0x00000008,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldInt325_"),
+ 5,
+ FieldType.INT32,
+ bitField0,
+ 0x00000010,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldFixed646_"),
+ 6,
+ FieldType.FIXED64,
+ bitField0,
+ 0x00000020,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldFixed327_"),
+ 7,
+ FieldType.FIXED32,
+ bitField0,
+ 0x00000040,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldBool8_"),
+ 8,
+ FieldType.BOOL,
+ bitField0,
+ 0x00000080,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldString9_"),
+ 9,
+ FieldType.STRING,
+ bitField0,
+ 0x00000100,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldMessage10_"),
+ 10,
+ FieldType.MESSAGE,
+ bitField0,
+ 0x00000200,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldBytes11_"),
+ 11,
+ FieldType.BYTES,
+ bitField0,
+ 0x00000400,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldUint3212_"),
+ 12,
+ FieldType.UINT32,
+ bitField0,
+ 0x00000800,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldEnum13_"),
+ 13,
+ FieldType.ENUM,
+ bitField0,
+ 0x00001000,
+ false,
+ TestEnum.internalGetVerifier()));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldSfixed3214_"),
+ 14,
+ FieldType.SFIXED32,
+ bitField0,
+ 0x00002000,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldSfixed6415_"),
+ 15,
+ FieldType.SFIXED64,
+ bitField0,
+ 0x00004000,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldSint3216_"),
+ 16,
+ FieldType.SINT32,
+ bitField0,
+ 0x00008000,
+ false,
+ null));
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldSint6417_"),
+ 17,
+ FieldType.SINT64,
+ bitField0,
+ 0x00010000,
+ false,
+ null));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldDoubleList18_"),
+ 18,
+ FieldType.DOUBLE_LIST,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldFloatList19_"), 19, FieldType.FLOAT_LIST, false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldInt64List20_"), 20, FieldType.INT64_LIST, false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldUint64List21_"),
+ 21,
+ FieldType.UINT64_LIST,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldInt32List22_"), 22, FieldType.INT32_LIST, false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldFixed64List23_"),
+ 23,
+ FieldType.FIXED64_LIST,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldFixed32List24_"),
+ 24,
+ FieldType.FIXED32_LIST,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldBoolList25_"), 25, FieldType.BOOL_LIST, false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldStringList26_"),
+ 26,
+ FieldType.STRING_LIST,
+ false));
+ builder.withField(
+ forRepeatedMessageField(
+ field(Proto2MessageLite.class, "fieldMessageList27_"),
+ 27,
+ FieldType.MESSAGE_LIST,
+ Proto2MessageLite.class));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldBytesList28_"), 28, FieldType.BYTES_LIST, false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldUint32List29_"),
+ 29,
+ FieldType.UINT32_LIST,
+ false));
+ builder.withField(
+ forFieldWithEnumVerifier(
+ field(Proto2MessageLite.class, "fieldEnumList30_"),
+ 30,
+ FieldType.ENUM_LIST,
+ TestEnum.internalGetVerifier()));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldSfixed32List31_"),
+ 31,
+ FieldType.SFIXED32_LIST,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldSfixed64List32_"),
+ 32,
+ FieldType.SFIXED64_LIST,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldSint32List33_"),
+ 33,
+ FieldType.SINT32_LIST,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldSint64List34_"),
+ 34,
+ FieldType.SINT64_LIST,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldDoubleListPacked35_"),
+ 35,
+ FieldType.DOUBLE_LIST_PACKED,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldFloatListPacked36_"),
+ 36,
+ FieldType.FLOAT_LIST_PACKED,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldInt64ListPacked37_"),
+ 37,
+ FieldType.INT64_LIST_PACKED,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldUint64ListPacked38_"),
+ 38,
+ FieldType.UINT64_LIST_PACKED,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldInt32ListPacked39_"),
+ 39,
+ FieldType.INT32_LIST_PACKED,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldFixed64ListPacked40_"),
+ 40,
+ FieldType.FIXED64_LIST_PACKED,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldFixed32ListPacked41_"),
+ 41,
+ FieldType.FIXED32_LIST_PACKED,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldBoolListPacked42_"),
+ 42,
+ FieldType.BOOL_LIST_PACKED,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldUint32ListPacked43_"),
+ 43,
+ FieldType.UINT32_LIST_PACKED,
+ false));
+ builder.withField(
+ forFieldWithEnumVerifier(
+ field(Proto2MessageLite.class, "fieldEnumListPacked44_"),
+ 44,
+ FieldType.ENUM_LIST_PACKED,
+ TestEnum.internalGetVerifier()));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldSfixed32ListPacked45_"),
+ 45,
+ FieldType.SFIXED32_LIST_PACKED,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldSfixed64ListPacked46_"),
+ 46,
+ FieldType.SFIXED64_LIST_PACKED,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldSint32ListPacked47_"),
+ 47,
+ FieldType.SINT32_LIST_PACKED,
+ false));
+ builder.withField(
+ forField(
+ field(Proto2MessageLite.class, "fieldSint64ListPacked48_"),
+ 48,
+ FieldType.SINT64_LIST_PACKED,
+ false));
+
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2MessageLite.class, "fieldGroup49_"),
+ 49,
+ FieldType.GROUP,
+ bitField0,
+ 0x00020000,
+ false,
+ null));
+ builder.withField(
+ forRepeatedMessageField(
+ field(Proto2MessageLite.class, "fieldGroupList51_"),
+ 51,
+ FieldType.GROUP_LIST,
+ Proto2MessageLite.FieldGroupList51.class));
+
+ OneofInfo oneof =
+ new OneofInfo(
+ 0,
+ field(Proto2MessageLite.class, "testOneofCase_"),
+ field(Proto2MessageLite.class, "testOneof_"));
+ builder.withField(forOneofMemberField(53, FieldType.DOUBLE, oneof, Double.class, false, null));
+ builder.withField(forOneofMemberField(54, FieldType.FLOAT, oneof, Float.class, false, null));
+ builder.withField(forOneofMemberField(55, FieldType.INT64, oneof, Long.class, false, null));
+ builder.withField(forOneofMemberField(56, FieldType.UINT64, oneof, Long.class, false, null));
+ builder.withField(forOneofMemberField(57, FieldType.INT32, oneof, Integer.class, false, null));
+ builder.withField(forOneofMemberField(58, FieldType.FIXED64, oneof, Long.class, false, null));
+ builder.withField(
+ forOneofMemberField(59, FieldType.FIXED32, oneof, Integer.class, false, null));
+ builder.withField(forOneofMemberField(60, FieldType.BOOL, oneof, Boolean.class, false, null));
+ builder.withField(forOneofMemberField(61, FieldType.STRING, oneof, String.class, false, null));
+ builder.withField(
+ forOneofMemberField(62, FieldType.MESSAGE, oneof, Proto2MessageLite.class, false, null));
+ builder.withField(
+ forOneofMemberField(63, FieldType.BYTES, oneof, ByteString.class, false, null));
+ builder.withField(forOneofMemberField(64, FieldType.UINT32, oneof, Integer.class, false, null));
+ builder.withField(
+ forOneofMemberField(65, FieldType.SFIXED32, oneof, Integer.class, false, null));
+ builder.withField(forOneofMemberField(66, FieldType.SFIXED64, oneof, Long.class, false, null));
+ builder.withField(forOneofMemberField(67, FieldType.SINT32, oneof, Integer.class, false, null));
+ builder.withField(forOneofMemberField(68, FieldType.SINT64, oneof, Long.class, false, null));
+ builder.withField(
+ forOneofMemberField(
+ 69, FieldType.GROUP, oneof, Proto2MessageLite.FieldGroup69.class, false, null));
+
+ Field bitField1 = field(Proto2MessageLite.class, "bitField1_");
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredDouble71_"),
+ 71,
+ FieldType.DOUBLE,
+ bitField1,
+ 0x00000008,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredFloat72_"),
+ 72,
+ FieldType.FLOAT,
+ bitField1,
+ 0x00000010,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredInt6473_"),
+ 73,
+ FieldType.INT64,
+ bitField1,
+ 0x00000020,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredUint6474_"),
+ 74,
+ FieldType.UINT64,
+ bitField1,
+ 0x00000040,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredInt3275_"),
+ 75,
+ FieldType.INT32,
+ bitField1,
+ 0x00000080,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredFixed6476_"),
+ 76,
+ FieldType.FIXED64,
+ bitField1,
+ 0x00000100,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredFixed3277_"),
+ 77,
+ FieldType.FIXED32,
+ bitField1,
+ 0x00000200,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredBool78_"),
+ 78,
+ FieldType.BOOL,
+ bitField1,
+ 0x00000400,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredString79_"),
+ 79,
+ FieldType.STRING,
+ bitField1,
+ 0x00000800,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredMessage80_"),
+ 80,
+ FieldType.MESSAGE,
+ bitField1,
+ 0x00001000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredBytes81_"),
+ 81,
+ FieldType.BYTES,
+ bitField1,
+ 0x00002000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredUint3282_"),
+ 82,
+ FieldType.UINT32,
+ bitField1,
+ 0x00004000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredEnum83_"),
+ 83,
+ FieldType.ENUM,
+ bitField1,
+ 0x00008000,
+ false,
+ TestEnum.internalGetVerifier()));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredSfixed3284_"),
+ 84,
+ FieldType.SFIXED32,
+ bitField1,
+ 0x00010000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredSfixed6485_"),
+ 85,
+ FieldType.SFIXED64,
+ bitField1,
+ 0x00020000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredSint3286_"),
+ 86,
+ FieldType.SINT32,
+ bitField1,
+ 0x00040000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredSint6487_"),
+ 87,
+ FieldType.SINT64,
+ bitField1,
+ 0x00080000,
+ false,
+ null));
+ builder.withField(
+ forProto2RequiredField(
+ field(Proto2MessageLite.class, "fieldRequiredGroup88_"),
+ 88,
+ FieldType.GROUP,
+ bitField1,
+ 0x00100000,
+ false,
+ null));
+ }
+
+ private static StructuralMessageInfo newMessageInfoForFieldGroup49() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(FieldGroup49.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(FieldGroup49.class, "fieldInt3250_"),
+ 50,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForFieldGroupList51() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(FieldGroup49.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(FieldGroupList51.class, "fieldInt3252_"),
+ 52,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForFieldGroup69() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(FieldGroup69.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(FieldGroup69.class, "fieldInt3270_"),
+ 70,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForRequiredNestedMessage() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(RequiredNestedMessage.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(RequiredNestedMessage.class, "value_"),
+ 1,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForFieldRequiredGroup88() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(FieldRequiredGroup88.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(FieldRequiredGroup88.class, "fieldInt3289_"),
+ 89,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForProto2EmptyLite() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForProto2MessageLiteWithExtensions() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(0);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForExtensionFieldGroup49() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(Proto2TestingLite.FieldGroup49.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2TestingLite.FieldGroup49.class, "fieldInt3250_"),
+ 50,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+ private static StructuralMessageInfo newMessageInfoForExtensionFieldGroupList51() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder(1);
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ Field bitField0 = field(Proto2TestingLite.FieldGroup49.class, "bitField0_");
+ builder.withField(
+ forProto2OptionalField(
+ field(Proto2TestingLite.FieldGroupList51.class, "fieldInt3252_"),
+ 52,
+ FieldType.INT32,
+ bitField0,
+ 0x00000001,
+ false,
+ null));
+ return builder.build();
+ }
+
+
+ private static StructuralMessageInfo newMessageInfoForProto2MessageLiteWithMaps() {
+ StructuralMessageInfo.Builder builder = StructuralMessageInfo.newBuilder();
+ builder.withCheckInitialized(
+ new int[] {
+ 10, 27, 44, 61, 78, 95, 112, 129, 146, 163, 180, 197,
+ });
+ builder.withSyntax(ProtoSyntax.PROTO2);
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_bool_1", 1));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_bytes_2", 2));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_double_3", 3));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_enum_4", 4));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_fixed32_5", 5));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_fixed64_6", 6));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_float_7", 7));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_int32_8", 8));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_int64_9", 9));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_message_10", 10));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_sfixed32_11", 11));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_sfixed64_12", 12));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_sint32_13", 13));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_sint64_14", 14));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_string_15", 15));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_uint32_16", 16));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_bool_uint64_17", 17));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_bool_18", 18));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_bytes_19", 19));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_double_20", 20));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_enum_21", 21));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_fixed32_22", 22));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_fixed64_23", 23));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_float_24", 24));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_int32_25", 25));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_int64_26", 26));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_message_27", 27));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_sfixed32_28", 28));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_sfixed64_29", 29));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_sint32_30", 30));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_sint64_31", 31));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_string_32", 32));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_uint32_33", 33));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed32_uint64_34", 34));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_bool_35", 35));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_bytes_36", 36));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_double_37", 37));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_enum_38", 38));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_fixed32_39", 39));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_fixed64_40", 40));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_float_41", 41));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_int32_42", 42));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_int64_43", 43));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_message_44", 44));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_sfixed32_45", 45));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_sfixed64_46", 46));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_sint32_47", 47));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_sint64_48", 48));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_string_49", 49));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_uint32_50", 50));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_fixed64_uint64_51", 51));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_bool_52", 52));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_bytes_53", 53));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_double_54", 54));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_enum_55", 55));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_fixed32_56", 56));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_fixed64_57", 57));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_float_58", 58));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_int32_59", 59));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_int64_60", 60));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_message_61", 61));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_sfixed32_62", 62));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_sfixed64_63", 63));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_sint32_64", 64));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_sint64_65", 65));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_string_66", 66));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_uint32_67", 67));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int32_uint64_68", 68));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_bool_69", 69));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_bytes_70", 70));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_double_71", 71));
+ builder.withField(mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_enum_72", 72));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_fixed32_73", 73));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_fixed64_74", 74));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_float_75", 75));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_int32_76", 76));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_int64_77", 77));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_message_78", 78));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_sfixed32_79", 79));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_sfixed64_80", 80));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_sint32_81", 81));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_sint64_82", 82));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_string_83", 83));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_uint32_84", 84));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_int64_uint64_85", 85));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_bool_86", 86));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_bytes_87", 87));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_double_88", 88));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_enum_89", 89));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_fixed32_90", 90));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_fixed64_91", 91));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_float_92", 92));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_int32_93", 93));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_int64_94", 94));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_message_95", 95));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_sfixed32_96", 96));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_sfixed64_97", 97));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_sint32_98", 98));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_sint64_99", 99));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_string_100", 100));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_uint32_101", 101));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed32_uint64_102", 102));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_bool_103", 103));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_bytes_104", 104));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_double_105", 105));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_enum_106", 106));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_fixed32_107", 107));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_fixed64_108", 108));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_float_109", 109));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_int32_110", 110));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_int64_111", 111));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_message_112", 112));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_sfixed32_113", 113));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_sfixed64_114", 114));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_sint32_115", 115));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_sint64_116", 116));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_string_117", 117));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_uint32_118", 118));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sfixed64_uint64_119", 119));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_bool_120", 120));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_bytes_121", 121));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_double_122", 122));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_enum_123", 123));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_fixed32_124", 124));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_fixed64_125", 125));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_float_126", 126));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_int32_127", 127));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_int64_128", 128));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_message_129", 129));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_sfixed32_130", 130));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_sfixed64_131", 131));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_sint32_132", 132));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_sint64_133", 133));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_string_134", 134));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_uint32_135", 135));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint32_uint64_136", 136));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_bool_137", 137));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_bytes_138", 138));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_double_139", 139));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_enum_140", 140));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_fixed32_141", 141));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_fixed64_142", 142));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_float_143", 143));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_int32_144", 144));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_int64_145", 145));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_message_146", 146));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_sfixed32_147", 147));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_sfixed64_148", 148));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_sint32_149", 149));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_sint64_150", 150));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_string_151", 151));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_uint32_152", 152));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_sint64_uint64_153", 153));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_bool_154", 154));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_bytes_155", 155));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_double_156", 156));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_enum_157", 157));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_fixed32_158", 158));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_fixed64_159", 159));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_float_160", 160));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_int32_161", 161));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_int64_162", 162));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_message_163", 163));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_sfixed32_164", 164));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_sfixed64_165", 165));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_sint32_166", 166));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_sint64_167", 167));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_string_168", 168));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_uint32_169", 169));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_string_uint64_170", 170));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_bool_171", 171));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_bytes_172", 172));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_double_173", 173));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_enum_174", 174));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_fixed32_175", 175));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_fixed64_176", 176));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_float_177", 177));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_int32_178", 178));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_int64_179", 179));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_message_180", 180));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_sfixed32_181", 181));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_sfixed64_182", 182));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_sint32_183", 183));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_sint64_184", 184));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_string_185", 185));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_uint32_186", 186));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint32_uint64_187", 187));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_bool_188", 188));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_bytes_189", 189));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_double_190", 190));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_enum_191", 191));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_fixed32_192", 192));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_fixed64_193", 193));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_float_194", 194));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_int32_195", 195));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_int64_196", 196));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_message_197", 197));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_sfixed32_198", 198));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_sfixed64_199", 199));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_sint32_200", 200));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_sint64_201", 201));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_string_202", 202));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_uint32_203", 203));
+ builder.withField(
+ mapFieldInfo(Proto2MessageLiteWithMaps.class, "field_map_uint64_uint64_204", 204));
+
+ return builder.build();
+ }
+
+ private static Field field(Class<?> clazz, String name) {
+ try {
+ return clazz.getDeclaredField(name);
+ } catch (NoSuchFieldException | SecurityException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static FieldInfo mapFieldInfo(Class<?> clazz, String fieldName, int fieldNumber) {
+ try {
+ return forMapField(
+ field(clazz, SchemaUtil.toCamelCase(fieldName, false) + "_"),
+ fieldNumber,
+ SchemaUtil.getMapDefaultEntry(clazz, fieldName),
+ fieldName.contains("_enum_") ? TestEnum.internalGetVerifier() : null);
+ } catch (Throwable t) {
+ throw new RuntimeException(t);
+ }
+ }
+}
diff --git a/java/util/src/test/java/com/google/protobuf/util/JsonFormatTest.java b/java/util/src/test/java/com/google/protobuf/util/JsonFormatTest.java
index b7b437c..75e2ae8 100644
--- a/java/util/src/test/java/com/google/protobuf/util/JsonFormatTest.java
+++ b/java/util/src/test/java/com/google/protobuf/util/JsonFormatTest.java
@@ -464,6 +464,20 @@
assertEquals(NullValue.NULL_VALUE, message.getOneofNullValue());
}
+ public void testNullMessageInDuplicateOneof() throws Exception {
+ // Succeeds if null is first.
+ TestOneof.Builder successBuilder = TestOneof.newBuilder();
+ mergeFromJson("{\"oneofNestedMessage\": null, \"oneofInt32\": 1}", successBuilder);
+
+ // Fails if null is last.
+ try {
+ TestOneof.Builder builder = TestOneof.newBuilder();
+ mergeFromJson("{\"oneofInt32\": 1, \"oneofNestedMessage\": null}", builder);
+ fail();
+ } catch (InvalidProtocolBufferException expected) {
+ }
+ }
+
public void testParserRejectDuplicatedFields() throws Exception {
// TODO(xiaofeng): The parser we are currently using (GSON) will accept and keep the last
// one if multiple entries have the same name. This is not the desired behavior but it can
diff --git a/js/message.js b/js/message.js
index 5ca0a73..aa6e157 100644
--- a/js/message.js
+++ b/js/message.js
@@ -172,7 +172,8 @@
* dead code eliminate fields used in protocol buffers that are never used
* in an application.
*/
-goog.define('jspb.Message.GENERATE_TO_OBJECT', true);
+jspb.Message.GENERATE_TO_OBJECT =
+ goog.define('jspb.Message.GENERATE_TO_OBJECT', true);
/**
@@ -184,7 +185,8 @@
* used in an application.
* By default this is enabled for test code only.
*/
-goog.define('jspb.Message.GENERATE_FROM_OBJECT', !goog.DISALLOW_TEST_ONLY_CODE);
+jspb.Message.GENERATE_FROM_OBJECT = goog.define(
+ 'jspb.Message.GENERATE_FROM_OBJECT', !goog.DISALLOW_TEST_ONLY_CODE);
/**
@@ -192,7 +194,8 @@
* this off if you do not use toString in your project and want to trim it
* from the compiled JS.
*/
-goog.define('jspb.Message.GENERATE_TO_STRING', true);
+jspb.Message.GENERATE_TO_STRING =
+ goog.define('jspb.Message.GENERATE_TO_STRING', true);
/**
@@ -200,7 +203,8 @@
* local (e.g. not from another iframe) and thus safely classified with
* instanceof Array.
*/
-goog.define('jspb.Message.ASSUME_LOCAL_ARRAYS', false);
+jspb.Message.ASSUME_LOCAL_ARRAYS =
+ goog.define('jspb.Message.ASSUME_LOCAL_ARRAYS', false);
// TODO(jakubvrana): Turn this off by default.
@@ -210,7 +214,8 @@
* the proto before serialization. This is enabled by default to be
* backwards compatible. Projects are advised to turn this flag always off.
*/
-goog.define('jspb.Message.SERIALIZE_EMPTY_TRAILING_FIELDS', true);
+jspb.Message.SERIALIZE_EMPTY_TRAILING_FIELDS =
+ goog.define('jspb.Message.SERIALIZE_EMPTY_TRAILING_FIELDS', true);
/**
@@ -326,6 +331,10 @@
return fieldNumber + msg.arrayIndexOffset_;
};
+// This is only here to ensure we are not back sliding on ES6 requiements for
+// protos in g3.
+jspb.Message.hiddenES6Property_ = class {};
+
/**
* Returns the tag number based on the index in msg.array.
diff --git a/python/google/protobuf/internal/api_implementation.cc b/python/google/protobuf/internal/api_implementation.cc
index 6db12e8..2a7f41d 100644
--- a/python/google/protobuf/internal/api_implementation.cc
+++ b/python/google/protobuf/internal/api_implementation.cc
@@ -69,25 +69,24 @@
static const char* kModuleName = "_api_implementation";
static const char kModuleDocstring[] =
-"_api_implementation is a module that exposes compile-time constants that\n"
-"determine the default API implementation to use for Python proto2.\n"
-"\n"
-"It complements api_implementation.py by setting defaults using compile-time\n"
-"constants defined in C, such that one can set defaults at compilation\n"
-"(e.g. with blaze flag --copt=-DPYTHON_PROTO2_CPP_IMPL_V2).";
+ "_api_implementation is a module that exposes compile-time constants that\n"
+ "determine the default API implementation to use for Python proto2.\n"
+ "\n"
+ "It complements api_implementation.py by setting defaults using "
+ "compile-time\n"
+ "constants defined in C, such that one can set defaults at compilation\n"
+ "(e.g. with blaze flag --copt=-DPYTHON_PROTO2_CPP_IMPL_V2).";
#if PY_MAJOR_VERSION >= 3
-static struct PyModuleDef _module = {
- PyModuleDef_HEAD_INIT,
- kModuleName,
- kModuleDocstring,
- -1,
- NULL,
- NULL,
- NULL,
- NULL,
- NULL
-};
+static struct PyModuleDef _module = {PyModuleDef_HEAD_INIT,
+ kModuleName,
+ kModuleDocstring,
+ -1,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL};
#define INITFUNC PyInit__api_implementation
#define INITFUNC_ERRORVAL NULL
#else
@@ -96,32 +95,31 @@
#endif
extern "C" {
- PyMODINIT_FUNC INITFUNC() {
+PyMODINIT_FUNC INITFUNC() {
#if PY_MAJOR_VERSION >= 3
- PyObject *module = PyModule_Create(&_module);
+ PyObject* module = PyModule_Create(&_module);
#else
- PyObject *module = Py_InitModule3(
- const_cast<char*>(kModuleName),
- NULL,
- const_cast<char*>(kModuleDocstring));
+ PyObject* module = Py_InitModule3(const_cast<char*>(kModuleName), NULL,
+ const_cast<char*>(kModuleDocstring));
#endif
- if (module == NULL) {
- return INITFUNC_ERRORVAL;
- }
-
- // Adds the module variable "api_version".
- if (PyModule_AddIntConstant(
- module,
- const_cast<char*>(kImplVersionName),
- kImplVersion))
-#if PY_MAJOR_VERSION < 3
- return;
-#else
- { Py_DECREF(module); return NULL; }
-
- return module;
-#endif
+ if (module == NULL) {
+ return INITFUNC_ERRORVAL;
}
+
+ // Adds the module variable "api_version".
+ if (PyModule_AddIntConstant(module, const_cast<char*>(kImplVersionName),
+ kImplVersion))
+#if PY_MAJOR_VERSION < 3
+ return;
+#else
+ {
+ Py_DECREF(module);
+ return NULL;
+ }
+
+ return module;
+#endif
+}
}
} // namespace python
diff --git a/python/google/protobuf/internal/api_implementation.py b/python/google/protobuf/internal/api_implementation.py
index 23cc2c0..e8448e8 100755
--- a/python/google/protobuf/internal/api_implementation.py
+++ b/python/google/protobuf/internal/api_implementation.py
@@ -137,6 +137,12 @@
return _implementation_type
+def _SetType(implementation_type):
+ """Never use! Only for protobuf benchmark."""
+ global _implementation_type
+ _implementation_type = implementation_type
+
+
# See comment on 'Type' above.
def Version():
return _implementation_version
diff --git a/python/google/protobuf/internal/descriptor_database_test.py b/python/google/protobuf/internal/descriptor_database_test.py
index 800d54f..a185612 100644
--- a/python/google/protobuf/internal/descriptor_database_test.py
+++ b/python/google/protobuf/internal/descriptor_database_test.py
@@ -48,7 +48,8 @@
from google.protobuf import descriptor_database
-class DescriptorDatabaseTest(testing_refleaks.BaseTestCase):
+@testing_refleaks.TestCase
+class DescriptorDatabaseTest(unittest.TestCase):
def testAdd(self):
db = descriptor_database.DescriptorDatabase()
diff --git a/python/google/protobuf/internal/descriptor_pool_test.py b/python/google/protobuf/internal/descriptor_pool_test.py
index 4dc2094..bf7e346 100644
--- a/python/google/protobuf/internal/descriptor_pool_test.py
+++ b/python/google/protobuf/internal/descriptor_pool_test.py
@@ -561,8 +561,8 @@
str(w[0].message))
-class DefaultDescriptorPoolTest(DescriptorPoolTestBase,
- testing_refleaks.BaseTestCase):
+@testing_refleaks.TestCase
+class DefaultDescriptorPoolTest(DescriptorPoolTestBase, unittest.TestCase):
def setUp(self):
self.pool = descriptor_pool.Default()
@@ -597,8 +597,8 @@
unittest_pb2.DESCRIPTOR.services_by_name['TestService'])
-class CreateDescriptorPoolTest(DescriptorPoolTestBase,
- testing_refleaks.BaseTestCase):
+@testing_refleaks.TestCase
+class CreateDescriptorPoolTest(DescriptorPoolTestBase, unittest.TestCase):
def setUp(self):
self.pool = descriptor_pool.DescriptorPool()
@@ -619,8 +619,9 @@
no_package_pb2.DESCRIPTOR.serialized_pb))
+@testing_refleaks.TestCase
class SecondaryDescriptorFromDescriptorDB(DescriptorPoolTestBase,
- testing_refleaks.BaseTestCase):
+ unittest.TestCase):
def setUp(self):
self.factory_test1_fd = descriptor_pb2.FileDescriptorProto.FromString(
@@ -812,7 +813,8 @@
test.assertEqual(file_desc, field_desc.file)
-class AddDescriptorTest(testing_refleaks.BaseTestCase):
+@testing_refleaks.TestCase
+class AddDescriptorTest(unittest.TestCase):
def _TestMessage(self, prefix):
pool = descriptor_pool.DescriptorPool()
diff --git a/python/google/protobuf/internal/extension_dict.py b/python/google/protobuf/internal/extension_dict.py
index 4a1399d..a8ce013 100644
--- a/python/google/protobuf/internal/extension_dict.py
+++ b/python/google/protobuf/internal/extension_dict.py
@@ -183,3 +183,24 @@
Extension field descriptor.
"""
return self._extended_message._extensions_by_number.get(number, None)
+
+ def __iter__(self):
+ # Return a generator over the populated extension fields
+ return (f[0] for f in self._extended_message.ListFields()
+ if f[0].is_extension)
+
+ def __contains__(self, extension_handle):
+ _VerifyExtensionHandle(self._extended_message, extension_handle)
+
+ if extension_handle not in self._extended_message._fields:
+ return False
+
+ if extension_handle.label == FieldDescriptor.LABEL_REPEATED:
+ return bool(self._extended_message._fields.get(extension_handle))
+
+ if extension_handle.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE:
+ value = self._extended_message._fields.get(extension_handle)
+ # pylint: disable=protected-access
+ return value is not None and value._is_present_in_parent
+
+ return True
diff --git a/python/google/protobuf/internal/keywords_test.py b/python/google/protobuf/internal/keywords_test.py
new file mode 100755
index 0000000..8744928
--- /dev/null
+++ b/python/google/protobuf/internal/keywords_test.py
@@ -0,0 +1,105 @@
+#! /usr/bin/env python
+#
+# 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.
+
+"""Tests for google.protobuf.internal.keywords."""
+
+import unittest
+
+
+from google.protobuf.internal import more_messages_pb2
+from google.protobuf import descriptor_pool
+
+
+class KeywordsConflictTest(unittest.TestCase):
+
+ def setUp(self):
+ super(KeywordsConflictTest, self).setUp()
+ self.pool = descriptor_pool.Default()
+
+ def testMessage(self):
+ message = getattr(more_messages_pb2, 'class')()
+ message.int_field = 123
+ self.assertEqual(message.int_field, 123)
+ des = self.pool.FindMessageTypeByName('google.protobuf.internal.class')
+ self.assertEqual(des.name, 'class')
+
+ def testNestedMessage(self):
+ message = getattr(more_messages_pb2, 'class')()
+ message.nested_message.field = 234
+ self.assertEqual(message.nested_message.field, 234)
+ des = self.pool.FindMessageTypeByName('google.protobuf.internal.class.try')
+ self.assertEqual(des.name, 'try')
+
+ def testField(self):
+ message = getattr(more_messages_pb2, 'class')()
+ setattr(message, 'if', 123)
+ setattr(message, 'as', 1)
+ self.assertEqual(getattr(message, 'if'), 123)
+ self.assertEqual(getattr(message, 'as'), 1)
+
+ def testEnum(self):
+ class_ = getattr(more_messages_pb2, 'class')
+ message = class_()
+ # Normal enum value.
+ message.enum_field = more_messages_pb2.default
+ self.assertEqual(message.enum_field, more_messages_pb2.default)
+ # Top level enum value.
+ message.enum_field = getattr(more_messages_pb2, 'else')
+ self.assertEqual(message.enum_field, 1)
+ # Nested enum value
+ message.nested_enum_field = getattr(class_, 'True')
+ self.assertEqual(message.nested_enum_field, 1)
+
+ def testExtension(self):
+ message = getattr(more_messages_pb2, 'class')()
+ # Top level extension
+ extension1 = getattr(more_messages_pb2, 'continue')
+ message.Extensions[extension1] = 456
+ self.assertEqual(message.Extensions[extension1], 456)
+ # None top level extension
+ extension2 = getattr(more_messages_pb2.ExtendClass, 'return')
+ message.Extensions[extension2] = 789
+ self.assertEqual(message.Extensions[extension2], 789)
+
+ def testExtensionForNestedMessage(self):
+ message = getattr(more_messages_pb2, 'class')()
+ extension = getattr(more_messages_pb2, 'with')
+ message.nested_message.Extensions[extension] = 999
+ self.assertEqual(message.nested_message.Extensions[extension], 999)
+
+ def TestFullKeywordUsed(self):
+ message = more_messages_pb2.TestFullKeyword()
+ message.field2.int_field = 123
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/python/google/protobuf/internal/message_factory_test.py b/python/google/protobuf/internal/message_factory_test.py
index 7a5a090..24b79ec 100644
--- a/python/google/protobuf/internal/message_factory_test.py
+++ b/python/google/protobuf/internal/message_factory_test.py
@@ -49,7 +49,8 @@
from google.protobuf import message_factory
-class MessageFactoryTest(testing_refleaks.BaseTestCase):
+@testing_refleaks.TestCase
+class MessageFactoryTest(unittest.TestCase):
def setUp(self):
self.factory_test1_fd = descriptor_pb2.FileDescriptorProto.FromString(
diff --git a/python/google/protobuf/internal/message_test.py b/python/google/protobuf/internal/message_test.py
index b66c1e0..3927ce1 100755
--- a/python/google/protobuf/internal/message_test.py
+++ b/python/google/protobuf/internal/message_test.py
@@ -106,13 +106,11 @@
return isinf(val) and (val < 0)
-BaseTestCase = testing_refleaks.BaseTestCase
-
-
@_parameterized.named_parameters(
('_proto2', unittest_pb2),
('_proto3', unittest_proto3_arena_pb2))
-class MessageTest(BaseTestCase):
+@testing_refleaks.TestCase
+class MessageTest(unittest.TestCase):
def testBadUtf8String(self, message_module):
if api_implementation.Type() != 'python':
@@ -779,28 +777,31 @@
m1 = message_module.TestAllTypes()
m2 = message_module.TestAllTypes()
# Cpp extension will lazily create a sub message which is immutable.
- self.assertEqual(0, m1.optional_nested_message.bb)
+ nested = m1.optional_nested_message
+ self.assertEqual(0, nested.bb)
m2.optional_nested_message.bb = 1
# Make sure cmessage pointing to a mutable message after merge instead of
# the lazily created message.
m1.MergeFrom(m2)
- self.assertEqual(1, m1.optional_nested_message.bb)
+ self.assertEqual(1, nested.bb)
# Test more nested sub message.
msg1 = message_module.NestedTestAllTypes()
msg2 = message_module.NestedTestAllTypes()
- self.assertEqual(0, msg1.child.payload.optional_nested_message.bb)
+ nested = msg1.child.payload.optional_nested_message
+ self.assertEqual(0, nested.bb)
msg2.child.payload.optional_nested_message.bb = 1
msg1.MergeFrom(msg2)
- self.assertEqual(1, msg1.child.payload.optional_nested_message.bb)
+ self.assertEqual(1, nested.bb)
# Test repeated field.
self.assertEqual(msg1.payload.repeated_nested_message,
msg1.payload.repeated_nested_message)
- msg2.payload.repeated_nested_message.add().bb = 1
+ nested = msg2.payload.repeated_nested_message.add()
+ nested.bb = 1
msg1.MergeFrom(msg2)
self.assertEqual(1, len(msg1.payload.repeated_nested_message))
- self.assertEqual(1, msg1.payload.repeated_nested_message[0].bb)
+ self.assertEqual(1, nested.bb)
def testMergeFromString(self, message_module):
m1 = message_module.TestAllTypes()
@@ -1299,7 +1300,8 @@
# Class to test proto2-only features (required, extensions, etc.)
-class Proto2Test(BaseTestCase):
+@testing_refleaks.TestCase
+class Proto2Test(unittest.TestCase):
def testFieldPresence(self):
message = unittest_pb2.TestAllTypes()
@@ -1573,7 +1575,8 @@
# Class to test proto3-only features/behavior (updated field presence & enums)
-class Proto3Test(BaseTestCase):
+@testing_refleaks.TestCase
+class Proto3Test(unittest.TestCase):
# Utility method for comparing equality with a map.
def assertMapIterEquals(self, map_iter, dict_value):
@@ -2444,7 +2447,8 @@
optional_string=u'\ud801\ud801')
-class ValidTypeNamesTest(BaseTestCase):
+@testing_refleaks.TestCase
+class ValidTypeNamesTest(unittest.TestCase):
def assertImportFromName(self, msg, base_name):
# Parse <type 'module.class_name'> to extra 'some.name' as a string.
@@ -2465,7 +2469,8 @@
self.assertImportFromName(pb.repeated_int32, 'Scalar')
self.assertImportFromName(pb.repeated_nested_message, 'Composite')
-class PackedFieldTest(BaseTestCase):
+@testing_refleaks.TestCase
+class PackedFieldTest(unittest.TestCase):
def setMessage(self, message):
message.repeated_int32.append(1)
@@ -2525,7 +2530,8 @@
@unittest.skipIf(api_implementation.Type() != 'cpp' or
sys.version_info < (2, 7),
'explicit tests of the C++ implementation for PY27 and above')
-class OversizeProtosTest(BaseTestCase):
+@testing_refleaks.TestCase
+class OversizeProtosTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
diff --git a/python/google/protobuf/internal/more_extensions.proto b/python/google/protobuf/internal/more_extensions.proto
index 78f1467..5038fd2 100644
--- a/python/google/protobuf/internal/more_extensions.proto
+++ b/python/google/protobuf/internal/more_extensions.proto
@@ -41,7 +41,9 @@
message ExtendedMessage {
- extensions 1 to max;
+ optional int32 optional_int32 = 1001;
+ repeated string repeated_string = 1002;
+ extensions 1 to 999;
}
diff --git a/python/google/protobuf/internal/more_messages.proto b/python/google/protobuf/internal/more_messages.proto
index 612f029..c5889c4 100644
--- a/python/google/protobuf/internal/more_messages.proto
+++ b/python/google/protobuf/internal/more_messages.proto
@@ -30,6 +30,8 @@
// Author: robinson@google.com (Will Robinson)
+// LINT: LEGACY_NAMES
+
syntax = "proto2";
package google.protobuf.internal;
@@ -51,6 +53,53 @@
optional int64 optional_int64 = 2;
}
+enum is { // top level enum keyword
+ default = 0;
+ else = 1; // top level enum value keyword
+}
+
+message class { // message keyword
+ optional int32 int_field = 1;
+ optional int32 if = 2; // field keyword
+ optional is as = 3; // enum field keyword
+ optional is enum_field = 4;
+ enum for { // nested enum keyword
+ default = 0;
+ True = 1; // nested enum value keyword
+ }
+ optional for nested_enum_field = 5;
+ message try {
+ optional int32 field = 1;
+ extensions 999 to 9999;
+ }
+ optional try nested_message = 6;
+ extensions 999 to 9999;
+}
+
+extend class {
+ optional int32 continue = 1001; // top level extension keyword
+}
+
+extend class.try {
+ optional int32 with = 1001;
+}
+
+message ExtendClass {
+ extend class {
+ optional int32 return = 1002; // nested extension keyword
+ }
+}
+
+message TestFullKeyword {
+ optional google.protobuf.internal.OutOfOrderFields field1 = 1;
+ optional google.protobuf.internal.class field2 = 2;
+}
+
+// TODO(jieluo): Add keyword support for service.
+// service False {
+// rpc Bar(class) returns (class);
+// }
+
message LotsNestedMessage {
message B0 {}
message B1 {}
diff --git a/python/google/protobuf/internal/python_protobuf.cc b/python/google/protobuf/internal/python_protobuf.cc
index f90cc43..e823bf2 100644
--- a/python/google/protobuf/internal/python_protobuf.cc
+++ b/python/google/protobuf/internal/python_protobuf.cc
@@ -36,12 +36,8 @@
namespace protobuf {
namespace python {
-static const Message* GetCProtoInsidePyProtoStub(PyObject* msg) {
- return NULL;
-}
-static Message* MutableCProtoInsidePyProtoStub(PyObject* msg) {
- return NULL;
-}
+static const Message* GetCProtoInsidePyProtoStub(PyObject* msg) { return NULL; }
+static Message* MutableCProtoInsidePyProtoStub(PyObject* msg) { return NULL; }
// This is initialized with a default, stub implementation.
// If python-google.protobuf.cc is loaded, the function pointer is overridden
diff --git a/python/google/protobuf/internal/reflection_test.py b/python/google/protobuf/internal/reflection_test.py
index b87eaba..d486bb1 100755
--- a/python/google/protobuf/internal/reflection_test.py
+++ b/python/google/protobuf/internal/reflection_test.py
@@ -68,9 +68,6 @@
long = int # pylint: disable=redefined-builtin,invalid-name
-BaseTestCase = testing_refleaks.BaseTestCase
-
-
class _MiniDecoder(object):
"""Decodes a stream of values from a string.
@@ -116,7 +113,8 @@
return self._pos == len(self._bytes)
-class ReflectionTest(BaseTestCase):
+@testing_refleaks.TestCase
+class ReflectionTest(unittest.TestCase):
def assertListsEqual(self, values, others):
self.assertEqual(len(values), len(others))
@@ -1201,32 +1199,71 @@
self.assertEqual(prius.price, new_prius.price)
self.assertEqual(prius.owners, new_prius.owners)
+ def testExtensionIter(self):
+ extendee_proto = more_extensions_pb2.ExtendedMessage()
+
+ extension_int32 = more_extensions_pb2.optional_int_extension
+ extendee_proto.Extensions[extension_int32] = 23
+
+ extension_repeated = more_extensions_pb2.repeated_int_extension
+ extendee_proto.Extensions[extension_repeated].append(11)
+
+ extension_msg = more_extensions_pb2.optional_message_extension
+ extendee_proto.Extensions[extension_msg].foreign_message_int = 56
+
+ # Set some normal fields.
+ extendee_proto.optional_int32 = 1
+ extendee_proto.repeated_string.append('hi')
+
+ expected = (extension_int32, extension_msg, extension_repeated)
+ count = 0
+ for item in extendee_proto.Extensions:
+ self.assertEqual(item.name, expected[count].name)
+ self.assertIn(item, extendee_proto.Extensions)
+ count += 1
+ self.assertEqual(count, 3)
+
+ def testExtensionContainsError(self):
+ extendee_proto = more_extensions_pb2.ExtendedMessage()
+ self.assertRaises(KeyError, extendee_proto.Extensions.__contains__, 0)
+
+ field = more_extensions_pb2.ExtendedMessage.DESCRIPTOR.fields_by_name[
+ 'optional_int32']
+ self.assertRaises(KeyError, extendee_proto.Extensions.__contains__, field)
+
def testTopLevelExtensionsForOptionalScalar(self):
extendee_proto = unittest_pb2.TestAllExtensions()
extension = unittest_pb2.optional_int32_extension
self.assertTrue(not extendee_proto.HasExtension(extension))
+ self.assertNotIn(extension, extendee_proto.Extensions)
self.assertEqual(0, extendee_proto.Extensions[extension])
# As with normal scalar fields, just doing a read doesn't actually set the
# "has" bit.
self.assertTrue(not extendee_proto.HasExtension(extension))
+ self.assertNotIn(extension, extendee_proto.Extensions)
# Actually set the thing.
extendee_proto.Extensions[extension] = 23
self.assertEqual(23, extendee_proto.Extensions[extension])
self.assertTrue(extendee_proto.HasExtension(extension))
+ self.assertIn(extension, extendee_proto.Extensions)
# Ensure that clearing works as well.
extendee_proto.ClearExtension(extension)
self.assertEqual(0, extendee_proto.Extensions[extension])
self.assertTrue(not extendee_proto.HasExtension(extension))
+ self.assertNotIn(extension, extendee_proto.Extensions)
def testTopLevelExtensionsForRepeatedScalar(self):
extendee_proto = unittest_pb2.TestAllExtensions()
extension = unittest_pb2.repeated_string_extension
self.assertEqual(0, len(extendee_proto.Extensions[extension]))
+ self.assertNotIn(extension, extendee_proto.Extensions)
extendee_proto.Extensions[extension].append('foo')
self.assertEqual(['foo'], extendee_proto.Extensions[extension])
+ self.assertIn(extension, extendee_proto.Extensions)
string_list = extendee_proto.Extensions[extension]
extendee_proto.ClearExtension(extension)
self.assertEqual(0, len(extendee_proto.Extensions[extension]))
+ self.assertNotIn(extension, extendee_proto.Extensions)
self.assertTrue(string_list is not extendee_proto.Extensions[extension])
# Shouldn't be allowed to do Extensions[extension] = 'a'
self.assertRaises(TypeError, operator.setitem, extendee_proto.Extensions,
@@ -1236,13 +1273,16 @@
extendee_proto = unittest_pb2.TestAllExtensions()
extension = unittest_pb2.optional_foreign_message_extension
self.assertTrue(not extendee_proto.HasExtension(extension))
+ self.assertNotIn(extension, extendee_proto.Extensions)
self.assertEqual(0, extendee_proto.Extensions[extension].c)
# As with normal (non-extension) fields, merely reading from the
# thing shouldn't set the "has" bit.
self.assertTrue(not extendee_proto.HasExtension(extension))
+ self.assertNotIn(extension, extendee_proto.Extensions)
extendee_proto.Extensions[extension].c = 23
self.assertEqual(23, extendee_proto.Extensions[extension].c)
self.assertTrue(extendee_proto.HasExtension(extension))
+ self.assertIn(extension, extendee_proto.Extensions)
# Save a reference here.
foreign_message = extendee_proto.Extensions[extension]
extendee_proto.ClearExtension(extension)
@@ -1253,6 +1293,7 @@
self.assertEqual(42, foreign_message.c)
self.assertTrue(foreign_message.HasField('c'))
self.assertTrue(not extendee_proto.HasExtension(extension))
+ self.assertNotIn(extension, extendee_proto.Extensions)
# Shouldn't be allowed to do Extensions[extension] = 'a'
self.assertRaises(TypeError, operator.setitem, extendee_proto.Extensions,
extension, 'a')
@@ -1280,15 +1321,19 @@
# We just test the non-repeated case.
self.assertTrue(not extendee_proto.HasExtension(extension))
+ self.assertNotIn(extension, extendee_proto.Extensions)
required = extendee_proto.Extensions[extension]
self.assertEqual(0, required.a)
self.assertTrue(not extendee_proto.HasExtension(extension))
+ self.assertNotIn(extension, extendee_proto.Extensions)
required.a = 23
self.assertEqual(23, extendee_proto.Extensions[extension].a)
self.assertTrue(extendee_proto.HasExtension(extension))
+ self.assertIn(extension, extendee_proto.Extensions)
extendee_proto.ClearExtension(extension)
self.assertTrue(required is not extendee_proto.Extensions[extension])
self.assertTrue(not extendee_proto.HasExtension(extension))
+ self.assertNotIn(extension, extendee_proto.Extensions)
def testRegisteredExtensions(self):
pool = unittest_pb2.DESCRIPTOR.pool
@@ -1952,7 +1997,8 @@
# into separate TestCase classes.
-class TestAllTypesEqualityTest(BaseTestCase):
+@testing_refleaks.TestCase
+class TestAllTypesEqualityTest(unittest.TestCase):
def setUp(self):
self.first_proto = unittest_pb2.TestAllTypes()
@@ -1968,7 +2014,8 @@
self.assertEqual(self.first_proto, self.second_proto)
-class FullProtosEqualityTest(BaseTestCase):
+@testing_refleaks.TestCase
+class FullProtosEqualityTest(unittest.TestCase):
"""Equality tests using completely-full protos as a starting point."""
@@ -2054,7 +2101,8 @@
self.assertEqual(self.first_proto, self.second_proto)
-class ExtensionEqualityTest(BaseTestCase):
+@testing_refleaks.TestCase
+class ExtensionEqualityTest(unittest.TestCase):
def testExtensionEquality(self):
first_proto = unittest_pb2.TestAllExtensions()
@@ -2087,7 +2135,8 @@
self.assertEqual(first_proto, second_proto)
-class MutualRecursionEqualityTest(BaseTestCase):
+@testing_refleaks.TestCase
+class MutualRecursionEqualityTest(unittest.TestCase):
def testEqualityWithMutualRecursion(self):
first_proto = unittest_pb2.TestMutualRecursionA()
@@ -2099,7 +2148,8 @@
self.assertEqual(first_proto, second_proto)
-class ByteSizeTest(BaseTestCase):
+@testing_refleaks.TestCase
+class ByteSizeTest(unittest.TestCase):
def setUp(self):
self.proto = unittest_pb2.TestAllTypes()
@@ -2411,7 +2461,8 @@
# * Handling of empty submessages (with and without "has"
# bits set).
-class SerializationTest(BaseTestCase):
+@testing_refleaks.TestCase
+class SerializationTest(unittest.TestCase):
def testSerializeEmtpyMessage(self):
first_proto = unittest_pb2.TestAllTypes()
@@ -3004,7 +3055,8 @@
self.assertEqual(3, proto.repeated_int32[2])
-class OptionsTest(BaseTestCase):
+@testing_refleaks.TestCase
+class OptionsTest(unittest.TestCase):
def testMessageOptions(self):
proto = message_set_extensions_pb2.TestMessageSet()
@@ -3031,7 +3083,8 @@
-class ClassAPITest(BaseTestCase):
+@testing_refleaks.TestCase
+class ClassAPITest(unittest.TestCase):
@unittest.skipIf(
api_implementation.Type() == 'cpp' and api_implementation.Version() == 2,
diff --git a/python/google/protobuf/internal/testing_refleaks.py b/python/google/protobuf/internal/testing_refleaks.py
index 8ce0651..e448fce 100644
--- a/python/google/protobuf/internal/testing_refleaks.py
+++ b/python/google/protobuf/internal/testing_refleaks.py
@@ -69,8 +69,8 @@
pass
-class ReferenceLeakCheckerTestCase(unittest.TestCase):
- """A TestCase which runs tests multiple times, collecting reference counts."""
+class ReferenceLeakCheckerMixin(object):
+ """A mixin class for TestCase, which checks reference counts."""
NB_RUNS = 3
@@ -81,8 +81,8 @@
self._saved_pickle_registry = copyreg.dispatch_table.copy()
# Run the test twice, to warm up the instance attributes.
- super(ReferenceLeakCheckerTestCase, self).run(result=result)
- super(ReferenceLeakCheckerTestCase, self).run(result=result)
+ super(ReferenceLeakCheckerMixin, self).run(result=result)
+ super(ReferenceLeakCheckerMixin, self).run(result=result)
oldrefcount = 0
local_result = LocalTestResult(result)
@@ -90,7 +90,7 @@
refcount_deltas = []
for _ in range(self.NB_RUNS):
oldrefcount = self._getRefcounts()
- super(ReferenceLeakCheckerTestCase, self).run(result=local_result)
+ super(ReferenceLeakCheckerMixin, self).run(result=local_result)
newrefcount = self._getRefcounts()
refcount_deltas.append(newrefcount - oldrefcount)
print(refcount_deltas, self)
@@ -112,12 +112,19 @@
if hasattr(sys, 'gettotalrefcount'):
- BaseTestCase = ReferenceLeakCheckerTestCase
+
+ def TestCase(test_class):
+ new_bases = (ReferenceLeakCheckerMixin,) + test_class.__bases__
+ new_class = type(test_class)(
+ test_class.__name__, new_bases, dict(test_class.__dict__))
+ return new_class
SkipReferenceLeakChecker = unittest.skip
else:
# When PyDEBUG is not enabled, run the tests normally.
- BaseTestCase = unittest.TestCase
+
+ def TestCase(test_class):
+ return test_class
def SkipReferenceLeakChecker(reason):
del reason # Don't skip, so don't need a reason.
diff --git a/python/google/protobuf/internal/text_format_test.py b/python/google/protobuf/internal/text_format_test.py
index cdab1c6..3b0adcb 100755
--- a/python/google/protobuf/internal/text_format_test.py
+++ b/python/google/protobuf/internal/text_format_test.py
@@ -598,6 +598,12 @@
six.assertRaisesRegex(self, text_format.ParseError, (
r'1:1 : Message type "\w+.TestAllTypes" has no field named '
r'"unknown_field".'), text_format.Parse, text, message)
+ text = ('optional_int32: 123\n'
+ 'unknown_field: 8\n'
+ 'optional_nested_message { bb: 45 }')
+ text_format.Parse(text, message, allow_unknown_field=True)
+ self.assertEqual(message.optional_nested_message.bb, 45)
+ self.assertEqual(message.optional_int32, 123)
def testParseBadEnumValue(self, message_module):
message = message_module.TestAllTypes()
diff --git a/python/google/protobuf/internal/unknown_fields_test.py b/python/google/protobuf/internal/unknown_fields_test.py
index ab0260e..bcc4a46 100755
--- a/python/google/protobuf/internal/unknown_fields_test.py
+++ b/python/google/protobuf/internal/unknown_fields_test.py
@@ -53,10 +53,8 @@
from google.protobuf import descriptor
-BaseTestCase = testing_refleaks.BaseTestCase
-
-
-class UnknownFieldsTest(BaseTestCase):
+@testing_refleaks.TestCase
+class UnknownFieldsTest(unittest.TestCase):
def setUp(self):
self.descriptor = unittest_pb2.TestAllTypes.DESCRIPTOR
@@ -152,7 +150,8 @@
msg.map_int32_all_types[1].optional_nested_message.SerializeToString())
-class UnknownFieldsAccessorsTest(BaseTestCase):
+@testing_refleaks.TestCase
+class UnknownFieldsAccessorsTest(unittest.TestCase):
def setUp(self):
self.descriptor = unittest_pb2.TestAllTypes.DESCRIPTOR
@@ -348,7 +347,8 @@
self.assertEqual(message.SerializeToString(), self.all_fields_data)
-class UnknownEnumValuesTest(BaseTestCase):
+@testing_refleaks.TestCase
+class UnknownEnumValuesTest(unittest.TestCase):
def setUp(self):
self.descriptor = missing_enum_values_pb2.TestEnumValues.DESCRIPTOR
diff --git a/python/google/protobuf/message.py b/python/google/protobuf/message.py
index 8854c86..35ceccb 100755
--- a/python/google/protobuf/message.py
+++ b/python/google/protobuf/message.py
@@ -311,4 +311,9 @@
def __setstate__(self, state):
"""Support the pickle protocol."""
self.__init__()
- self.ParseFromString(state['serialized'])
+ serialized = state['serialized']
+ # On Python 3, using encoding='latin1' is required for unpickling
+ # protos pickled by Python 2.
+ if not isinstance(serialized, bytes):
+ serialized = serialized.encode('latin1')
+ self.ParseFromString(serialized)
diff --git a/python/google/protobuf/pyext/descriptor.cc b/python/google/protobuf/pyext/descriptor.cc
index fb55511..7102a94 100644
--- a/python/google/protobuf/pyext/descriptor.cc
+++ b/python/google/protobuf/pyext/descriptor.cc
@@ -394,11 +394,12 @@
return reinterpret_cast<PyObject*>(py_descriptor);
}
-static void Dealloc(PyBaseDescriptor* self) {
+static void Dealloc(PyObject* pself) {
+ PyBaseDescriptor* self = reinterpret_cast<PyBaseDescriptor*>(pself);
// Remove from interned dictionary
interned_descriptors->erase(self->descriptor);
Py_CLEAR(self->pool);
- Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
+ Py_TYPE(self)->tp_free(pself);
}
static int GcTraverse(PyObject* pself, visitproc visit, void* arg) {
@@ -1323,7 +1324,7 @@
static void Dealloc(PyFileDescriptor* self) {
Py_XDECREF(self->serialized_pb);
- descriptor::Dealloc(&self->base);
+ descriptor::Dealloc(reinterpret_cast<PyObject*>(self));
}
static PyObject* GetPool(PyFileDescriptor *self, void *closure) {
diff --git a/python/google/protobuf/pyext/extension_dict.cc b/python/google/protobuf/pyext/extension_dict.cc
index 7debe6f..35b6ec6 100644
--- a/python/google/protobuf/pyext/extension_dict.cc
+++ b/python/google/protobuf/pyext/extension_dict.cc
@@ -90,6 +90,47 @@
return size;
}
+struct ExtensionIterator {
+ PyObject_HEAD;
+ Py_ssize_t index;
+ std::vector<const FieldDescriptor*> fields;
+
+ // Owned reference, to keep the FieldDescriptors alive.
+ ExtensionDict* extension_dict;
+};
+
+PyObject* GetIter(PyObject* _self) {
+ ExtensionDict* self = reinterpret_cast<ExtensionDict*>(_self);
+
+ ScopedPyObjectPtr obj(PyType_GenericAlloc(&ExtensionIterator_Type, 0));
+ if (obj == nullptr) {
+ return PyErr_Format(PyExc_MemoryError,
+ "Could not allocate extension iterator");
+ }
+
+ ExtensionIterator* iter = reinterpret_cast<ExtensionIterator*>(obj.get());
+
+ // Call "placement new" to initialize. So the constructor of
+ // std::vector<...> fields will be called.
+ new (iter) ExtensionIterator;
+
+ self->parent->message->GetReflection()->ListFields(*self->parent->message,
+ &iter->fields);
+ iter->index = 0;
+ Py_INCREF(self);
+ iter->extension_dict = self;
+
+ return obj.release();
+}
+
+static void DeallocExtensionIterator(PyObject* _self) {
+ ExtensionIterator* self = reinterpret_cast<ExtensionIterator*>(_self);
+ self->fields.clear();
+ Py_XDECREF(self->extension_dict);
+ self->~ExtensionIterator();
+ Py_TYPE(_self)->tp_free(_self);
+}
+
PyObject* subscript(ExtensionDict* self, PyObject* key) {
const FieldDescriptor* descriptor = cmessage::GetExtensionDescriptor(key);
if (descriptor == NULL) {
@@ -108,20 +149,19 @@
self->parent->composite_fields->find(descriptor);
if (iterator != self->parent->composite_fields->end()) {
Py_INCREF(iterator->second);
- return iterator->second;
+ return iterator->second->AsPyObject();
}
if (descriptor->label() != FieldDescriptor::LABEL_REPEATED &&
descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
// TODO(plabatut): consider building the class on the fly!
- PyObject* sub_message = cmessage::InternalGetSubMessage(
+ ContainerBase* sub_message = cmessage::InternalGetSubMessage(
self->parent, descriptor);
if (sub_message == NULL) {
return NULL;
}
- Py_INCREF(sub_message);
(*self->parent->composite_fields)[descriptor] = sub_message;
- return sub_message;
+ return sub_message->AsPyObject();
}
if (descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
@@ -144,23 +184,21 @@
if (message_class == NULL) {
return NULL;
}
- PyObject* py_container = repeated_composite_container::NewContainer(
+ ContainerBase* py_container = repeated_composite_container::NewContainer(
self->parent, descriptor, message_class);
if (py_container == NULL) {
return NULL;
}
- Py_INCREF(py_container);
(*self->parent->composite_fields)[descriptor] = py_container;
- return py_container;
+ return py_container->AsPyObject();
} else {
- PyObject* py_container = repeated_scalar_container::NewContainer(
+ ContainerBase* py_container = repeated_scalar_container::NewContainer(
self->parent, descriptor);
if (py_container == NULL) {
return NULL;
}
- Py_INCREF(py_container);
(*self->parent->composite_fields)[descriptor] = py_container;
- return py_container;
+ return py_container->AsPyObject();
}
}
PyErr_SetString(PyExc_ValueError, "control reached unexpected line");
@@ -236,6 +274,35 @@
return PyFieldDescriptor_FromDescriptor(message_extension);
}
+static int Contains(PyObject* _self, PyObject* key) {
+ ExtensionDict* self = reinterpret_cast<ExtensionDict*>(_self);
+ const FieldDescriptor* field_descriptor =
+ cmessage::GetExtensionDescriptor(key);
+ if (field_descriptor == nullptr) {
+ return -1;
+ }
+
+ if (!field_descriptor->is_extension()) {
+ PyErr_Format(PyExc_KeyError, "%s is not an extension",
+ field_descriptor->full_name().c_str());
+ return -1;
+ }
+
+ const Message* message = self->parent->message;
+ const Reflection* reflection = message->GetReflection();
+ if (field_descriptor->is_repeated()) {
+ if (reflection->FieldSize(*message, field_descriptor) > 0) {
+ return 1;
+ }
+ } else {
+ if (reflection->HasField(*message, field_descriptor)) {
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
ExtensionDict* NewExtensionDict(CMessage *parent) {
ExtensionDict* self = reinterpret_cast<ExtensionDict*>(
PyType_GenericAlloc(&ExtensionDict_Type, 0));
@@ -248,7 +315,8 @@
return self;
}
-void dealloc(ExtensionDict* self) {
+void dealloc(PyObject* pself) {
+ ExtensionDict* self = reinterpret_cast<ExtensionDict*>(pself);
Py_CLEAR(self->parent);
Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
}
@@ -269,6 +337,16 @@
Py_RETURN_TRUE;
}
}
+static PySequenceMethods SeqMethods = {
+ (lenfunc)len, // sq_length
+ 0, // sq_concat
+ 0, // sq_repeat
+ 0, // sq_item
+ 0, // sq_slice
+ 0, // sq_ass_item
+ 0, // sq_ass_slice
+ (objobjproc)Contains, // sq_contains
+};
static PyMappingMethods MpMethods = {
(lenfunc)len, /* mp_length */
@@ -278,54 +356,119 @@
#define EDMETHOD(name, args, doc) { #name, (PyCFunction)name, args, doc }
static PyMethodDef Methods[] = {
- EDMETHOD(_FindExtensionByName, METH_O,
- "Finds an extension by name."),
- EDMETHOD(_FindExtensionByNumber, METH_O,
- "Finds an extension by field number."),
- { NULL, NULL }
+ EDMETHOD(_FindExtensionByName, METH_O, "Finds an extension by name."),
+ EDMETHOD(_FindExtensionByNumber, METH_O,
+ "Finds an extension by field number."),
+ {NULL, NULL},
};
} // namespace extension_dict
PyTypeObject ExtensionDict_Type = {
- PyVarObject_HEAD_INIT(&PyType_Type, 0)
- FULL_MODULE_NAME ".ExtensionDict", // tp_name
- sizeof(ExtensionDict), // tp_basicsize
- 0, // tp_itemsize
- (destructor)extension_dict::dealloc, // tp_dealloc
- 0, // tp_print
- 0, // tp_getattr
- 0, // tp_setattr
- 0, // tp_compare
- 0, // tp_repr
- 0, // tp_as_number
- 0, // tp_as_sequence
- &extension_dict::MpMethods, // tp_as_mapping
- PyObject_HashNotImplemented, // tp_hash
- 0, // tp_call
- 0, // tp_str
- 0, // tp_getattro
- 0, // tp_setattro
- 0, // tp_as_buffer
- Py_TPFLAGS_DEFAULT, // tp_flags
- "An extension dict", // tp_doc
- 0, // tp_traverse
- 0, // tp_clear
- (richcmpfunc)extension_dict::RichCompare, // tp_richcompare
- 0, // tp_weaklistoffset
- 0, // tp_iter
- 0, // tp_iternext
- extension_dict::Methods, // tp_methods
- 0, // tp_members
- 0, // tp_getset
- 0, // tp_base
- 0, // tp_dict
- 0, // tp_descr_get
- 0, // tp_descr_set
- 0, // tp_dictoffset
- 0, // tp_init
+ PyVarObject_HEAD_INIT(&PyType_Type, 0) //
+ FULL_MODULE_NAME ".ExtensionDict", // tp_name
+ sizeof(ExtensionDict), // tp_basicsize
+ 0, // tp_itemsize
+ (destructor)extension_dict::dealloc, // tp_dealloc
+ 0, // tp_print
+ 0, // tp_getattr
+ 0, // tp_setattr
+ 0, // tp_compare
+ 0, // tp_repr
+ 0, // tp_as_number
+ &extension_dict::SeqMethods, // tp_as_sequence
+ &extension_dict::MpMethods, // tp_as_mapping
+ PyObject_HashNotImplemented, // tp_hash
+ 0, // tp_call
+ 0, // tp_str
+ 0, // tp_getattro
+ 0, // tp_setattro
+ 0, // tp_as_buffer
+ Py_TPFLAGS_DEFAULT, // tp_flags
+ "An extension dict", // tp_doc
+ 0, // tp_traverse
+ 0, // tp_clear
+ (richcmpfunc)extension_dict::RichCompare, // tp_richcompare
+ 0, // tp_weaklistoffset
+ extension_dict::GetIter, // tp_iter
+ 0, // tp_iternext
+ extension_dict::Methods, // tp_methods
+ 0, // tp_members
+ 0, // tp_getset
+ 0, // tp_base
+ 0, // tp_dict
+ 0, // tp_descr_get
+ 0, // tp_descr_set
+ 0, // tp_dictoffset
+ 0, // tp_init
};
+PyObject* IterNext(PyObject* _self) {
+ extension_dict::ExtensionIterator* self =
+ reinterpret_cast<extension_dict::ExtensionIterator*>(_self);
+ Py_ssize_t total_size = self->fields.size();
+ Py_ssize_t index = self->index;
+ while (self->index < total_size) {
+ index = self->index;
+ ++self->index;
+ if (self->fields[index]->is_extension()) {
+ // With C++ descriptors, the field can always be retrieved, but for
+ // unknown extensions which have not been imported in Python code, there
+ // is no message class and we cannot retrieve the value.
+ // ListFields() has the same behavior.
+ if (self->fields[index]->message_type() != nullptr &&
+ message_factory::GetMessageClass(
+ cmessage::GetFactoryForMessage(self->extension_dict->parent),
+ self->fields[index]->message_type()) == nullptr) {
+ PyErr_Clear();
+ continue;
+ }
+
+ return PyFieldDescriptor_FromDescriptor(self->fields[index]);
+ }
+ }
+
+ return nullptr;
+}
+
+PyTypeObject ExtensionIterator_Type = {
+ PyVarObject_HEAD_INIT(&PyType_Type, 0) //
+ FULL_MODULE_NAME ".ExtensionIterator", // tp_name
+ sizeof(extension_dict::ExtensionIterator), // tp_basicsize
+ 0, // tp_itemsize
+ extension_dict::DeallocExtensionIterator, // tp_dealloc
+ 0, // tp_print
+ 0, // tp_getattr
+ 0, // tp_setattr
+ 0, // tp_compare
+ 0, // tp_repr
+ 0, // tp_as_number
+ 0, // tp_as_sequence
+ 0, // tp_as_mapping
+ 0, // tp_hash
+ 0, // tp_call
+ 0, // tp_str
+ 0, // tp_getattro
+ 0, // tp_setattro
+ 0, // tp_as_buffer
+ Py_TPFLAGS_DEFAULT, // tp_flags
+ "A scalar map iterator", // tp_doc
+ 0, // tp_traverse
+ 0, // tp_clear
+ 0, // tp_richcompare
+ 0, // tp_weaklistoffset
+ PyObject_SelfIter, // tp_iter
+ IterNext, // tp_iternext
+ 0, // tp_methods
+ 0, // tp_members
+ 0, // tp_getset
+ 0, // tp_base
+ 0, // tp_dict
+ 0, // tp_descr_get
+ 0, // tp_descr_set
+ 0, // tp_dictoffset
+ 0, // tp_init
+};
} // namespace python
} // namespace protobuf
} // namespace google
diff --git a/python/google/protobuf/pyext/extension_dict.h b/python/google/protobuf/pyext/extension_dict.h
index a7d6bb7..c9da443 100644
--- a/python/google/protobuf/pyext/extension_dict.h
+++ b/python/google/protobuf/pyext/extension_dict.h
@@ -56,6 +56,7 @@
} ExtensionDict;
extern PyTypeObject ExtensionDict_Type;
+extern PyTypeObject ExtensionIterator_Type;
namespace extension_dict {
diff --git a/python/google/protobuf/pyext/map_container.cc b/python/google/protobuf/pyext/map_container.cc
index d858402..bc59ae8 100644
--- a/python/google/protobuf/pyext/map_container.cc
+++ b/python/google/protobuf/pyext/map_container.cc
@@ -43,6 +43,7 @@
#include <google/protobuf/pyext/message.h>
#include <google/protobuf/pyext/repeated_composite_container.h>
#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+#include <google/protobuf/stubs/map_util.h>
#if PY_MAJOR_VERSION >= 3
#define PyInt_FromLong PyLong_FromLong
@@ -82,26 +83,23 @@
// We own a ref on this.
MapContainer* container;
- // We need to keep a ref on the Message* too, because
+ // We need to keep a ref on the parent Message too, because
// MapIterator::~MapIterator() accesses it. Normally this would be ok because
// the ref on container (above) would guarantee outlive semantics. However in
- // the case of ClearField(), InitializeAndCopyToParentContainer() resets the
- // message pointer (and the owner) to a different message, a copy of the
- // original. But our iterator still points to the original, which could now
- // get deleted before us.
+ // the case of ClearField(), the MapContainer points to a different message,
+ // a copy of the original. But our iterator still points to the original,
+ // which could now get deleted before us.
//
// To prevent this, we ensure that the Message will always stay alive as long
// as this iterator does. This is solely for the benefit of the MapIterator
// destructor -- we should never actually access the iterator in this state
// except to delete it.
- CMessage::OwnerRef owner;
-
+ CMessage* parent;
// The version of the map when we took the iterator to it.
//
// We store this so that if the map is modified during iteration we can throw
// an error.
uint64 version;
-
// True if the container is empty. We signal this separately to avoid calling
// any of the iteration methods, which are non-const.
bool empty;
@@ -109,7 +107,7 @@
Message* MapContainer::GetMutableMessage() {
cmessage::AssureWritable(parent);
- return const_cast<Message*>(message);
+ return parent->message;
}
// Consumes a reference on the Python string object.
@@ -315,7 +313,7 @@
Py_ssize_t MapReflectionFriend::Length(PyObject* _self) {
MapContainer* self = GetMap(_self);
- const google::protobuf::Message* message = self->message;
+ const google::protobuf::Message* message = self->parent->message;
return message->GetReflection()->MapSize(*message,
self->parent_field_descriptor);
}
@@ -343,7 +341,7 @@
MapContainer* self = GetMap(_self);
MapContainer* other_map = GetMap(arg);
Message* message = self->GetMutableMessage();
- const Message* other_message = other_map->message;
+ const Message* other_message = other_map->parent->message;
const Reflection* reflection = message->GetReflection();
const Reflection* other_reflection = other_message->GetReflection();
internal::MapFieldBase* field = reflection->MutableMapData(
@@ -359,7 +357,7 @@
PyObject* MapReflectionFriend::Contains(PyObject* _self, PyObject* key) {
MapContainer* self = GetMap(_self);
- const Message* message = self->message;
+ const Message* message = self->parent->message;
const Reflection* reflection = message->GetReflection();
MapKey map_key;
@@ -375,71 +373,26 @@
}
}
-// Initializes the underlying Message object of "to" so it becomes a new parent
-// map container, and copies all the values from "from" to it. A child map
-// container can be released by passing it as both from and to (e.g. making it
-// the recipient of the new parent message and copying the values from itself).
-// In fact, this is the only supported use at the moment.
-static int InitializeAndCopyToParentContainer(MapContainer* from,
- MapContainer* to) {
- // For now we require from == to, re-evaluate if we want to support deep copy
- // as in repeated_scalar_container.cc.
- GOOGLE_DCHECK(from == to);
- Message* new_message = from->message->New();
-
- if (MapReflectionFriend::Length(reinterpret_cast<PyObject*>(from)) > 0) {
- // A somewhat roundabout way of copying just one field from old_message to
- // new_message. This is the best we can do with what Reflection gives us.
- Message* mutable_old = from->GetMutableMessage();
- std::vector<const FieldDescriptor*> fields;
- fields.push_back(from->parent_field_descriptor);
-
- // Move the map field into the new message.
- mutable_old->GetReflection()->SwapFields(mutable_old, new_message, fields);
-
- // If/when we support from != to, this will be required also to copy the
- // map field back into the existing message:
- // mutable_old->MergeFrom(*new_message);
- }
-
- // If from == to this could delete old_message.
- to->owner.reset(new_message);
-
- to->parent = NULL;
- to->parent_field_descriptor = from->parent_field_descriptor;
- to->message = new_message;
-
- // Invalidate iterators, since they point to the old copy of the field.
- to->version++;
-
- return 0;
-}
-
-int MapContainer::Release() {
- return InitializeAndCopyToParentContainer(this, this);
-}
-
-
// ScalarMap ///////////////////////////////////////////////////////////////////
-PyObject *NewScalarMapContainer(
+MapContainer* NewScalarMapContainer(
CMessage* parent, const google::protobuf::FieldDescriptor* parent_field_descriptor) {
if (!CheckFieldBelongsToMessage(parent_field_descriptor, parent->message)) {
return NULL;
}
- ScopedPyObjectPtr obj(PyType_GenericAlloc(ScalarMapContainer_Type, 0));
- if (obj.get() == NULL) {
- return PyErr_Format(PyExc_RuntimeError,
- "Could not allocate new container.");
+ PyObject* obj(PyType_GenericAlloc(ScalarMapContainer_Type, 0));
+ if (obj == NULL) {
+ PyErr_Format(PyExc_RuntimeError,
+ "Could not allocate new container.");
+ return NULL;
}
- MapContainer* self = GetMap(obj.get());
+ MapContainer* self = GetMap(obj);
- self->message = parent->message;
+ Py_INCREF(parent);
self->parent = parent;
self->parent_field_descriptor = parent_field_descriptor;
- self->owner = parent->owner;
self->version = 0;
self->key_field_descriptor =
@@ -449,11 +402,12 @@
if (self->key_field_descriptor == NULL ||
self->value_field_descriptor == NULL) {
- return PyErr_Format(PyExc_KeyError,
- "Map entry descriptor did not have key/value fields");
+ PyErr_Format(PyExc_KeyError,
+ "Map entry descriptor did not have key/value fields");
+ return NULL;
}
- return obj.release();
+ return self;
}
PyObject* MapReflectionFriend::ScalarMapGetItem(PyObject* _self,
@@ -571,7 +525,7 @@
static void ScalarMapDealloc(PyObject* _self) {
MapContainer* self = GetMap(_self);
- self->owner.reset();
+ self->RemoveFromParentCache();
PyTypeObject *type = Py_TYPE(_self);
type->tp_free(_self);
if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
@@ -674,36 +628,15 @@
return reinterpret_cast<MessageMapContainer*>(obj);
}
-static PyObject* GetCMessage(MessageMapContainer* self, Message* message,
- bool insert_message_dict) {
+static PyObject* GetCMessage(MessageMapContainer* self, Message* message) {
// Get or create the CMessage object corresponding to this message.
- ScopedPyObjectPtr key(PyLong_FromVoidPtr(message));
- PyObject* ret = PyDict_GetItem(self->message_dict, key.get());
-
- if (ret == NULL) {
- CMessage* cmsg = cmessage::NewEmptyMessage(self->message_class);
- ret = reinterpret_cast<PyObject*>(cmsg);
-
- if (cmsg == NULL) {
- return NULL;
- }
- cmsg->owner = self->owner;
- cmsg->message = message;
- cmsg->parent = self->parent;
- if (insert_message_dict) {
- if (PyDict_SetItem(self->message_dict, key.get(), ret) < 0) {
- Py_DECREF(ret);
- return NULL;
- }
- }
- } else {
- Py_INCREF(ret);
- }
-
- return ret;
+ return self->parent
+ ->BuildSubMessageFromPointer(self->parent_field_descriptor, message,
+ self->message_class)
+ ->AsPyObject();
}
-PyObject* NewMessageMapContainer(
+MessageMapContainer* NewMessageMapContainer(
CMessage* parent, const google::protobuf::FieldDescriptor* parent_field_descriptor,
CMessageClass* message_class) {
if (!CheckFieldBelongsToMessage(parent_field_descriptor, parent->message)) {
@@ -712,16 +645,15 @@
PyObject* obj = PyType_GenericAlloc(MessageMapContainer_Type, 0);
if (obj == NULL) {
- return PyErr_Format(PyExc_RuntimeError,
- "Could not allocate new container.");
+ PyErr_SetString(PyExc_RuntimeError, "Could not allocate new container.");
+ return NULL;
}
MessageMapContainer* self = GetMessageMap(obj);
- self->message = parent->message;
+ Py_INCREF(parent);
self->parent = parent;
self->parent_field_descriptor = parent_field_descriptor;
- self->owner = parent->owner;
self->version = 0;
self->key_field_descriptor =
@@ -729,23 +661,18 @@
self->value_field_descriptor =
parent_field_descriptor->message_type()->FindFieldByName("value");
- self->message_dict = PyDict_New();
- if (self->message_dict == NULL) {
- return PyErr_Format(PyExc_RuntimeError,
- "Could not allocate message dict.");
- }
-
Py_INCREF(message_class);
self->message_class = message_class;
if (self->key_field_descriptor == NULL ||
self->value_field_descriptor == NULL) {
- Py_DECREF(obj);
- return PyErr_Format(PyExc_KeyError,
- "Map entry descriptor did not have key/value fields");
+ Py_DECREF(self);
+ PyErr_SetString(PyExc_KeyError,
+ "Map entry descriptor did not have key/value fields");
+ return NULL;
}
- return obj;
+ return self;
}
int MapReflectionFriend::MessageMapSetItem(PyObject* _self, PyObject* key,
@@ -777,22 +704,14 @@
MapValueRef value;
reflection->InsertOrLookupMapValue(message, self->parent_field_descriptor,
map_key, &value);
- ScopedPyObjectPtr key(PyLong_FromVoidPtr(value.MutableMessageValue()));
-
- PyObject* cmsg_value = PyDict_GetItem(self->message_dict, key.get());
- if (cmsg_value) {
- // Need to keep CMessage stay alive if it is still referenced after
- // deletion. Makes a new message and swaps values into CMessage
- // instead of just removing.
- CMessage* cmsg = reinterpret_cast<CMessage*>(cmsg_value);
- Message* msg = cmsg->message;
- cmsg->owner.reset(msg->New());
- cmsg->message = cmsg->owner.get();
- cmsg->parent = NULL;
- msg->GetReflection()->Swap(msg, cmsg->message);
- if (PyDict_DelItem(self->message_dict, key.get()) < 0) {
- return -1;
- }
+ Message* sub_message = value.MutableMessageValue();
+ // If there is a living weak reference to an item, we "Release" it,
+ // otherwise we just discard the C++ value.
+ if (CMessage* released =
+ self->parent->MaybeReleaseSubMessage(sub_message)) {
+ Message* msg = released->message;
+ released->message = msg->New();
+ msg->GetReflection()->Swap(msg, released->message);
}
// Delete key from map.
@@ -823,7 +742,7 @@
self->version++;
}
- return GetCMessage(self, value.MutableMessageValue(), true);
+ return GetCMessage(self, value.MutableMessageValue());
}
PyObject* MapReflectionFriend::MessageMapToStr(PyObject* _self) {
@@ -846,10 +765,7 @@
if (key == NULL) {
return NULL;
}
- // Do not insert the cmessage to self->message_dict because
- // the returned CMessage will not escape this function.
- value.reset(GetCMessage(
- self, it.MutableValueRef()->MutableMessageValue(), false));
+ value.reset(GetCMessage(self, it.MutableValueRef()->MutableMessageValue()));
if (value == NULL) {
return NULL;
}
@@ -886,8 +802,7 @@
static void MessageMapDealloc(PyObject* _self) {
MessageMapContainer* self = GetMessageMap(_self);
- self->owner.reset();
- Py_DECREF(self->message_dict);
+ self->RemoveFromParentCache();
Py_DECREF(self->message_class);
PyTypeObject *type = Py_TYPE(_self);
type->tp_free(_self);
@@ -1005,7 +920,8 @@
Py_INCREF(self);
iter->container = self;
iter->version = self->version;
- iter->owner = self->owner;
+ Py_INCREF(self->parent);
+ iter->parent = self->parent;
if (MapReflectionFriend::Length(_self) > 0) {
Message* message = self->GetMutableMessage();
@@ -1027,6 +943,10 @@
return PyErr_Format(PyExc_RuntimeError,
"Map modified during iteration.");
}
+ if (self->parent != self->container->parent) {
+ return PyErr_Format(PyExc_RuntimeError,
+ "Map cleared during iteration.");
+ }
if (self->iter.get() == NULL) {
return NULL;
@@ -1051,8 +971,8 @@
static void DeallocMapIterator(PyObject* _self) {
MapIterator* self = GetIter(_self);
self->iter.reset();
- self->owner.reset();
- Py_XDECREF(self->container);
+ Py_CLEAR(self->container);
+ Py_CLEAR(self->parent);
Py_TYPE(_self)->tp_free(_self);
}
diff --git a/python/google/protobuf/pyext/map_container.h b/python/google/protobuf/pyext/map_container.h
index 7e77b02..2c9b323 100644
--- a/python/google/protobuf/pyext/map_container.h
+++ b/python/google/protobuf/pyext/map_container.h
@@ -50,55 +50,21 @@
// This struct is used directly for ScalarMap, and is the base class of
// MessageMapContainer, which is used for MessageMap.
-struct MapContainer {
- PyObject_HEAD;
-
- // This is the top-level C++ Message object that owns the whole
- // proto tree. Every Python MapContainer holds a
- // reference to it in order to keep it alive as long as there's a
- // Python object that references any part of the tree.
- CMessage::OwnerRef owner;
-
- // Pointer to the C++ Message that contains this container. The
- // MapContainer does not own this pointer.
- const Message* message;
-
+struct MapContainer : public ContainerBase {
// Use to get a mutable message when necessary.
Message* GetMutableMessage();
- // Weak reference to a parent CMessage object (i.e. may be NULL.)
- //
- // Used to make sure all ancestors are also mutable when first
- // modifying the container.
- CMessage* parent;
-
- // Pointer to the parent's descriptor that describes this
- // field. Used together with the parent's message when making a
- // default message instance mutable.
- // The pointer is owned by the global DescriptorPool.
- const FieldDescriptor* parent_field_descriptor;
+ // Cache some descriptors, used to convert keys and values.
const FieldDescriptor* key_field_descriptor;
const FieldDescriptor* value_field_descriptor;
-
// We bump this whenever we perform a mutation, to invalidate existing
// iterators.
uint64 version;
-
- // Releases the messages in the container to a new message.
- //
- // Returns 0 on success, -1 on failure.
- int Release();
-
- // Set the owner field of self and any children of self.
- void SetOwner(const CMessage::OwnerRef& new_owner) { owner = new_owner; }
};
struct MessageMapContainer : public MapContainer {
// The type used to create new child messages.
CMessageClass* message_class;
-
- // A dict mapping Message* -> CMessage.
- PyObject* message_dict;
};
bool InitMapContainers();
@@ -109,12 +75,12 @@
// Builds a MapContainer object, from a parent message and a
// field descriptor.
-extern PyObject* NewScalarMapContainer(
+extern MapContainer* NewScalarMapContainer(
CMessage* parent, const FieldDescriptor* parent_field_descriptor);
// Builds a MessageMap object, from a parent message and a
// field descriptor.
-extern PyObject* NewMessageMapContainer(
+extern MessageMapContainer* NewMessageMapContainer(
CMessage* parent, const FieldDescriptor* parent_field_descriptor,
CMessageClass* message_class);
diff --git a/python/google/protobuf/pyext/message.cc b/python/google/protobuf/pyext/message.cc
index 9a3caa4..ae0971d 100644
--- a/python/google/protobuf/pyext/message.cc
+++ b/python/google/protobuf/pyext/message.cc
@@ -68,6 +68,7 @@
#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
#include <google/protobuf/util/message_differencer.h>
#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/stubs/map_util.h>
#include <google/protobuf/port_def.inc>
@@ -531,101 +532,10 @@
namespace cmessage {
int InternalReleaseFieldByDescriptor(
CMessage* self,
- const FieldDescriptor* field_descriptor,
- PyObject* composite_field);
+ const FieldDescriptor* field_descriptor);
} // namespace cmessage
// ---------------------------------------------------------------------
-// Visiting the composite children of a CMessage
-
-struct ChildVisitor {
- // Returns 0 on success, -1 on failure.
- int VisitRepeatedCompositeContainer(RepeatedCompositeContainer* container) {
- return 0;
- }
-
- // Returns 0 on success, -1 on failure.
- int VisitRepeatedScalarContainer(RepeatedScalarContainer* container) {
- return 0;
- }
-
- // Returns 0 on success, -1 on failure.
- int VisitMapContainer(MapContainer* container) {
- return 0;
- }
-
- // Returns 0 on success, -1 on failure.
- int VisitCMessage(CMessage* cmessage,
- const FieldDescriptor* field_descriptor) {
- return 0;
- }
-
- // Returns 0 on success, -1 on failure.
- int VisitUnknownFieldSet(PyUnknownFields* unknown_field_set) {
- return 0;
- }
-};
-
-// Apply a function to a composite field. Does nothing if child is of
-// non-composite type.
-template<class Visitor>
-static int VisitCompositeField(const FieldDescriptor* descriptor,
- PyObject* child,
- Visitor visitor) {
- if (descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
- if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
- if (descriptor->is_map()) {
- MapContainer* container = reinterpret_cast<MapContainer*>(child);
- if (visitor.VisitMapContainer(container) == -1) {
- return -1;
- }
- } else {
- RepeatedCompositeContainer* container =
- reinterpret_cast<RepeatedCompositeContainer*>(child);
- if (visitor.VisitRepeatedCompositeContainer(container) == -1)
- return -1;
- }
- } else {
- RepeatedScalarContainer* container =
- reinterpret_cast<RepeatedScalarContainer*>(child);
- if (visitor.VisitRepeatedScalarContainer(container) == -1)
- return -1;
- }
- } else if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
- CMessage* cmsg = reinterpret_cast<CMessage*>(child);
- if (visitor.VisitCMessage(cmsg, descriptor) == -1)
- return -1;
- }
- // The ExtensionDict might contain non-composite fields, which we
- // skip here.
- return 0;
-}
-
-// Visit each composite field and extension field of this CMessage.
-// Returns -1 on error and 0 on success.
-template<class Visitor>
-int ForEachCompositeField(CMessage* self, Visitor visitor) {
- // Visit normal fields.
- if (self->composite_fields) {
- for (CMessage::CompositeFieldsMap::iterator it =
- self->composite_fields->begin();
- it != self->composite_fields->end(); it++) {
- const FieldDescriptor* descriptor = it->first;
- PyObject* field = it->second;
- if (VisitCompositeField(descriptor, field, visitor) == -1) return -1;
- }
- }
-
- if (self->unknown_field_set) {
- PyUnknownFields* unknown_field_set =
- reinterpret_cast<PyUnknownFields*>(self->unknown_field_set);
- visitor.VisitUnknownFieldSet(unknown_field_set);
- }
-
- return 0;
-}
-
-// ---------------------------------------------------------------------
PyObject* EncodeError_class;
PyObject* DecodeError_class;
@@ -941,139 +851,79 @@
// Non-message fields don't need to be released.
return 0;
}
- if (cmessage->composite_fields) {
- CMessage::CompositeFieldsMap::iterator iterator =
- cmessage->composite_fields->find(existing_field);
- if (iterator != cmessage->composite_fields->end()) {
- if (InternalReleaseFieldByDescriptor(cmessage, existing_field,
- iterator->second) < 0) {
- return -1;
- }
- Py_DECREF(iterator->second);
- cmessage->composite_fields->erase(iterator);
- }
+ if (InternalReleaseFieldByDescriptor(cmessage, existing_field) < 0) {
+ return -1;
}
#endif
return 0;
}
+// After a Merge, visit every sub-message that was read-only, and
+// eventually update their pointer if the Merge operation modified them.
+int FixupMessageAfterMerge(CMessage* self) {
+ if (!self->composite_fields) {
+ return 0;
+ }
+ for (const auto& item : *self->composite_fields) {
+ const FieldDescriptor* descriptor = item.first;
+ if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
+ !descriptor->is_repeated()) {
+ CMessage* cmsg = reinterpret_cast<CMessage*>(item.second);
+ if (cmsg->read_only == false) {
+ return 0;
+ }
+ Message* message = self->message;
+ const Reflection* reflection = message->GetReflection();
+ if (reflection->HasField(*message, descriptor)) {
+ // Message used to be read_only, but is no longer. Get the new pointer
+ // and record it.
+ Message* mutable_message =
+ reflection->MutableMessage(message, descriptor, nullptr);
+ cmsg->message = mutable_message;
+ cmsg->read_only = false;
+ if (FixupMessageAfterMerge(cmsg) < 0) {
+ return -1;
+ }
+ }
+ }
+ }
+
+ return 0;
+}
+
// ---------------------------------------------------------------------
// Making a message writable
-static Message* GetMutableMessage(
- CMessage* parent,
- const FieldDescriptor* parent_field) {
- Message* parent_message = parent->message;
- const Reflection* reflection = parent_message->GetReflection();
- if (MaybeReleaseOverlappingOneofField(parent, parent_field) < 0) {
- return NULL;
- }
- return reflection->MutableMessage(
- parent_message, parent_field,
- GetFactoryForMessage(parent)->message_factory);
-}
-
-struct FixupMessageReference : public ChildVisitor {
- // message must outlive this object.
- explicit FixupMessageReference(Message* message) :
- message_(message) {}
-
- int VisitRepeatedCompositeContainer(RepeatedCompositeContainer* container) {
- container->message = message_;
- return 0;
- }
-
- int VisitRepeatedScalarContainer(RepeatedScalarContainer* container) {
- container->message = message_;
- return 0;
- }
-
- int VisitMapContainer(MapContainer* container) {
- container->message = message_;
- return 0;
- }
-
- int VisitUnknownFieldSet(PyUnknownFields* unknown_field_set) {
- const Reflection* reflection = message_->GetReflection();
- unknown_field_set->fields = &reflection->GetUnknownFields(*message_);
- return 0;
- }
-
- private:
- Message* message_;
-};
-
-// After a Merge, visit every sub-message that was read-only, and
-// eventually update their pointer if the Merge operation modified them.
-struct FixupMessageAfterMerge : public FixupMessageReference {
- explicit FixupMessageAfterMerge(CMessage* parent) :
- FixupMessageReference(parent->message),
- parent_cmessage(parent), message(parent->message) {}
-
- int VisitCMessage(CMessage* cmessage,
- const FieldDescriptor* field_descriptor) {
- if (cmessage->read_only == false) {
- return 0;
- }
- if (message->GetReflection()->HasField(*message, field_descriptor)) {
- Message* mutable_message = GetMutableMessage(
- parent_cmessage, field_descriptor);
- if (mutable_message == NULL) {
- return -1;
- }
- cmessage->message = mutable_message;
- cmessage->read_only = false;
- if (ForEachCompositeField(
- cmessage, FixupMessageAfterMerge(cmessage)) == -1) {
- return -1;
- }
- }
- return 0;
- }
-
- private:
- CMessage* parent_cmessage;
- Message* message;
-};
-
int AssureWritable(CMessage* self) {
if (self == NULL || !self->read_only) {
return 0;
}
- if (self->parent == NULL) {
- // If parent is NULL but we are trying to modify a read-only message, this
- // is a reference to a constant default instance that needs to be replaced
- // with a mutable top-level message.
- self->message = self->message->New();
- self->owner.reset(self->message);
- // Cascade the new owner to eventual children: even if this message is
- // empty, some submessages or repeated containers might exist already.
- SetOwner(self, self->owner);
- } else {
- // Otherwise, we need a mutable child message.
- if (AssureWritable(self->parent) == -1)
- return -1;
+ // Toplevel messages are always mutable.
+ GOOGLE_DCHECK(self->parent);
- // Make self->message writable.
- Message* mutable_message = GetMutableMessage(
- self->parent,
- self->parent_field_descriptor);
- if (mutable_message == NULL) {
- return -1;
- }
- self->message = mutable_message;
- }
- self->read_only = false;
-
- // When a CMessage is made writable its Message pointer is updated
- // to point to a new mutable Message. When that happens we need to
- // update any references to the old, read-only CMessage. There are
- // three places such references occur: RepeatedScalarContainer,
- // RepeatedCompositeContainer, and MapContainer.
- if (ForEachCompositeField(self, FixupMessageReference(self->message)) == -1)
+ if (AssureWritable(self->parent) == -1)
return -1;
+ // If this message is part of a oneof, there might be a field to release in
+ // the parent.
+ if (MaybeReleaseOverlappingOneofField(self->parent,
+ self->parent_field_descriptor) < 0) {
+ return -1;
+ }
+
+ // Make self->message writable.
+ Message* parent_message = self->parent->message;
+ const Reflection* reflection = parent_message->GetReflection();
+ Message* mutable_message = reflection->MutableMessage(
+ parent_message, self->parent_field_descriptor,
+ GetFactoryForMessage(self->parent)->message_factory);
+ if (mutable_message == NULL) {
+ return -1;
+ }
+ self->message = mutable_message;
+ self->read_only = false;
+
return 0;
}
@@ -1119,16 +969,16 @@
return value;
}
-// If cmessage_list is not NULL, this function releases values into the
-// container CMessages instead of just removing. Repeated composite container
-// needs to do this to make sure CMessages stay alive if they're still
-// referenced after deletion. Repeated scalar container doesn't need to worry.
-int InternalDeleteRepeatedField(
- Message* message,
+// Delete a slice from a repeated field.
+// The only way to remove items in C++ protos is to delete the last one,
+// so we swap items to move the deleted ones at the end, and then strip the
+// sequence.
+int DeleteRepeatedField(
+ CMessage* self,
const FieldDescriptor* field_descriptor,
- PyObject* slice,
- PyObject* cmessage_list) {
+ PyObject* slice) {
Py_ssize_t length, from, to, step, slice_length;
+ Message* message = self->message;
const Reflection* reflection = message->GetReflection();
int min, max;
length = reflection->FieldSize(*message, field_descriptor);
@@ -1178,39 +1028,31 @@
i += step;
}
+ // Swap elements so that items to delete are at the end.
to = 0;
for (i = 0; i < length; ++i) {
if (!to_delete[i]) {
if (i != to) {
reflection->SwapElements(message, field_descriptor, i, to);
- if (cmessage_list != NULL) {
- // If a list of cmessages is passed in (i.e. from a repeated
- // composite container), swap those as well to correspond to the
- // swaps in the underlying message so they're in the right order
- // when we start releasing.
- PyObject* tmp = PyList_GET_ITEM(cmessage_list, i);
- PyList_SET_ITEM(cmessage_list, i,
- PyList_GET_ITEM(cmessage_list, to));
- PyList_SET_ITEM(cmessage_list, to, tmp);
- }
}
++to;
}
}
- while (i > to) {
- if (cmessage_list == NULL) {
- reflection->RemoveLast(message, field_descriptor);
- } else {
- CMessage* last_cmessage = reinterpret_cast<CMessage*>(
- PyList_GET_ITEM(cmessage_list, PyList_GET_SIZE(cmessage_list) - 1));
- repeated_composite_container::ReleaseLastTo(
- message, field_descriptor, last_cmessage);
- if (PySequence_DelItem(cmessage_list, -1) < 0) {
- return -1;
+ // Remove items, starting from the end.
+ for (; length > to; length--) {
+ // If there is a living weak reference to a deleted item, we "Release" it,
+ if (field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
+ self->child_submessages) {
+ Message* sub_message = reflection->MutableRepeatedMessage(
+ message, field_descriptor, length - 1);
+ if (CMessage* released = self->MaybeReleaseSubMessage(sub_message)) {
+ released->message = reflection->ReleaseLast(message, field_descriptor);
+ continue;
}
}
- --i;
+ // No Python object refers to this item, discard the value.
+ reflection->RemoveLast(message, field_descriptor);
}
return 0;
@@ -1384,8 +1226,8 @@
return 0;
}
-// Allocates an incomplete Python Message: the caller must fill self->message,
-// self->owner and eventually self->parent.
+// Allocates an incomplete Python Message: the caller must fill self->message
+// and eventually self->parent.
CMessage* NewEmptyMessage(CMessageClass* type) {
CMessage* self = reinterpret_cast<CMessage*>(
PyType_GenericAlloc(&type->super.ht_type, 0));
@@ -1393,14 +1235,13 @@
return NULL;
}
- // Use "placement new" syntax to initialize the C++ object.
- new (&self->owner) CMessage::OwnerRef(NULL);
self->message = NULL;
self->parent = NULL;
self->parent_field_descriptor = NULL;
self->read_only = false;
self->composite_fields = NULL;
+ self->child_submessages = NULL;
self->unknown_field_set = NULL;
@@ -1420,9 +1261,10 @@
if (message_descriptor == NULL) {
return NULL;
}
- const Message* default_message = type->py_message_factory->message_factory
- ->GetPrototype(message_descriptor);
- if (default_message == NULL) {
+ const Message* prototype =
+ type->py_message_factory->message_factory->GetPrototype(
+ message_descriptor);
+ if (prototype == NULL) {
PyErr_SetString(PyExc_TypeError, message_descriptor->full_name().c_str());
return NULL;
}
@@ -1431,8 +1273,8 @@
if (self == NULL) {
return NULL;
}
- self->message = default_message->New();
- self->owner.reset(self->message);
+ self->message = prototype->New();
+ self->parent = nullptr; // This message owns its data.
return reinterpret_cast<PyObject*>(self);
}
@@ -1444,63 +1286,39 @@
// ---------------------------------------------------------------------
// Deallocating a CMessage
-//
-// Deallocating a CMessage requires that we clear any weak references
-// from children to the message being deallocated.
-
-// Clear the weak reference from the child to the parent.
-struct ClearWeakReferences : public ChildVisitor {
- int VisitRepeatedCompositeContainer(RepeatedCompositeContainer* container) {
- container->parent = NULL;
- // The elements in the container have the same parent as the
- // container itself, so NULL out that pointer as well.
- const Py_ssize_t n = PyList_GET_SIZE(container->child_messages);
- for (Py_ssize_t i = 0; i < n; ++i) {
- CMessage* child_cmessage = reinterpret_cast<CMessage*>(
- PyList_GET_ITEM(container->child_messages, i));
- child_cmessage->parent = NULL;
- }
- return 0;
- }
-
- int VisitRepeatedScalarContainer(RepeatedScalarContainer* container) {
- container->parent = NULL;
- return 0;
- }
-
- int VisitMapContainer(MapContainer* container) {
- container->parent = NULL;
- return 0;
- }
-
- int VisitCMessage(CMessage* cmessage,
- const FieldDescriptor* field_descriptor) {
- cmessage->parent = NULL;
- return 0;
- }
-};
static void Dealloc(CMessage* self) {
if (self->weakreflist) {
PyObject_ClearWeakRefs(reinterpret_cast<PyObject*>(self));
}
- // Null out all weak references from children to this message.
- GOOGLE_CHECK_EQ(0, ForEachCompositeField(self, ClearWeakReferences()));
-
- if (self->composite_fields) {
- for (CMessage::CompositeFieldsMap::iterator it =
- self->composite_fields->begin();
- it != self->composite_fields->end(); it++) {
- Py_DECREF(it->second);
- }
- delete self->composite_fields;
- }
+ // At this point all dependent objects have been removed.
+ GOOGLE_DCHECK(!self->child_submessages || self->child_submessages->empty());
+ GOOGLE_DCHECK(!self->composite_fields || self->composite_fields->empty());
+ delete self->child_submessages;
+ delete self->composite_fields;
if (self->unknown_field_set) {
unknown_fields::Clear(
reinterpret_cast<PyUnknownFields*>(self->unknown_field_set));
- Py_CLEAR(self->unknown_field_set);
}
- self->owner.~ThreadUnsafeSharedPtr<Message>();
+
+ CMessage* parent = self->parent;
+ if (!parent) {
+ // No parent, we own the message.
+ delete self->message;
+ } else if (parent->AsPyObject() == Py_None) {
+ // Message owned externally: Nothing to dealloc
+ Py_CLEAR(self->parent);
+ } else {
+ // Clear this message from its parent's map.
+ if (self->parent_field_descriptor->is_repeated()) {
+ if (parent->child_submessages)
+ parent->child_submessages->erase(self->message);
+ } else {
+ if (parent->composite_fields)
+ parent->composite_fields->erase(self->parent_field_descriptor);
+ }
+ Py_CLEAR(self->parent);
+ }
Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
}
@@ -1652,17 +1470,8 @@
if (descriptor == NULL) {
return NULL;
}
- if (self->composite_fields != NULL) {
- CMessage::CompositeFieldsMap::iterator iterator =
- self->composite_fields->find(descriptor);
- if (iterator != self->composite_fields->end()) {
- if (InternalReleaseFieldByDescriptor(self, descriptor,
- iterator->second) < 0) {
- return NULL;
- }
- Py_DECREF(iterator->second);
- self->composite_fields->erase(iterator);
- }
+ if (InternalReleaseFieldByDescriptor(self, descriptor) < 0) {
+ return NULL;
}
return ClearFieldByDescriptor(self, descriptor);
}
@@ -1680,141 +1489,107 @@
//
// The Python API's ClearField() and Clear() methods behave
// differently than their C++ counterparts. While the C++ versions
-// clears the children the Python versions detaches the children,
+// clears the children, the Python versions detaches the children,
// without touching their content. This impedance mismatch causes
// some complexity in the implementation, which is captured in this
// section.
//
-// When a CMessage field is cleared we need to:
+// When one or multiple fields are cleared we need to:
//
-// * Release the Message used as the backing store for the CMessage
-// from its parent.
+// * Gather all child objects that need to be detached from the message.
+// In composite_fields and child_submessages.
//
-// * Change the owner field of the released CMessage and all of its
-// children to point to the newly released Message.
+// * Create a new Python message of the same kind. Use SwapFields() to move
+// data from the original message.
//
-// * Clear the weak references from the released CMessage to the
-// parent.
-//
-// When a RepeatedCompositeContainer field is cleared we need to:
-//
-// * Release all the Message used as the backing store for the
-// CMessages stored in the container.
-//
-// * Change the owner field of all the released CMessage and all of
-// their children to point to the newly released Messages.
-//
-// * Clear the weak references from the released container to the
-// parent.
+// * Change the parent of all child objects: update their strong reference
+// to their parent, and move their presence in composite_fields and
+// child_submessages.
-class SetOwnerVisitor : public ChildVisitor {
- public:
- // new_owner must outlive this object.
- explicit SetOwnerVisitor(const CMessage::OwnerRef& new_owner)
- : new_owner_(new_owner) {}
+// ---------------------------------------------------------------------
+// Release a composite child of a CMessage
- int VisitRepeatedCompositeContainer(RepeatedCompositeContainer* container) {
- repeated_composite_container::SetOwner(container, new_owner_);
+static int InternalReparentFields(
+ CMessage* self, const std::vector<CMessage*>& messages_to_release,
+ const std::vector<ContainerBase*>& containers_to_release) {
+ if (messages_to_release.empty() && containers_to_release.empty()) {
return 0;
}
- int VisitRepeatedScalarContainer(RepeatedScalarContainer* container) {
- repeated_scalar_container::SetOwner(container, new_owner_);
- return 0;
- }
-
- int VisitMapContainer(MapContainer* container) {
- container->SetOwner(new_owner_);
- return 0;
- }
-
- int VisitCMessage(CMessage* cmessage,
- const FieldDescriptor* field_descriptor) {
- return SetOwner(cmessage, new_owner_);
- }
-
- private:
- const CMessage::OwnerRef& new_owner_;
-};
-
-// Change the owner of this CMessage and all its children, recursively.
-int SetOwner(CMessage* self, const CMessage::OwnerRef& new_owner) {
- self->owner = new_owner;
- if (ForEachCompositeField(self, SetOwnerVisitor(new_owner)) == -1)
+ // Move all the passed sub_messages to another message.
+ CMessage* new_message = cmessage::NewEmptyMessage(self->GetMessageClass());
+ if (new_message == nullptr) {
return -1;
+ }
+ new_message->message = self->message->New();
+ ScopedPyObjectPtr holder(reinterpret_cast<PyObject*>(new_message));
+ new_message->child_submessages = new CMessage::SubMessagesMap();
+ new_message->composite_fields = new CMessage::CompositeFieldsMap();
+ std::set<const FieldDescriptor*> fields_to_swap;
+
+ // In case this the removed fields are the last reference to a message, keep
+ // a reference.
+ Py_INCREF(self);
+
+ for (const auto& to_release : messages_to_release) {
+ fields_to_swap.insert(to_release->parent_field_descriptor);
+ // Reparent
+ Py_INCREF(new_message);
+ Py_DECREF(to_release->parent);
+ to_release->parent = new_message;
+ self->child_submessages->erase(to_release->message);
+ new_message->child_submessages->emplace(to_release->message, to_release);
+ }
+
+ for (const auto& to_release : containers_to_release) {
+ fields_to_swap.insert(to_release->parent_field_descriptor);
+ Py_INCREF(new_message);
+ Py_DECREF(to_release->parent);
+ to_release->parent = new_message;
+ self->composite_fields->erase(to_release->parent_field_descriptor);
+ new_message->composite_fields->emplace(to_release->parent_field_descriptor,
+ to_release);
+ }
+
+ self->message->GetReflection()->SwapFields(
+ self->message, new_message->message,
+ std::vector<const FieldDescriptor*>(fields_to_swap.begin(),
+ fields_to_swap.end()));
+
+ // This might delete the Python message completely if all children were moved.
+ Py_DECREF(self);
+
return 0;
}
-// Releases the message specified by 'field' and returns the
-// pointer. If the field does not exist a new message is created using
-// 'descriptor'. The caller takes ownership of the returned pointer.
-Message* ReleaseMessage(CMessage* self,
- const Descriptor* descriptor,
- const FieldDescriptor* field_descriptor) {
- MessageFactory* message_factory = GetFactoryForMessage(self)->message_factory;
- Message* released_message = self->message->GetReflection()->ReleaseMessage(
- self->message, field_descriptor, message_factory);
- // ReleaseMessage will return NULL which differs from
- // child_cmessage->message, if the field does not exist. In this case,
- // the latter points to the default instance via a const_cast<>, so we
- // have to reset it to a new mutable object since we are taking ownership.
- if (released_message == NULL) {
- const Message* prototype = message_factory->GetPrototype(descriptor);
- GOOGLE_DCHECK(prototype != NULL);
- released_message = prototype->New();
- }
-
- return released_message;
-}
-
-int ReleaseSubMessage(CMessage* self,
- const FieldDescriptor* field_descriptor,
- CMessage* child_cmessage) {
- // Release the Message
- CMessage::OwnerRef released_message(ReleaseMessage(
- self, child_cmessage->message->GetDescriptor(), field_descriptor));
- child_cmessage->message = released_message.get();
- child_cmessage->owner.swap(released_message);
- child_cmessage->parent = NULL;
- child_cmessage->parent_field_descriptor = NULL;
- child_cmessage->read_only = false;
- return ForEachCompositeField(child_cmessage,
- SetOwnerVisitor(child_cmessage->owner));
-}
-
-struct ReleaseChild : public ChildVisitor {
- // message must outlive this object.
- explicit ReleaseChild(CMessage* parent) :
- parent_(parent) {}
-
- int VisitRepeatedCompositeContainer(RepeatedCompositeContainer* container) {
- return repeated_composite_container::Release(container);
- }
-
- int VisitRepeatedScalarContainer(RepeatedScalarContainer* container) {
- return repeated_scalar_container::Release(container);
- }
-
- int VisitMapContainer(MapContainer* container) {
- return container->Release();
- }
-
- int VisitCMessage(CMessage* cmessage,
- const FieldDescriptor* field_descriptor) {
- return ReleaseSubMessage(parent_, field_descriptor, cmessage);
- }
-
- CMessage* parent_;
-};
-
int InternalReleaseFieldByDescriptor(
CMessage* self,
- const FieldDescriptor* field_descriptor,
- PyObject* composite_field) {
- return VisitCompositeField(
- field_descriptor,
- composite_field,
- ReleaseChild(self));
+ const FieldDescriptor* field_descriptor) {
+ if (!field_descriptor->is_repeated() &&
+ field_descriptor->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
+ // Single scalars are not in any cache.
+ return 0;
+ }
+ std::vector<CMessage*> messages_to_release;
+ std::vector<ContainerBase*> containers_to_release;
+ if (self->child_submessages && field_descriptor->is_repeated() &&
+ field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+ for (const auto& child_item : *self->child_submessages) {
+ if (child_item.second->parent_field_descriptor == field_descriptor) {
+ messages_to_release.push_back(child_item.second);
+ }
+ }
+ }
+ if (self->composite_fields) {
+ CMessage::CompositeFieldsMap::iterator it =
+ self->composite_fields->find(field_descriptor);
+ if (it != self->composite_fields->end()) {
+ containers_to_release.push_back(it->second);
+ }
+ }
+
+ return InternalReparentFields(self, messages_to_release,
+ containers_to_release);
}
PyObject* ClearFieldByDescriptor(
@@ -1864,37 +1639,35 @@
arg = arg_in_oneof.get();
}
- if (self->composite_fields) {
- CMessage::CompositeFieldsMap::iterator iterator =
- self->composite_fields->find(field_descriptor);
- if (iterator != self->composite_fields->end()) {
- if (InternalReleaseFieldByDescriptor(self, field_descriptor,
- iterator->second) < 0) {
- return NULL;
- }
- Py_DECREF(iterator->second);
- self->composite_fields->erase(iterator);
- }
+ if (InternalReleaseFieldByDescriptor(self, field_descriptor) < 0) {
+ return NULL;
}
return ClearFieldByDescriptor(self, field_descriptor);
}
PyObject* Clear(CMessage* self) {
AssureWritable(self);
- if (ForEachCompositeField(self, ReleaseChild(self)) == -1)
- return NULL;
- if (self->composite_fields) {
- for (CMessage::CompositeFieldsMap::iterator it =
- self->composite_fields->begin();
- it != self->composite_fields->end(); it++) {
- Py_DECREF(it->second);
+ // Detach all current fields of this message
+ std::vector<CMessage*> messages_to_release;
+ std::vector<ContainerBase*> containers_to_release;
+ if (self->child_submessages) {
+ for (const auto& item : *self->child_submessages) {
+ messages_to_release.push_back(item.second);
}
- self->composite_fields->clear();
+ }
+ if (self->composite_fields) {
+ for (const auto& item : *self->composite_fields) {
+ containers_to_release.push_back(item.second);
+ }
+ }
+ if (InternalReparentFields(self, messages_to_release, containers_to_release) <
+ 0) {
+ return NULL;
}
if (self->unknown_field_set) {
unknown_fields::Clear(
reinterpret_cast<PyUnknownFields*>(self->unknown_field_set));
- Py_CLEAR(self->unknown_field_set);
+ self->unknown_field_set = nullptr;
}
self->message->Clear();
Py_RETURN_NONE;
@@ -2075,7 +1848,7 @@
self->message->MergeFrom(*other_message->message);
// Child message might be lazily created before MergeFrom. Make sure they
// are mutable at this point if child messages are really created.
- if (ForEachCompositeField(self, FixupMessageAfterMerge(self)) == -1) {
+ if (FixupMessageAfterMerge(self) < 0) {
return NULL;
}
@@ -2168,7 +1941,7 @@
bool success = self->message->MergePartialFromCodedStream(&input);
// Child message might be lazily created before MergeFrom. Make sure they
// are mutable at this point if child messages are really created.
- if (ForEachCompositeField(self, FixupMessageAfterMerge(self)) == -1) {
+ if (FixupMessageAfterMerge(self) < 0) {
return NULL;
}
@@ -2458,7 +2231,7 @@
return result;
}
-PyObject* InternalGetSubMessage(
+CMessage* InternalGetSubMessage(
CMessage* self, const FieldDescriptor* field_descriptor) {
const Reflection* reflection = self->message->GetReflection();
PyMessageFactory* factory = GetFactoryForMessage(self);
@@ -2467,7 +2240,7 @@
CMessageClass* message_class = message_factory::GetOrCreateMessageClass(
factory, field_descriptor->message_type());
- ScopedPyObjectPtr message_class_handler(
+ ScopedPyObjectPtr message_class_owner(
reinterpret_cast<PyObject*>(message_class));
if (message_class == NULL) {
return NULL;
@@ -2478,13 +2251,12 @@
return NULL;
}
- cmsg->owner = self->owner;
+ Py_INCREF(self);
cmsg->parent = self;
cmsg->parent_field_descriptor = field_descriptor;
cmsg->read_only = !reflection->HasField(*self->message, field_descriptor);
cmsg->message = const_cast<Message*>(&sub_message);
-
- return reinterpret_cast<PyObject*>(cmsg);
+ return cmsg;
}
int InternalSetNonOneofScalar(
@@ -2680,6 +2452,13 @@
if (serialized == NULL) {
return NULL;
}
+#if PY_MAJOR_VERSION >= 3
+ // On Python 3, using encoding='latin1' is required for unpickling
+ // protos pickled by Python 2.
+ if (!PyBytes_Check(serialized)) {
+ serialized = PyUnicode_AsEncodedString(serialized, "latin1", NULL);
+ }
+#endif
if (ScopedPyObjectPtr(ParseFromString(self, serialized)) == NULL) {
return NULL;
}
@@ -2719,8 +2498,9 @@
static PyObject* UnknownFieldSet(CMessage* self) {
if (self->unknown_field_set == NULL) {
self->unknown_field_set = unknown_fields::NewPyUnknownFields(self);
+ } else {
+ Py_INCREF(self->unknown_field_set);
}
- Py_INCREF(self->unknown_field_set);
return self->unknown_field_set;
}
@@ -2805,17 +2585,23 @@
{ NULL, NULL}
};
-static bool SetCompositeField(CMessage* self, const FieldDescriptor* field,
- PyObject* value) {
+bool SetCompositeField(CMessage* self, const FieldDescriptor* field,
+ ContainerBase* value) {
if (self->composite_fields == NULL) {
self->composite_fields = new CMessage::CompositeFieldsMap();
}
- Py_INCREF(value);
- Py_XDECREF((*self->composite_fields)[field]);
(*self->composite_fields)[field] = value;
return true;
}
+bool SetSubmessage(CMessage* self, CMessage* submessage) {
+ if (self->child_submessages == NULL) {
+ self->child_submessages = new CMessage::SubMessagesMap();
+ }
+ (*self->child_submessages)[submessage->message] = submessage;
+ return true;
+}
+
PyObject* GetAttr(PyObject* pself, PyObject* name) {
CMessage* self = reinterpret_cast<CMessage*>(pself);
PyObject* result = PyObject_GenericGetAttr(
@@ -2838,9 +2624,9 @@
CMessage::CompositeFieldsMap::iterator it =
self->composite_fields->find(field_descriptor);
if (it != self->composite_fields->end()) {
- PyObject* value = it->second;
+ ContainerBase* value = it->second;
Py_INCREF(value);
- return value;
+ return value->AsPyObject();
}
}
@@ -2852,8 +2638,13 @@
return NULL;
}
+ if (!field_descriptor->is_repeated() &&
+ field_descriptor->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
+ return InternalGetScalar(self->message, field_descriptor);
+ }
+
+ ContainerBase* py_container = nullptr;
if (field_descriptor->is_map()) {
- PyObject* py_container = NULL;
const Descriptor* entry_type = field_descriptor->message_type();
const FieldDescriptor* value_type = entry_type->FindFieldByName("value");
if (value_type->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
@@ -2867,18 +2658,7 @@
} else {
py_container = NewScalarMapContainer(self, field_descriptor);
}
- if (py_container == NULL) {
- return NULL;
- }
- if (!SetCompositeField(self, field_descriptor, py_container)) {
- Py_DECREF(py_container);
- return NULL;
- }
- return py_container;
- }
-
- if (field_descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
- PyObject* py_container = NULL;
+ } else if (field_descriptor->is_repeated()) {
if (field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
CMessageClass* message_class = message_factory::GetMessageClass(
GetFactoryForMessage(self), field_descriptor->message_type());
@@ -2888,32 +2668,24 @@
py_container = repeated_composite_container::NewContainer(
self, field_descriptor, message_class);
} else {
- py_container = repeated_scalar_container::NewContainer(
- self, field_descriptor);
+ py_container =
+ repeated_scalar_container::NewContainer(self, field_descriptor);
}
- if (py_container == NULL) {
- return NULL;
- }
- if (!SetCompositeField(self, field_descriptor, py_container)) {
- Py_DECREF(py_container);
- return NULL;
- }
- return py_container;
+ } else if (field_descriptor->cpp_type() ==
+ FieldDescriptor::CPPTYPE_MESSAGE) {
+ py_container = InternalGetSubMessage(self, field_descriptor);
+ } else {
+ PyErr_SetString(PyExc_SystemError, "Should never happen");
}
- if (field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
- PyObject* sub_message = InternalGetSubMessage(self, field_descriptor);
- if (sub_message == NULL) {
- return NULL;
- }
- if (!SetCompositeField(self, field_descriptor, sub_message)) {
- Py_DECREF(sub_message);
- return NULL;
- }
- return sub_message;
+ if (py_container == NULL) {
+ return NULL;
}
-
- return InternalGetScalar(self->message, field_descriptor);
+ if (!SetCompositeField(self, field_descriptor, py_container)) {
+ Py_DECREF(py_container);
+ return NULL;
+ }
+ return py_container->AsPyObject();
}
int SetFieldValue(CMessage* self, const FieldDescriptor* field_descriptor,
@@ -2941,8 +2713,82 @@
return InternalSetScalar(self, field_descriptor, value);
}
}
+
} // namespace cmessage
+// All containers which are not messages:
+// - Make a new parent message
+// - Copy the field
+// - return the field.
+PyObject* ContainerBase::DeepCopy() {
+ CMessage* new_parent =
+ cmessage::NewEmptyMessage(this->parent->GetMessageClass());
+ new_parent->message = this->parent->message->New();
+
+ // Copy the map field into the new message.
+ this->parent->message->GetReflection()->SwapFields(
+ this->parent->message, new_parent->message,
+ {this->parent_field_descriptor});
+ this->parent->message->MergeFrom(*new_parent->message);
+
+ PyObject* result =
+ cmessage::GetFieldValue(new_parent, this->parent_field_descriptor);
+ Py_DECREF(new_parent);
+ return result;
+}
+
+void ContainerBase::RemoveFromParentCache() {
+ CMessage* parent = this->parent;
+ if (parent) {
+ if (parent->composite_fields)
+ parent->composite_fields->erase(this->parent_field_descriptor);
+ Py_CLEAR(parent);
+ }
+}
+
+CMessage* CMessage::BuildSubMessageFromPointer(
+ const FieldDescriptor* field_descriptor, Message* sub_message,
+ CMessageClass* message_class) {
+ if (!this->child_submessages) {
+ this->child_submessages = new CMessage::SubMessagesMap();
+ }
+ CMessage* cmsg = FindPtrOrNull(
+ *this->child_submessages, sub_message);
+ if (cmsg) {
+ Py_INCREF(cmsg);
+ } else {
+ cmsg = cmessage::NewEmptyMessage(message_class);
+
+ if (cmsg == NULL) {
+ return NULL;
+ }
+ cmsg->message = sub_message;
+ Py_INCREF(this);
+ cmsg->parent = this;
+ cmsg->parent_field_descriptor = field_descriptor;
+ cmessage::SetSubmessage(this, cmsg);
+ }
+ return cmsg;
+}
+
+CMessage* CMessage::MaybeReleaseSubMessage(Message* sub_message) {
+ if (!this->child_submessages) {
+ return nullptr;
+ }
+ CMessage* released = FindPtrOrNull(
+ *this->child_submessages, sub_message);
+ if (!released) {
+ return nullptr;
+ }
+ // The target message will now own its content.
+ Py_CLEAR(released->parent);
+ released->parent_field_descriptor = nullptr;
+ released->read_only = false;
+ // Delete it from the cache.
+ this->child_submessages->erase(sub_message);
+ return released;
+}
+
static CMessageClass _CMessage_Type = { { {
PyVarObject_HEAD_INIT(&_CMessageClass_Type, 0)
FULL_MODULE_NAME ".CMessage", // tp_name
@@ -3023,10 +2869,11 @@
PyErr_SetString(PyExc_TypeError, "Not a Message instance");
return NULL;
}
-
-
CMessage* cmsg = reinterpret_cast<CMessage*>(msg);
- if (cmsg->composite_fields && !cmsg->composite_fields->empty()) {
+
+
+ if ((cmsg->composite_fields && !cmsg->composite_fields->empty()) ||
+ (cmsg->child_submessages && !cmsg->child_submessages->empty())) {
// There is currently no way of accurately syncing arbitrary changes to
// the underlying C++ message back to the CMessage (e.g. removed repeated
// composite containers). We only allow direct mutation of the underlying
@@ -3040,6 +2887,34 @@
return cmsg->message;
}
+PyObject* PyMessage_NewMessageOwnedExternally(Message* message,
+ PyObject* message_factory) {
+ if (message_factory) {
+ PyErr_SetString(PyExc_NotImplementedError,
+ "Default message_factory=NULL is the only supported value");
+ return NULL;
+ }
+ if (message->GetReflection()->GetMessageFactory() !=
+ MessageFactory::generated_factory()) {
+ PyErr_SetString(PyExc_TypeError,
+ "Message pointer was not created from the default factory");
+ return NULL;
+ }
+
+ CMessageClass* message_class = message_factory::GetOrCreateMessageClass(
+ GetDefaultDescriptorPool()->py_message_factory, message->GetDescriptor());
+
+ CMessage* self = cmessage::NewEmptyMessage(message_class);
+ if (self == NULL) {
+ return NULL;
+ }
+ Py_DECREF(message_class);
+ self->message = message;
+ Py_INCREF(Py_None);
+ self->parent = reinterpret_cast<CMessage*>(Py_None);
+ return self->AsPyObject();
+}
+
void InitGlobals() {
// TODO(gps): Check all return values in this function for NULL and propagate
// the error (MemoryError) on up to result in an import failure. These should
@@ -3168,6 +3043,11 @@
PyModule_AddObject(
m, "ExtensionDict",
reinterpret_cast<PyObject*>(&ExtensionDict_Type));
+ if (PyType_Ready(&ExtensionIterator_Type) < 0) {
+ return false;
+ }
+ PyModule_AddObject(m, "ExtensionIterator",
+ reinterpret_cast<PyObject*>(&ExtensionIterator_Type));
// Expose the DescriptorPool used to hold all descriptors added from generated
// pb2.py files.
diff --git a/python/google/protobuf/pyext/message.h b/python/google/protobuf/pyext/message.h
index 64aafaf..55be297 100644
--- a/python/google/protobuf/pyext/message.h
+++ b/python/google/protobuf/pyext/message.h
@@ -41,7 +41,6 @@
#include <unordered_map>
#include <google/protobuf/stubs/common.h>
-#include <google/protobuf/pyext/thread_unsafe_shared_ptr.h>
namespace google {
namespace protobuf {
@@ -57,39 +56,51 @@
struct ExtensionDict;
struct PyMessageFactory;
+struct CMessageClass;
-typedef struct CMessage {
+// Most of the complexity of the Message class comes from the "Release"
+// behavior:
+//
+// When a field is cleared, it is only detached from its message. Existing
+// references to submessages, to repeated container etc. won't see any change,
+// as if the data was effectively managed by these containers.
+//
+// ExtensionDicts and UnknownFields containers do NOT follow this rule. They
+// don't store any data, and always refer to their parent message.
+
+struct ContainerBase {
PyObject_HEAD;
- // This is the top-level C++ Message object that owns the whole
- // proto tree. Every Python CMessage holds a reference to it in
- // order to keep it alive as long as there's a Python object that
- // references any part of the tree.
-
- typedef ThreadUnsafeSharedPtr<Message> OwnerRef;
- OwnerRef owner;
-
- // Weak reference to a parent CMessage object. This is NULL for any top-level
- // message and is set for any child message (i.e. a child submessage or a
- // part of a repeated composite field).
+ // Strong reference to a parent message object. For a CMessage there are three
+ // cases:
+ // - For a top-level message, this pointer is NULL.
+ // - For a sub-message, this points to the parent message.
+ // - For a message managed externally, this is a owned reference to Py_None.
//
- // Used to make sure all ancestors are also mutable when first modifying
- // a child submessage (in other words, turning a default message instance
- // into a mutable one).
- //
- // If a submessage is released (becomes a new top-level message), this field
- // MUST be set to NULL. The parent may get deallocated and further attempts
- // to use this pointer will result in a crash.
+ // For all other types: repeated containers, maps, it always point to a
+ // valid parent CMessage.
struct CMessage* parent;
- // Pointer to the parent's descriptor that describes this submessage.
- // Used together with the parent's message when making a default message
- // instance mutable.
- // The pointer is owned by the global DescriptorPool.
+ // If this object belongs to a parent message, describes which field it comes
+ // from.
+ // The pointer is owned by the DescriptorPool (which is kept alive
+ // through the message's Python class)
const FieldDescriptor* parent_field_descriptor;
- // Pointer to the C++ Message object for this CMessage. The
- // CMessage does not own this pointer.
+ PyObject* AsPyObject() { return reinterpret_cast<PyObject*>(this); }
+
+ // The Three methods below are only used by Repeated containers, and Maps.
+
+ // This implementation works for all containers which have a parent.
+ PyObject* DeepCopy();
+ // Delete this container object from its parent. Does not work for messages.
+ void RemoveFromParentCache();
+};
+
+typedef struct CMessage : public ContainerBase {
+ // Pointer to the C++ Message object for this CMessage.
+ // - If this object has no parent, we own this pointer.
+ // - If this object has a parent message, the parent owns this pointer.
Message* message;
// Indicates this submessage is pointing to a default instance of a message.
@@ -97,23 +108,37 @@
// made writable, at which point this field is set to false.
bool read_only;
- // A mapping indexed by field, containing CMessage,
- // RepeatedCompositeContainer, and RepeatedScalarContainer
- // objects. Used as a cache to make sure we don't have to make a
- // Python wrapper for the C++ Message objects on every access, or
- // deal with the synchronization nightmare that could create.
- // Also cache extension fields.
- // The FieldDescriptor is owned by the message's pool; PyObject references
- // are owned.
- typedef std::unordered_map<const FieldDescriptor*, PyObject*>
+ // A mapping indexed by field, containing weak references to contained objects
+ // which need to implement the "Release" mechanism:
+ // direct submessages, RepeatedCompositeContainer, RepeatedScalarContainer
+ // and MapContainer.
+ typedef std::unordered_map<const FieldDescriptor*, ContainerBase*>
CompositeFieldsMap;
CompositeFieldsMap* composite_fields;
+ // A mapping containing weak references to indirect child messages, accessed
+ // through containers: repeated messages, and values of message maps.
+ // This avoid the creation of similar maps in each of those containers.
+ typedef std::unordered_map<const Message*, CMessage*> SubMessagesMap;
+ SubMessagesMap* child_submessages;
+
// A reference to PyUnknownFields.
PyObject* unknown_field_set;
// Implements the "weakref" protocol for this object.
PyObject* weakreflist;
+
+ // Return a *borrowed* reference to the message class.
+ CMessageClass* GetMessageClass() {
+ return reinterpret_cast<CMessageClass*>(Py_TYPE(this));
+ }
+
+ // For container containing messages, return a Python object for the given
+ // pointer to a message.
+ CMessage* BuildSubMessageFromPointer(const FieldDescriptor* field_descriptor,
+ Message* sub_message,
+ CMessageClass* message_class);
+ CMessage* MaybeReleaseSubMessage(Message* sub_message);
} CMessage;
// The (meta) type of all Messages classes.
@@ -161,21 +186,16 @@
// submessage as the result is cached in composite_fields.
//
// Corresponds to reflection api method GetMessage.
-PyObject* InternalGetSubMessage(
+CMessage* InternalGetSubMessage(
CMessage* self, const FieldDescriptor* field_descriptor);
-// Deletes a range of C++ submessages in a repeated field (following a
+// Deletes a range of items in a repeated field (following a
// removal in a RepeatedCompositeContainer).
//
-// Releases submessages to the provided cmessage_list if it is not NULL rather
-// than just removing them from the underlying proto. This cmessage_list must
-// have a CMessage for each underlying submessage. The CMessages referred to
-// by slice will be removed from cmessage_list by this function.
-//
// Corresponds to reflection api method RemoveLast.
-int InternalDeleteRepeatedField(Message* message,
- const FieldDescriptor* field_descriptor,
- PyObject* slice, PyObject* cmessage_list);
+int DeleteRepeatedField(CMessage* self,
+ const FieldDescriptor* field_descriptor,
+ PyObject* slice);
// Sets the specified scalar value to the message.
int InternalSetScalar(CMessage* self,
@@ -193,6 +213,11 @@
PyObject* InternalGetScalar(const Message* message,
const FieldDescriptor* field_descriptor);
+bool SetCompositeField(CMessage* self, const FieldDescriptor* field,
+ ContainerBase* value);
+
+bool SetSubmessage(CMessage* self, CMessage* submessage);
+
// Clears the message, removing all contained data. Extension dictionary and
// submessages are released first if there are remaining external references.
//
@@ -248,11 +273,6 @@
PyObject* FindInitializationErrors(CMessage* self);
-// Set the owner field of self and any children of self, recursively.
-// Used when self is being released and thus has a new owner (the
-// released Message.)
-int SetOwner(CMessage* self, const CMessage::OwnerRef& new_owner);
-
int AssureWritable(CMessage* self);
// Returns the message factory for the given message.
@@ -344,6 +364,8 @@
const Message* PyMessage_GetMessagePointer(PyObject* msg);
Message* PyMessage_GetMutableMessagePointer(PyObject* msg);
+PyObject* PyMessage_NewMessageOwnedExternally(Message* message,
+ PyObject* message_factory);
bool InitProto2MessageModule(PyObject *m);
diff --git a/python/google/protobuf/pyext/repeated_composite_container.cc b/python/google/protobuf/pyext/repeated_composite_container.cc
index d8088a1..4188b5f 100644
--- a/python/google/protobuf/pyext/repeated_composite_container.cc
+++ b/python/google/protobuf/pyext/repeated_composite_container.cc
@@ -46,6 +46,7 @@
#include <google/protobuf/pyext/message_factory.h>
#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
#include <google/protobuf/reflection.h>
+#include <google/protobuf/stubs/map_util.h>
#if PY_MAJOR_VERSION >= 3
#define PyInt_Check PyLong_Check
@@ -59,22 +60,6 @@
namespace repeated_composite_container {
-// TODO(tibell): We might also want to check:
-// GOOGLE_CHECK_NOTNULL((self)->owner.get());
-#define GOOGLE_CHECK_ATTACHED(self) \
- do { \
- GOOGLE_CHECK_NOTNULL((self)->message); \
- GOOGLE_CHECK_NOTNULL((self)->parent_field_descriptor); \
- } while (0);
-
-#define GOOGLE_CHECK_RELEASED(self) \
- do { \
- GOOGLE_CHECK((self)->owner.get() == NULL); \
- GOOGLE_CHECK((self)->message == NULL); \
- GOOGLE_CHECK((self)->parent_field_descriptor == NULL); \
- GOOGLE_CHECK((self)->parent == NULL); \
- } while (0);
-
// ---------------------------------------------------------------------
// len()
@@ -82,75 +67,28 @@
RepeatedCompositeContainer* self =
reinterpret_cast<RepeatedCompositeContainer*>(pself);
- Message* message = self->message;
- if (message != NULL) {
- return message->GetReflection()->FieldSize(*message,
- self->parent_field_descriptor);
- } else {
- // The container has been released (i.e. by a call to Clear() or
- // ClearField() on the parent) and thus there's no message.
- return PyList_GET_SIZE(self->child_messages);
- }
-}
-
-// Returns 0 if successful; returns -1 and sets an exception if
-// unsuccessful.
-static int UpdateChildMessages(RepeatedCompositeContainer* self) {
- if (self->message == NULL)
- return 0;
-
- // A MergeFrom on a parent message could have caused extra messages to be
- // added in the underlying protobuf so add them to our list. They can never
- // be removed in such a way so there's no need to worry about that.
- Py_ssize_t message_length = Length(reinterpret_cast<PyObject*>(self));
- Py_ssize_t child_length = PyList_GET_SIZE(self->child_messages);
- Message* message = self->message;
- const Reflection* reflection = message->GetReflection();
- for (Py_ssize_t i = child_length; i < message_length; ++i) {
- const Message& sub_message = reflection->GetRepeatedMessage(
- *(self->message), self->parent_field_descriptor, i);
- CMessage* cmsg = cmessage::NewEmptyMessage(self->child_message_class);
- ScopedPyObjectPtr py_cmsg(reinterpret_cast<PyObject*>(cmsg));
- if (cmsg == NULL) {
- return -1;
- }
- cmsg->owner = self->owner;
- cmsg->message = const_cast<Message*>(&sub_message);
- cmsg->parent = self->parent;
- if (PyList_Append(self->child_messages, py_cmsg.get()) < 0) {
- return -1;
- }
- }
- return 0;
+ Message* message = self->parent->message;
+ return message->GetReflection()->FieldSize(*message,
+ self->parent_field_descriptor);
}
// ---------------------------------------------------------------------
// add()
-static PyObject* AddToAttached(RepeatedCompositeContainer* self,
- PyObject* args,
- PyObject* kwargs) {
- GOOGLE_CHECK_ATTACHED(self);
-
- if (UpdateChildMessages(self) < 0) {
- return NULL;
- }
+PyObject* Add(RepeatedCompositeContainer* self, PyObject* args,
+ PyObject* kwargs) {
if (cmessage::AssureWritable(self->parent) == -1)
return NULL;
- Message* message = self->message;
+ Message* message = self->parent->message;
Message* sub_message =
message->GetReflection()->AddMessage(
message,
self->parent_field_descriptor,
self->child_message_class->py_message_factory->message_factory);
- CMessage* cmsg = cmessage::NewEmptyMessage(self->child_message_class);
- if (cmsg == NULL)
- return NULL;
+ CMessage* cmsg = self->parent->BuildSubMessageFromPointer(
+ self->parent_field_descriptor, sub_message, self->child_message_class);
- cmsg->owner = self->owner;
- cmsg->message = sub_message;
- cmsg->parent = self->parent;
if (cmessage::InitAttributes(cmsg, args, kwargs) < 0) {
message->GetReflection()->RemoveLast(
message, self->parent_field_descriptor);
@@ -158,38 +96,7 @@
return NULL;
}
- PyObject* py_cmsg = reinterpret_cast<PyObject*>(cmsg);
- return py_cmsg;
-}
-
-static PyObject* AddToReleased(RepeatedCompositeContainer* self,
- PyObject* args,
- PyObject* kwargs) {
- GOOGLE_CHECK_RELEASED(self);
-
- // Create a new Message detached from the rest.
- PyObject* py_cmsg = PyEval_CallObjectWithKeywords(
- self->child_message_class->AsPyObject(), args, kwargs);
- return py_cmsg;
-}
-
-PyObject* Add(RepeatedCompositeContainer* self,
- PyObject* args,
- PyObject* kwargs) {
- PyObject* py_cmsg;
- if (self->message == nullptr)
- py_cmsg = AddToReleased(self, args, kwargs);
- else
- py_cmsg = AddToAttached(self, args, kwargs);
-
- if (py_cmsg == NULL)
- return NULL;
-
- if (PyList_Append(self->child_messages, py_cmsg) < 0) {
- Py_DECREF(py_cmsg);
- return NULL;
- }
- return py_cmsg;
+ return cmsg->AsPyObject();
}
static PyObject* AddMethod(PyObject* self, PyObject* args, PyObject* kwargs) {
@@ -201,31 +108,17 @@
static PyObject* AddMessage(RepeatedCompositeContainer* self, PyObject* value) {
cmessage::AssureWritable(self->parent);
- if (UpdateChildMessages(self) < 0) {
- return nullptr;
- }
-
PyObject* py_cmsg;
- if (self->message == nullptr) {
- py_cmsg = AddToReleased(self, nullptr, nullptr);
- if (py_cmsg == nullptr) return nullptr;
- CMessage* cmsg = reinterpret_cast<CMessage*>(py_cmsg);
- if (ScopedPyObjectPtr(cmessage::MergeFrom(cmsg, value)) == nullptr) {
- Py_DECREF(cmsg);
- return nullptr;
- }
- } else {
- Message* message = self->message;
- const Reflection* reflection = message->GetReflection();
- py_cmsg = AddToAttached(self, nullptr, nullptr);
- if (py_cmsg == nullptr) return nullptr;
- CMessage* cmsg = reinterpret_cast<CMessage*>(py_cmsg);
- if (ScopedPyObjectPtr(cmessage::MergeFrom(cmsg, value)) == nullptr) {
- reflection->RemoveLast(
- message, self->parent_field_descriptor);
- Py_DECREF(cmsg);
- return nullptr;
- }
+ Message* message = self->parent->message;
+ const Reflection* reflection = message->GetReflection();
+ py_cmsg = Add(self, nullptr, nullptr);
+ if (py_cmsg == nullptr) return nullptr;
+ CMessage* cmsg = reinterpret_cast<CMessage*>(py_cmsg);
+ if (ScopedPyObjectPtr(cmessage::MergeFrom(cmsg, value)) == nullptr) {
+ reflection->RemoveLast(
+ message, self->parent_field_descriptor);
+ Py_DECREF(cmsg);
+ return nullptr;
}
return py_cmsg;
}
@@ -238,10 +131,6 @@
return nullptr;
}
- if (PyList_Append(self->child_messages, py_cmsg.get()) < 0) {
- return nullptr;
- }
-
Py_RETURN_NONE;
}
@@ -262,23 +151,18 @@
return nullptr;
}
- if (self->message != nullptr) {
- // Swap the element to right position.
- Message* message = self->message;
- const Reflection* reflection = message->GetReflection();
- const FieldDescriptor* field_descriptor = self->parent_field_descriptor;
- Py_ssize_t length = reflection->FieldSize(*message, field_descriptor) - 1;
- Py_ssize_t end_index = index;
- if (end_index < 0) end_index += length;
- if (end_index < 0) end_index = 0;
- for (Py_ssize_t i = length; i > end_index; i --) {
- reflection->SwapElements(message, field_descriptor, i, i - 1);
- }
+ // Swap the element to right position.
+ Message* message = self->parent->message;
+ const Reflection* reflection = message->GetReflection();
+ const FieldDescriptor* field_descriptor = self->parent_field_descriptor;
+ Py_ssize_t length = reflection->FieldSize(*message, field_descriptor) - 1;
+ Py_ssize_t end_index = index;
+ if (end_index < 0) end_index += length;
+ if (end_index < 0) end_index = 0;
+ for (Py_ssize_t i = length; i > end_index; i --) {
+ reflection->SwapElements(message, field_descriptor, i, i - 1);
}
- if (PyList_Insert(self->child_messages, index, py_cmsg.get()) < 0) {
- return nullptr;
- }
Py_RETURN_NONE;
}
@@ -287,9 +171,6 @@
PyObject* Extend(RepeatedCompositeContainer* self, PyObject* value) {
cmessage::AssureWritable(self->parent);
- if (UpdateChildMessages(self) < 0) {
- return NULL;
- }
ScopedPyObjectPtr iter(PyObject_GetIter(value));
if (iter == NULL) {
PyErr_SetString(PyExc_TypeError, "Value must be iterable");
@@ -322,9 +203,6 @@
}
PyObject* MergeFrom(RepeatedCompositeContainer* self, PyObject* other) {
- if (UpdateChildMessages(self) < 0) {
- return NULL;
- }
return Extend(self, other);
}
@@ -332,13 +210,70 @@
return MergeFrom(reinterpret_cast<RepeatedCompositeContainer*>(self), other);
}
-PyObject* Subscript(RepeatedCompositeContainer* self, PyObject* slice) {
- if (UpdateChildMessages(self) < 0) {
+// This function does not check the bounds.
+static PyObject* GetItem(RepeatedCompositeContainer* self, Py_ssize_t index,
+ Py_ssize_t length = -1) {
+ if (length == -1) {
+ Message* message = self->parent->message;
+ const Reflection* reflection = message->GetReflection();
+ length = reflection->FieldSize(*message, self->parent_field_descriptor);
+ }
+ if (index < 0 || index >= length) {
+ PyErr_Format(PyExc_IndexError, "list index (%zd) out of range", index);
return NULL;
}
- // Just forward the call to the subscript-handling function of the
- // list containing the child messages.
- return PyObject_GetItem(self->child_messages, slice);
+ Message* message = self->parent->message;
+ Message* sub_message = message->GetReflection()->MutableRepeatedMessage(
+ message, self->parent_field_descriptor, index);
+ return self->parent
+ ->BuildSubMessageFromPointer(self->parent_field_descriptor, sub_message,
+ self->child_message_class)
+ ->AsPyObject();
+}
+
+PyObject* Subscript(RepeatedCompositeContainer* self, PyObject* item) {
+ Message* message = self->parent->message;
+ const Reflection* reflection = message->GetReflection();
+ Py_ssize_t length =
+ reflection->FieldSize(*message, self->parent_field_descriptor);
+
+ if (PyIndex_Check(item)) {
+ Py_ssize_t index;
+ index = PyNumber_AsSsize_t(item, PyExc_IndexError);
+ if (index == -1 && PyErr_Occurred()) return NULL;
+ if (index < 0) index += length;
+ return GetItem(self, index, length);
+ } else if (PySlice_Check(item)) {
+ Py_ssize_t from, to, step, slicelength, cur, i;
+ PyObject* result;
+
+#if PY_MAJOR_VERSION >= 3
+ if (PySlice_GetIndicesEx(item,
+ length, &from, &to, &step, &slicelength) == -1) {
+#else
+ if (PySlice_GetIndicesEx(reinterpret_cast<PySliceObject*>(item),
+ length, &from, &to, &step, &slicelength) == -1) {
+#endif
+ return NULL;
+ }
+
+ if (slicelength <= 0) {
+ return PyList_New(0);
+ } else {
+ result = PyList_New(slicelength);
+ if (!result) return NULL;
+
+ for (cur = from, i = 0; i < slicelength; cur += step, i++) {
+ PyList_SET_ITEM(result, i, GetItem(self, cur, length));
+ }
+
+ return result;
+ }
+ } else {
+ PyErr_Format(PyExc_TypeError, "indices must be integers, not %.200s",
+ item->ob_type->tp_name);
+ return NULL;
+ }
}
static PyObject* SubscriptMethod(PyObject* self, PyObject* slice) {
@@ -348,49 +283,13 @@
int AssignSubscript(RepeatedCompositeContainer* self,
PyObject* slice,
PyObject* value) {
- if (UpdateChildMessages(self) < 0) {
- return -1;
- }
if (value != NULL) {
PyErr_SetString(PyExc_TypeError, "does not support assignment");
return -1;
}
- // Delete from the underlying Message, if any.
- if (self->message != nullptr) {
- if (cmessage::InternalDeleteRepeatedField(self->message,
- self->parent_field_descriptor,
- slice,
- self->child_messages) < 0) {
- return -1;
- }
- } else {
- Py_ssize_t from;
- Py_ssize_t to;
- Py_ssize_t step;
- Py_ssize_t length = Length(reinterpret_cast<PyObject*>(self));
- Py_ssize_t slicelength;
- if (PySlice_Check(slice)) {
-#if PY_MAJOR_VERSION >= 3
- if (PySlice_GetIndicesEx(slice,
- length, &from, &to, &step, &slicelength) == -1) {
-#else
- if (PySlice_GetIndicesEx(reinterpret_cast<PySliceObject*>(slice),
- length, &from, &to, &step, &slicelength) == -1) {
-#endif
- return -1;
- }
- return PySequence_DelSlice(self->child_messages, from, to);
- } else if (PyInt_Check(slice) || PyLong_Check(slice)) {
- from = to = PyLong_AsLong(slice);
- if (from < 0) {
- from = to = length + from;
- }
- return PySequence_DelItem(self->child_messages, from);
- }
- }
-
- return 0;
+ return cmessage::DeleteRepeatedField(self->parent,
+ self->parent_field_descriptor, slice);
}
static int AssignSubscriptMethod(PyObject* self, PyObject* slice,
@@ -402,28 +301,33 @@
static PyObject* Remove(PyObject* pself, PyObject* value) {
RepeatedCompositeContainer* self =
reinterpret_cast<RepeatedCompositeContainer*>(pself);
+ Py_ssize_t len = Length(reinterpret_cast<PyObject*>(self));
- if (UpdateChildMessages(self) < 0) {
- return NULL;
+ for (Py_ssize_t i = 0; i < len; i++) {
+ ScopedPyObjectPtr item(GetItem(self, i, len));
+ if (item == NULL) {
+ return NULL;
+ }
+ int result = PyObject_RichCompareBool(item.get(), value, Py_EQ);
+ if (result < 0) {
+ return NULL;
+ }
+ if (result) {
+ ScopedPyObjectPtr py_index(PyLong_FromSsize_t(i));
+ if (AssignSubscript(self, py_index.get(), NULL) < 0) {
+ return NULL;
+ }
+ Py_RETURN_NONE;
+ }
}
- Py_ssize_t index = PySequence_Index(self->child_messages, value);
- if (index == -1) {
- return NULL;
- }
- ScopedPyObjectPtr py_index(PyLong_FromLong(index));
- if (AssignSubscript(self, py_index.get(), NULL) < 0) {
- return NULL;
- }
- Py_RETURN_NONE;
+ PyErr_SetString(PyExc_ValueError, "Item to delete not in list");
+ return NULL;
}
static PyObject* RichCompare(PyObject* pself, PyObject* other, int opid) {
RepeatedCompositeContainer* self =
reinterpret_cast<RepeatedCompositeContainer*>(pself);
- if (UpdateChildMessages(self) < 0) {
- return NULL;
- }
if (!PyObject_TypeCheck(other, &RepeatedCompositeContainer_Type)) {
PyErr_SetString(PyExc_TypeError,
"Can only compare repeated composite fields "
@@ -469,8 +373,9 @@
// ---------------------------------------------------------------------
// sort()
-static void ReorderAttached(RepeatedCompositeContainer* self) {
- Message* message = self->message;
+static void ReorderAttached(RepeatedCompositeContainer* self,
+ PyObject* child_list) {
+ Message* message = self->parent->message;
const Reflection* reflection = message->GetReflection();
const FieldDescriptor* descriptor = self->parent_field_descriptor;
const Py_ssize_t length = Length(reinterpret_cast<PyObject*>(self));
@@ -483,7 +388,7 @@
for (Py_ssize_t i = 0; i < length; ++i) {
CMessage* py_cmsg = reinterpret_cast<CMessage*>(
- PyList_GET_ITEM(self->child_messages, i));
+ PyList_GET_ITEM(child_list, i));
reflection->AddAllocatedMessage(message, descriptor, py_cmsg->message);
}
}
@@ -493,14 +398,17 @@
static int SortPythonMessages(RepeatedCompositeContainer* self,
PyObject* args,
PyObject* kwds) {
- ScopedPyObjectPtr m(PyObject_GetAttrString(self->child_messages, "sort"));
+ ScopedPyObjectPtr child_list(
+ PySequence_List(reinterpret_cast<PyObject*>(self)));
+ if (child_list == NULL) {
+ return -1;
+ }
+ ScopedPyObjectPtr m(PyObject_GetAttrString(child_list.get(), "sort"));
if (m == NULL)
return -1;
if (ScopedPyObjectPtr(PyObject_Call(m.get(), args, kwds)) == NULL)
return -1;
- if (self->message != NULL) {
- ReorderAttached(self);
- }
+ ReorderAttached(self, child_list.get());
return 0;
}
@@ -520,9 +428,6 @@
}
}
- if (UpdateChildMessages(self) < 0) {
- return NULL;
- }
if (SortPythonMessages(self, args, kwds) < 0) {
return NULL;
}
@@ -534,20 +439,7 @@
static PyObject* Item(PyObject* pself, Py_ssize_t index) {
RepeatedCompositeContainer* self =
reinterpret_cast<RepeatedCompositeContainer*>(pself);
-
- if (UpdateChildMessages(self) < 0) {
- return NULL;
- }
- Py_ssize_t length = Length(pself);
- if (index < 0) {
- index = length + index;
- }
- PyObject* item = PyList_GetItem(self->child_messages, index);
- if (item == NULL) {
- return NULL;
- }
- Py_INCREF(item);
- return item;
+ return GetItem(self, index);
}
static PyObject* Pop(PyObject* pself, PyObject* args) {
@@ -558,9 +450,10 @@
if (!PyArg_ParseTuple(args, "|n", &index)) {
return NULL;
}
- PyObject* item = Item(pself, index);
+ Py_ssize_t length = Length(pself);
+ if (index < 0) index += length;
+ PyObject* item = GetItem(self, index, length);
if (item == NULL) {
- PyErr_Format(PyExc_IndexError, "list index (%zd) out of range", index);
return NULL;
}
ScopedPyObjectPtr py_index(PyLong_FromSsize_t(index));
@@ -570,106 +463,15 @@
return item;
}
-// Release field of parent message and transfer the ownership to target.
-void ReleaseLastTo(Message* message,
- const FieldDescriptor* field,
- CMessage* target) {
- GOOGLE_CHECK(message != nullptr);
- GOOGLE_CHECK(field != nullptr);
- GOOGLE_CHECK(target != nullptr);
-
- CMessage::OwnerRef released_message(
- message->GetReflection()->ReleaseLast(message, field));
- // TODO(tibell): Deal with proto1.
-
- target->parent = NULL;
- target->parent_field_descriptor = NULL;
- target->message = released_message.get();
- target->read_only = false;
- cmessage::SetOwner(target, released_message);
-}
-
-// Called to release a container using
-// ClearField('container_field_name') on the parent.
-int Release(RepeatedCompositeContainer* self) {
- if (UpdateChildMessages(self) < 0) {
- PyErr_WriteUnraisable(PyBytes_FromString("Failed to update released "
- "messages"));
- return -1;
- }
-
- Message* message = self->message;
- const FieldDescriptor* field = self->parent_field_descriptor;
-
- // The reflection API only lets us release the last message in a
- // repeated field. Therefore we iterate through the children
- // starting with the last one.
- const Py_ssize_t size = PyList_GET_SIZE(self->child_messages);
- GOOGLE_DCHECK_EQ(size, message->GetReflection()->FieldSize(*message, field));
- for (Py_ssize_t i = size - 1; i >= 0; --i) {
- CMessage* child_cmessage = reinterpret_cast<CMessage*>(
- PyList_GET_ITEM(self->child_messages, i));
- ReleaseLastTo(message, field, child_cmessage);
- }
-
- // Detach from containing message.
- self->parent = NULL;
- self->parent_field_descriptor = NULL;
- self->message = NULL;
- self->owner.reset();
-
- return 0;
-}
-
PyObject* DeepCopy(PyObject* pself, PyObject* arg) {
- RepeatedCompositeContainer* self =
- reinterpret_cast<RepeatedCompositeContainer*>(pself);
-
- ScopedPyObjectPtr cloneObj(
- PyType_GenericAlloc(&RepeatedCompositeContainer_Type, 0));
- if (cloneObj == NULL) {
- return NULL;
- }
- RepeatedCompositeContainer* clone =
- reinterpret_cast<RepeatedCompositeContainer*>(cloneObj.get());
-
- Message* new_message = self->message->New();
- clone->parent = NULL;
- clone->parent_field_descriptor = self->parent_field_descriptor;
- clone->message = new_message;
- clone->owner.reset(new_message);
- Py_INCREF(self->child_message_class);
- clone->child_message_class = self->child_message_class;
- clone->child_messages = PyList_New(0);
-
- new_message->GetReflection()
- ->GetMutableRepeatedFieldRef<Message>(new_message,
- self->parent_field_descriptor)
- .MergeFrom(self->message->GetReflection()->GetRepeatedFieldRef<Message>(
- *self->message, self->parent_field_descriptor));
- return cloneObj.release();
-}
-
-int SetOwner(RepeatedCompositeContainer* self,
- const CMessage::OwnerRef& new_owner) {
- GOOGLE_CHECK_ATTACHED(self);
-
- self->owner = new_owner;
- const Py_ssize_t n = PyList_GET_SIZE(self->child_messages);
- for (Py_ssize_t i = 0; i < n; ++i) {
- PyObject* msg = PyList_GET_ITEM(self->child_messages, i);
- if (cmessage::SetOwner(reinterpret_cast<CMessage*>(msg), new_owner) == -1) {
- return -1;
- }
- }
- return 0;
+ return reinterpret_cast<RepeatedCompositeContainer*>(pself)->DeepCopy();
}
// The private constructor of RepeatedCompositeContainer objects.
-PyObject *NewContainer(
+RepeatedCompositeContainer *NewContainer(
CMessage* parent,
const FieldDescriptor* parent_field_descriptor,
- CMessageClass* concrete_class) {
+ CMessageClass* child_message_class) {
if (!CheckFieldBelongsToMessage(parent_field_descriptor, parent->message)) {
return NULL;
}
@@ -681,27 +483,19 @@
return NULL;
}
- self->message = parent->message;
+ Py_INCREF(parent);
self->parent = parent;
self->parent_field_descriptor = parent_field_descriptor;
- self->owner = parent->owner;
- Py_INCREF(concrete_class);
- self->child_message_class = concrete_class;
- self->child_messages = PyList_New(0);
-
- return reinterpret_cast<PyObject*>(self);
+ Py_INCREF(child_message_class);
+ self->child_message_class = child_message_class;
+ return self;
}
static void Dealloc(PyObject* pself) {
RepeatedCompositeContainer* self =
reinterpret_cast<RepeatedCompositeContainer*>(pself);
-
- Py_CLEAR(self->child_messages);
+ self->RemoveFromParentCache();
Py_CLEAR(self->child_message_class);
- // TODO(tibell): Do we need to call delete on these objects to make
- // sure their destructors are called?
- self->owner.reset();
-
Py_TYPE(self)->tp_free(pself);
}
diff --git a/python/google/protobuf/pyext/repeated_composite_container.h b/python/google/protobuf/pyext/repeated_composite_container.h
index d075577..e241827 100644
--- a/python/google/protobuf/pyext/repeated_composite_container.h
+++ b/python/google/protobuf/pyext/repeated_composite_container.h
@@ -52,46 +52,11 @@
struct CMessageClass;
-// A RepeatedCompositeContainer can be in one of two states: attached
-// or released.
-//
-// When in the attached state all modifications to the container are
-// done both on the 'message' and on the 'child_messages'
-// list. In this state all Messages referred to by the children in
-// 'child_messages' are owner by the 'owner'.
-//
-// When in the released state 'message', 'owner', 'parent', and
-// 'parent_field_descriptor' are NULL.
-typedef struct RepeatedCompositeContainer {
- PyObject_HEAD;
-
- // This is the top-level C++ Message object that owns the whole
- // proto tree. Every Python RepeatedCompositeContainer holds a
- // reference to it in order to keep it alive as long as there's a
- // Python object that references any part of the tree.
- CMessage::OwnerRef owner;
-
- // Weak reference to parent object. May be NULL. Used to make sure
- // the parent is writable before modifying the
- // RepeatedCompositeContainer.
- CMessage* parent;
-
- // A descriptor used to modify the underlying 'message'.
- // The pointer is owned by the global DescriptorPool.
- const FieldDescriptor* parent_field_descriptor;
-
- // Pointer to the C++ Message that contains this container. The
- // RepeatedCompositeContainer does not own this pointer.
- //
- // If NULL, this message has been released from its parent (by
- // calling Clear() or ClearField() on the parent.
- Message* message;
-
+// A RepeatedCompositeContainer always has a parent message.
+// The parent message also caches reference to items of the container.
+typedef struct RepeatedCompositeContainer : public ContainerBase {
// The type used to create new child messages.
CMessageClass* child_message_class;
-
- // A list of child messages.
- PyObject* child_messages;
} RepeatedCompositeContainer;
extern PyTypeObject RepeatedCompositeContainer_Type;
@@ -100,7 +65,7 @@
// Builds a RepeatedCompositeContainer object, from a parent message and a
// field descriptor.
-PyObject *NewContainer(
+RepeatedCompositeContainer* NewContainer(
CMessage* parent,
const FieldDescriptor* parent_field_descriptor,
CMessageClass *child_message_class);
@@ -139,25 +104,6 @@
int AssignSubscript(RepeatedCompositeContainer* self,
PyObject* slice,
PyObject* value);
-
-// Releases the messages in the container to a new message.
-//
-// Returns 0 on success, -1 on failure.
-int Release(RepeatedCompositeContainer* self);
-
-// Returns 0 on success, -1 on failure.
-int SetOwner(RepeatedCompositeContainer* self,
- const CMessage::OwnerRef& new_owner);
-
-// Removes the last element of the repeated message field 'field' on
-// the Message 'parent', and transfers the ownership of the released
-// Message to 'target'.
-//
-// Corresponds to reflection api method ReleaseMessage.
-void ReleaseLastTo(Message* message,
- const FieldDescriptor* field,
- CMessage* target);
-
} // namespace repeated_composite_container
} // namespace python
} // namespace protobuf
diff --git a/python/google/protobuf/pyext/repeated_scalar_container.cc b/python/google/protobuf/pyext/repeated_scalar_container.cc
index ac06cff..07ac602 100644
--- a/python/google/protobuf/pyext/repeated_scalar_container.cc
+++ b/python/google/protobuf/pyext/repeated_scalar_container.cc
@@ -63,8 +63,8 @@
static int InternalAssignRepeatedField(
RepeatedScalarContainer* self, PyObject* list) {
- self->message->GetReflection()->ClearField(self->message,
- self->parent_field_descriptor);
+ Message* message = self->parent->message;
+ message->GetReflection()->ClearField(message, self->parent_field_descriptor);
for (Py_ssize_t i = 0; i < PyList_GET_SIZE(list); ++i) {
PyObject* value = PyList_GET_ITEM(list, i);
if (ScopedPyObjectPtr(Append(self, value)) == NULL) {
@@ -77,7 +77,7 @@
static Py_ssize_t Len(PyObject* pself) {
RepeatedScalarContainer* self =
reinterpret_cast<RepeatedScalarContainer*>(pself);
- Message* message = self->message;
+ Message* message = self->parent->message;
return message->GetReflection()->FieldSize(*message,
self->parent_field_descriptor);
}
@@ -87,7 +87,7 @@
reinterpret_cast<RepeatedScalarContainer*>(pself);
cmessage::AssureWritable(self->parent);
- Message* message = self->message;
+ Message* message = self->parent->message;
const FieldDescriptor* field_descriptor = self->parent_field_descriptor;
const Reflection* reflection = message->GetReflection();
@@ -104,9 +104,8 @@
if (arg == NULL) {
ScopedPyObjectPtr py_index(PyLong_FromLong(index));
- return cmessage::InternalDeleteRepeatedField(self->message,
- field_descriptor,
- py_index.get(), NULL);
+ return cmessage::DeleteRepeatedField(self->parent, field_descriptor,
+ py_index.get());
}
if (PySequence_Check(arg) && !(PyBytes_Check(arg) || PyUnicode_Check(arg))) {
@@ -193,7 +192,7 @@
RepeatedScalarContainer* self =
reinterpret_cast<RepeatedScalarContainer*>(pself);
- Message* message = self->message;
+ Message* message = self->parent->message;
const FieldDescriptor* field_descriptor = self->parent_field_descriptor;
const Reflection* reflection = message->GetReflection();
@@ -343,7 +342,7 @@
PyObject* Append(RepeatedScalarContainer* self, PyObject* item) {
cmessage::AssureWritable(self->parent);
- Message* message = self->message;
+ Message* message = self->parent->message;
const FieldDescriptor* field_descriptor = self->parent_field_descriptor;
const Reflection* reflection = message->GetReflection();
@@ -437,7 +436,7 @@
bool create_list = false;
cmessage::AssureWritable(self->parent);
- Message* message = self->message;
+ Message* message = self->parent->message;
const FieldDescriptor* field_descriptor =
self->parent_field_descriptor;
@@ -467,8 +466,7 @@
}
if (value == NULL) {
- return cmessage::InternalDeleteRepeatedField(
- self->message, field_descriptor, slice, nullptr);
+ return cmessage::DeleteRepeatedField(self->parent, field_descriptor, slice);
}
if (!create_list) {
@@ -669,7 +667,7 @@
}
// The private constructor of RepeatedScalarContainer objects.
-PyObject *NewContainer(
+RepeatedScalarContainer* NewContainer(
CMessage* parent, const FieldDescriptor* parent_field_descriptor) {
if (!CheckFieldBelongsToMessage(parent_field_descriptor, parent->message)) {
return NULL;
@@ -681,72 +679,20 @@
return NULL;
}
- self->message = parent->message;
+ Py_INCREF(parent);
self->parent = parent;
self->parent_field_descriptor = parent_field_descriptor;
- self->owner = parent->owner;
- return reinterpret_cast<PyObject*>(self);
-}
-
-// Initializes the underlying Message object of "to" so it becomes a new parent
-// repeated scalar, and copies all the values from "from" to it. A child scalar
-// container can be released by passing it as both from and to (e.g. making it
-// the recipient of the new parent message and copying the values from itself).
-static int InitializeAndCopyToParentContainer(
- RepeatedScalarContainer* from,
- RepeatedScalarContainer* to) {
- ScopedPyObjectPtr full_slice(PySlice_New(NULL, NULL, NULL));
- if (full_slice == NULL) {
- return -1;
- }
- ScopedPyObjectPtr values(
- Subscript(reinterpret_cast<PyObject*>(from), full_slice.get()));
- if (values == NULL) {
- return -1;
- }
- Message* new_message = from->message->New();
- to->parent = NULL;
- to->parent_field_descriptor = from->parent_field_descriptor;
- to->message = new_message;
- to->owner.reset(new_message);
- if (InternalAssignRepeatedField(to, values.get()) < 0) {
- return -1;
- }
- return 0;
-}
-
-int Release(RepeatedScalarContainer* self) {
- return InitializeAndCopyToParentContainer(self, self);
+ return self;
}
PyObject* DeepCopy(PyObject* pself, PyObject* arg) {
- RepeatedScalarContainer* self =
- reinterpret_cast<RepeatedScalarContainer*>(pself);
-
- RepeatedScalarContainer* clone = reinterpret_cast<RepeatedScalarContainer*>(
- PyType_GenericAlloc(&RepeatedScalarContainer_Type, 0));
- if (clone == NULL) {
- return NULL;
- }
-
- if (InitializeAndCopyToParentContainer(self, clone) < 0) {
- Py_DECREF(clone);
- return NULL;
- }
- return reinterpret_cast<PyObject*>(clone);
+ return reinterpret_cast<RepeatedScalarContainer*>(pself)->DeepCopy();
}
static void Dealloc(PyObject* pself) {
- RepeatedScalarContainer* self =
- reinterpret_cast<RepeatedScalarContainer*>(pself);
- self->owner.reset();
- Py_TYPE(self)->tp_free(pself);
-}
-
-void SetOwner(RepeatedScalarContainer* self,
- const CMessage::OwnerRef& new_owner) {
- self->owner = new_owner;
+ reinterpret_cast<RepeatedScalarContainer*>(pself)->RemoveFromParentCache();
+ Py_TYPE(pself)->tp_free(pself);
}
static PySequenceMethods SqMethods = {
diff --git a/python/google/protobuf/pyext/repeated_scalar_container.h b/python/google/protobuf/pyext/repeated_scalar_container.h
index 4dcecba..f9f0ea8 100644
--- a/python/google/protobuf/pyext/repeated_scalar_container.h
+++ b/python/google/protobuf/pyext/repeated_scalar_container.h
@@ -45,30 +45,7 @@
namespace protobuf {
namespace python {
-typedef struct RepeatedScalarContainer {
- PyObject_HEAD;
-
- // This is the top-level C++ Message object that owns the whole
- // proto tree. Every Python RepeatedScalarContainer holds a
- // reference to it in order to keep it alive as long as there's a
- // Python object that references any part of the tree.
- CMessage::OwnerRef owner;
-
- // Pointer to the C++ Message that contains this container. The
- // RepeatedScalarContainer does not own this pointer.
- Message* message;
-
- // Weak reference to a parent CMessage object (i.e. may be NULL.)
- //
- // Used to make sure all ancestors are also mutable when first
- // modifying the container.
- CMessage* parent;
-
- // Pointer to the parent's descriptor that describes this
- // field. Used together with the parent's message when making a
- // default message instance mutable.
- // The pointer is owned by the global DescriptorPool.
- const FieldDescriptor* parent_field_descriptor;
+typedef struct RepeatedScalarContainer : public ContainerBase {
} RepeatedScalarContainer;
extern PyTypeObject RepeatedScalarContainer_Type;
@@ -77,7 +54,7 @@
// Builds a RepeatedScalarContainer object, from a parent message and a
// field descriptor.
-extern PyObject *NewContainer(
+extern RepeatedScalarContainer* NewContainer(
CMessage* parent, const FieldDescriptor* parent_field_descriptor);
// Appends the scalar 'item' to the end of the container 'self'.
@@ -86,21 +63,12 @@
// unsuccessful.
PyObject* Append(RepeatedScalarContainer* self, PyObject* item);
-// Releases the messages in the container to a new message.
-//
-// Returns 0 on success, -1 on failure.
-int Release(RepeatedScalarContainer* self);
-
// Appends all the elements in the input iterator to the container.
//
// Returns None if successful; returns NULL and sets an exception if
// unsuccessful.
PyObject* Extend(RepeatedScalarContainer* self, PyObject* value);
-// Set the owner field of self and any children of self.
-void SetOwner(RepeatedScalarContainer* self,
- const CMessage::OwnerRef& new_owner);
-
} // namespace repeated_scalar_container
} // namespace python
} // namespace protobuf
diff --git a/python/google/protobuf/pyext/thread_unsafe_shared_ptr.h b/python/google/protobuf/pyext/thread_unsafe_shared_ptr.h
deleted file mode 100644
index 79fa9e3..0000000
--- a/python/google/protobuf/pyext/thread_unsafe_shared_ptr.h
+++ /dev/null
@@ -1,104 +0,0 @@
-// 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.
-
-// ThreadUnsafeSharedPtr<T> is the same as shared_ptr<T> without the locking
-// overhread (and thread-safety).
-#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_THREAD_UNSAFE_SHARED_PTR_H__
-#define GOOGLE_PROTOBUF_PYTHON_CPP_THREAD_UNSAFE_SHARED_PTR_H__
-
-#include <algorithm>
-#include <utility>
-
-#include <google/protobuf/stubs/logging.h>
-#include <google/protobuf/stubs/common.h>
-
-namespace google {
-namespace protobuf {
-namespace python {
-
-template <typename T>
-class ThreadUnsafeSharedPtr {
- public:
- // Takes ownership.
- explicit ThreadUnsafeSharedPtr(T* ptr)
- : ptr_(ptr), refcount_(ptr ? new RefcountT(1) : nullptr) {
- }
-
- ThreadUnsafeSharedPtr(const ThreadUnsafeSharedPtr& other)
- : ThreadUnsafeSharedPtr(nullptr) {
- *this = other;
- }
-
- ThreadUnsafeSharedPtr& operator=(const ThreadUnsafeSharedPtr& other) {
- if (other.refcount_ == refcount_) {
- return *this;
- }
- this->~ThreadUnsafeSharedPtr();
- ptr_ = other.ptr_;
- refcount_ = other.refcount_;
- if (refcount_) {
- ++*refcount_;
- }
- return *this;
- }
-
- ~ThreadUnsafeSharedPtr() {
- if (refcount_ == nullptr) {
- GOOGLE_DCHECK(ptr_ == nullptr);
- return;
- }
- if (--*refcount_ == 0) {
- delete refcount_;
- delete ptr_;
- }
- }
-
- void reset(T* ptr = nullptr) { *this = ThreadUnsafeSharedPtr(ptr); }
-
- T* get() { return ptr_; }
- const T* get() const { return ptr_; }
-
- void swap(ThreadUnsafeSharedPtr& other) {
- using std::swap;
- swap(ptr_, other.ptr_);
- swap(refcount_, other.refcount_);
- }
-
- private:
- typedef int RefcountT;
- T* ptr_;
- RefcountT* refcount_;
-};
-
-} // namespace python
-} // namespace protobuf
-} // namespace google
-
-#endif // GOOGLE_PROTOBUF_PYTHON_CPP_THREAD_UNSAFE_SHARED_PTR_H__
diff --git a/python/google/protobuf/pyext/unknown_fields.cc b/python/google/protobuf/pyext/unknown_fields.cc
index 760452f..c3679c0 100755
--- a/python/google/protobuf/pyext/unknown_fields.cc
+++ b/python/google/protobuf/pyext/unknown_fields.cc
@@ -137,6 +137,8 @@
if (PyObject_TypeCheck(self->parent, &PyUnknownFields_Type)) {
reinterpret_cast<PyUnknownFields*>(
self->parent)->sub_unknown_fields.erase(self);
+ } else {
+ reinterpret_cast<CMessage*>(self->parent)->unknown_field_set = nullptr;
}
Py_CLEAR(self->parent);
self->~PyUnknownFields();
diff --git a/python/google/protobuf/text_format.py b/python/google/protobuf/text_format.py
index 557c7e2..7211662 100755
--- a/python/google/protobuf/text_format.py
+++ b/python/google/protobuf/text_format.py
@@ -584,7 +584,8 @@
message,
allow_unknown_extension=False,
allow_field_number=False,
- descriptor_pool=None):
+ descriptor_pool=None,
+ allow_unknown_field=False):
"""Parses a text representation of a protocol message into a message.
NOTE: for historical reasons this function does not clear the input
@@ -610,6 +611,9 @@
parsing
allow_field_number: if True, both field number and field name are allowed.
descriptor_pool: A DescriptorPool used to resolve Any types.
+ allow_unknown_field: if True, skip over unknown field and keep
+ parsing. Avoid to use this option if possible. It may hide some
+ errors (e.g. spelling error on field name)
Returns:
The same message passed as argument.
@@ -621,14 +625,16 @@
message,
allow_unknown_extension,
allow_field_number,
- descriptor_pool=descriptor_pool)
+ descriptor_pool=descriptor_pool,
+ allow_unknown_field=allow_unknown_field)
def Merge(text,
message,
allow_unknown_extension=False,
allow_field_number=False,
- descriptor_pool=None):
+ descriptor_pool=None,
+ allow_unknown_field=False):
"""Parses a text representation of a protocol message into a message.
Like Parse(), but allows repeated values for a non-repeated field, and uses
@@ -641,6 +647,9 @@
parsing
allow_field_number: if True, both field number and field name are allowed.
descriptor_pool: A DescriptorPool used to resolve Any types.
+ allow_unknown_field: if True, skip over unknown field and keep
+ parsing. Avoid to use this option if possible. It may hide some
+ errors (e.g. spelling error on field name)
Returns:
The same message passed as argument.
@@ -653,14 +662,16 @@
message,
allow_unknown_extension,
allow_field_number,
- descriptor_pool=descriptor_pool)
+ descriptor_pool=descriptor_pool,
+ allow_unknown_field=allow_unknown_field)
def ParseLines(lines,
message,
allow_unknown_extension=False,
allow_field_number=False,
- descriptor_pool=None):
+ descriptor_pool=None,
+ allow_unknown_field=False):
"""Parses a text representation of a protocol message into a message.
Args:
@@ -670,6 +681,9 @@
parsing
allow_field_number: if True, both field number and field name are allowed.
descriptor_pool: A DescriptorPool used to resolve Any types.
+ allow_unknown_field: if True, skip over unknown field and keep
+ parsing. Avoid to use this option if possible. It may hide some
+ errors (e.g. spelling error on field name)
Returns:
The same message passed as argument.
@@ -679,7 +693,8 @@
"""
parser = _Parser(allow_unknown_extension,
allow_field_number,
- descriptor_pool=descriptor_pool)
+ descriptor_pool=descriptor_pool,
+ allow_unknown_field=allow_unknown_field)
return parser.ParseLines(lines, message)
@@ -687,7 +702,8 @@
message,
allow_unknown_extension=False,
allow_field_number=False,
- descriptor_pool=None):
+ descriptor_pool=None,
+ allow_unknown_field=False):
"""Parses a text representation of a protocol message into a message.
Like ParseLines(), but allows repeated values for a non-repeated field, and
@@ -700,6 +716,9 @@
parsing
allow_field_number: if True, both field number and field name are allowed.
descriptor_pool: A DescriptorPool used to resolve Any types.
+ allow_unknown_field: if True, skip over unknown field and keep
+ parsing. Avoid to use this option if possible. It may hide some
+ errors (e.g. spelling error on field name)
Returns:
The same message passed as argument.
@@ -709,7 +728,8 @@
"""
parser = _Parser(allow_unknown_extension,
allow_field_number,
- descriptor_pool=descriptor_pool)
+ descriptor_pool=descriptor_pool,
+ allow_unknown_field=allow_unknown_field)
return parser.MergeLines(lines, message)
@@ -719,10 +739,12 @@
def __init__(self,
allow_unknown_extension=False,
allow_field_number=False,
- descriptor_pool=None):
+ descriptor_pool=None,
+ allow_unknown_field=False):
self.allow_unknown_extension = allow_unknown_extension
self.allow_field_number = allow_field_number
self.descriptor_pool = descriptor_pool
+ self.allow_unknown_field = allow_unknown_field
def ParseLines(self, lines, message):
"""Parses a text representation of a protocol message into a message."""
@@ -844,7 +866,7 @@
field.message_type.name != name):
field = None
- if not field:
+ if not field and not self.allow_unknown_field:
raise tokenizer.ParseErrorPreviousToken(
'Message type "%s" has no field named "%s".' %
(message_descriptor.full_name, name))
@@ -883,7 +905,7 @@
merger(tokenizer, message, field)
else: # Proto field is unknown.
- assert self.allow_unknown_extension
+ assert (self.allow_unknown_extension or self.allow_unknown_field)
_SkipFieldContents(tokenizer)
# For historical reasons, fields may optionally be separated by commas or
diff --git a/src/Makefile.am b/src/Makefile.am
index 6f64b96..fabc23a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -182,8 +182,8 @@
google/protobuf/stubs/hash.h \
google/protobuf/stubs/int128.cc \
google/protobuf/stubs/int128.h \
- google/protobuf/stubs/io_win32.cc \
- google/protobuf/stubs/io_win32.h \
+ google/protobuf/io/io_win32.cc \
+ google/protobuf/io/io_win32.h \
google/protobuf/stubs/map_util.h \
google/protobuf/stubs/mathutil.h \
google/protobuf/stubs/status.cc \
@@ -730,7 +730,7 @@
google/protobuf/stubs/bytestream_unittest.cc \
google/protobuf/stubs/common_unittest.cc \
google/protobuf/stubs/int128_unittest.cc \
- google/protobuf/stubs/io_win32_unittest.cc \
+ google/protobuf/io/io_win32_unittest.cc \
google/protobuf/stubs/statusor_test.cc \
google/protobuf/stubs/status_test.cc \
google/protobuf/stubs/stringpiece_unittest.cc \
diff --git a/src/google/protobuf/any.cc b/src/google/protobuf/any.cc
index 4b3cce6..a79214b 100644
--- a/src/google/protobuf/any.cc
+++ b/src/google/protobuf/any.cc
@@ -64,16 +64,16 @@
bool GetAnyFieldDescriptors(const Message& message,
const FieldDescriptor** type_url_field,
const FieldDescriptor** value_field) {
- const Descriptor* descriptor = message.GetDescriptor();
- if (descriptor->full_name() != kAnyFullTypeName) {
- return false;
- }
- *type_url_field = descriptor->FindFieldByNumber(1);
- *value_field = descriptor->FindFieldByNumber(2);
- return (*type_url_field != NULL &&
- (*type_url_field)->type() == FieldDescriptor::TYPE_STRING &&
- *value_field != NULL &&
- (*value_field)->type() == FieldDescriptor::TYPE_BYTES);
+ const Descriptor* descriptor = message.GetDescriptor();
+ if (descriptor->full_name() != kAnyFullTypeName) {
+ return false;
+ }
+ *type_url_field = descriptor->FindFieldByNumber(1);
+ *value_field = descriptor->FindFieldByNumber(2);
+ return (*type_url_field != NULL &&
+ (*type_url_field)->type() == FieldDescriptor::TYPE_STRING &&
+ *value_field != NULL &&
+ (*value_field)->type() == FieldDescriptor::TYPE_BYTES);
}
} // namespace internal
diff --git a/src/google/protobuf/any.pb.cc b/src/google/protobuf/any.pb.cc
index 3515411..404de6f 100644
--- a/src/google/protobuf/any.pb.cc
+++ b/src/google/protobuf/any.pb.cc
@@ -36,10 +36,6 @@
PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Any_google_2fprotobuf_2fany_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsAny_google_2fprotobuf_2fany_2eproto}, {}};
-void InitDefaults_google_2fprotobuf_2fany_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Any_google_2fprotobuf_2fany_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2fany_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2fany_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fany_2eproto = nullptr;
@@ -76,8 +72,7 @@
"roto3"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fany_2eproto = {
- false, InitDefaults_google_2fprotobuf_2fany_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2fany_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2fany_2eproto,
"google/protobuf/any.proto", &assign_descriptors_table_google_2fprotobuf_2fany_2eproto, 205,
};
@@ -85,6 +80,7 @@
static constexpr ::PROTOBUF_NAMESPACE_ID::internal::InitFunc deps[1] =
{
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Any_google_2fprotobuf_2fany_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2fany_2eproto, deps, 0);
}
@@ -190,38 +186,44 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Any::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// string type_url = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_type_url(), ptr, ctx, "google.protobuf.Any.type_url");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// bytes value = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_value(), ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Any::MergePartialFromCodedStream(
diff --git a/src/google/protobuf/any_test.cc b/src/google/protobuf/any_test.cc
index 72bd5e0..4fbf0b6 100644
--- a/src/google/protobuf/any_test.cc
+++ b/src/google/protobuf/any_test.cc
@@ -166,4 +166,3 @@
} // namespace
} // namespace protobuf
} // namespace google
-
diff --git a/src/google/protobuf/api.pb.cc b/src/google/protobuf/api.pb.cc
index 1b56305..c9e2123 100644
--- a/src/google/protobuf/api.pb.cc
+++ b/src/google/protobuf/api.pb.cc
@@ -81,12 +81,6 @@
PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Mixin_google_2fprotobuf_2fapi_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsMixin_google_2fprotobuf_2fapi_2eproto}, {}};
-void InitDefaults_google_2fprotobuf_2fapi_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Api_google_2fprotobuf_2fapi_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Method_google_2fprotobuf_2fapi_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Mixin_google_2fprotobuf_2fapi_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2fapi_2eproto[3];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2fapi_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fapi_2eproto = nullptr;
@@ -164,8 +158,7 @@
"rotobuf.WellKnownTypesb\006proto3"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fapi_2eproto = {
- false, InitDefaults_google_2fprotobuf_2fapi_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2fapi_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2fapi_2eproto,
"google/protobuf/api.proto", &assign_descriptors_table_google_2fprotobuf_2fapi_2eproto, 750,
};
@@ -175,6 +168,9 @@
::AddDescriptors_google_2fprotobuf_2fsource_5fcontext_2eproto,
::AddDescriptors_google_2fprotobuf_2ftype_2eproto,
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Api_google_2fprotobuf_2fapi_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Method_google_2fprotobuf_2fapi_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Mixin_google_2fprotobuf_2fapi_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2fapi_2eproto, deps, 2);
}
@@ -296,67 +292,74 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Api::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "google.protobuf.Api.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.Method methods = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_methods(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 18 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 18) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.Option options = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 26 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 26) break;
+ ptr += 1;
+ }
break;
}
// string version = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_version(), ptr, ctx, "google.protobuf.Api.version");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// .google.protobuf.SourceContext source_context = 5;
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 42) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_source_context(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.Mixin mixins = 6;
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 50) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_mixins(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 50 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 50) break;
+ ptr += 1;
+ }
break;
}
// .google.protobuf.Syntax syntax = 7;
case 7: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 56) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
set_syntax(static_cast<PROTOBUF_NAMESPACE_ID::Syntax>(val));
break;
}
@@ -364,15 +367,20 @@
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Api::MergePartialFromCodedStream(
@@ -898,61 +906,64 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Method::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "google.protobuf.Method.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// string request_type_url = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_request_type_url(), ptr, ctx, "google.protobuf.Method.request_type_url");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// bool request_streaming = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 24) goto handle_unusual;
- set_request_streaming(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ request_streaming_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// string response_type_url = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_response_type_url(), ptr, ctx, "google.protobuf.Method.response_type_url");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// bool response_streaming = 5;
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 40) goto handle_unusual;
- set_response_streaming(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ response_streaming_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.Option options = 6;
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 50) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 50 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 50) break;
+ ptr += 1;
+ }
break;
}
// .google.protobuf.Syntax syntax = 7;
case 7: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 56) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
set_syntax(static_cast<PROTOBUF_NAMESPACE_ID::Syntax>(val));
break;
}
@@ -960,15 +971,20 @@
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Method::MergePartialFromCodedStream(
@@ -1464,38 +1480,44 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Mixin::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "google.protobuf.Mixin.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// string root = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_root(), ptr, ctx, "google.protobuf.Mixin.root");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Mixin::MergePartialFromCodedStream(
diff --git a/src/google/protobuf/arena.cc b/src/google/protobuf/arena.cc
index eb3a1dd..0171c56 100644
--- a/src/google/protobuf/arena.cc
+++ b/src/google/protobuf/arena.cc
@@ -31,6 +31,7 @@
#include <google/protobuf/arena.h>
#include <algorithm>
+#include <atomic>
#include <limits>
#include <google/protobuf/stubs/mutex.h>
@@ -49,7 +50,7 @@
namespace internal {
-std::atomic<int64> ArenaImpl::lifecycle_id_generator_;
+std::atomic<LifecycleId> ArenaImpl::lifecycle_id_generator_;
#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
ArenaImpl::ThreadCache& ArenaImpl::thread_cache() {
static internal::ThreadLocalStorage<ThreadCache>* thread_cache_ =
@@ -58,7 +59,7 @@
}
#elif defined(PROTOBUF_USE_DLLS)
ArenaImpl::ThreadCache& ArenaImpl::thread_cache() {
- static GOOGLE_THREAD_LOCAL ThreadCache thread_cache_ = { -1, NULL };
+ static GOOGLE_THREAD_LOCAL ThreadCache thread_cache_ = {-1, NULL};
return thread_cache_;
}
#else
@@ -242,7 +243,7 @@
uint64 ArenaImpl::SpaceUsed() const {
SerialArena* serial = threads_.load(std::memory_order_acquire);
uint64 space_used = 0;
- for ( ; serial; serial = serial->next()) {
+ for (; serial; serial = serial->next()) {
space_used += serial->SpaceUsed();
}
return space_used;
@@ -286,7 +287,7 @@
// We have to be careful in this function, since we will be freeing the Block
// that contains this SerialArena. Be careful about accessing |serial|.
- for (Block* b = serial->head_; b; ) {
+ for (Block* b = serial->head_; b;) {
// This is inside the block we are freeing, so we need to read it now.
Block* next_block = b->next();
space_allocated += (b->size());
@@ -312,7 +313,7 @@
// properly synchronize Reset() or the destructor will throw a TSAN warning.
SerialArena* serial = threads_.load(std::memory_order_relaxed);
- for ( ; serial; serial = serial->next()) {
+ for (; serial; serial = serial->next()) {
serial->CleanupList();
}
}
@@ -365,7 +366,7 @@
ArenaImpl::SerialArena* ArenaImpl::GetSerialArenaFallback(void* me) {
// Look for this SerialArena in our linked list.
SerialArena* serial = threads_.load(std::memory_order_acquire);
- for ( ; serial; serial = serial->next()) {
+ for (; serial; serial = serial->next()) {
if (serial->owner() == me) {
break;
}
diff --git a/src/google/protobuf/arena.h b/src/google/protobuf/arena.h
index 3a9feb5..52f3fb9 100644
--- a/src/google/protobuf/arena.h
+++ b/src/google/protobuf/arena.h
@@ -72,8 +72,8 @@
namespace google {
namespace protobuf {
-class Arena; // defined below
-class Message; // defined in message.h
+class Arena; // defined below
+class Message; // defined in message.h
class MessageLite;
namespace arena_metrics {
@@ -84,8 +84,8 @@
namespace internal {
-struct ArenaStringPtr; // defined in arenastring.h
-class LazyField; // defined in lazy_field.h
+struct ArenaStringPtr; // defined in arenastring.h
+class LazyField; // defined in lazy_field.h
template <typename Type>
class GenericTypeHandler; // defined in repeated_field.h
@@ -402,8 +402,8 @@
// will be manually called when the arena is destroyed or reset. This differs
// from OwnDestructor() in that any member function may be specified, not only
// the class destructor.
- PROTOBUF_NOINLINE void OwnCustomDestructor(
- void* object, void (*destruct)(void*)) {
+ PROTOBUF_NOINLINE void OwnCustomDestructor(void* object,
+ void (*destruct)(void*)) {
impl_.AddCleanup(object, destruct);
}
diff --git a/src/google/protobuf/arena_impl.h b/src/google/protobuf/arena_impl.h
index 4ba5954..0beec17 100644
--- a/src/google/protobuf/arena_impl.h
+++ b/src/google/protobuf/arena_impl.h
@@ -55,6 +55,8 @@
return (n + 7) & static_cast<size_t>(-8);
}
+using LifecycleId = int64_t;
+
// This class provides the core Arena memory allocation library. Different
// implementations only need to implement the public interface below.
// Arena is not a template type as that would only be useful if all protos
@@ -73,12 +75,12 @@
template <typename O>
explicit Options(const O& options)
- : start_block_size(options.start_block_size),
- max_block_size(options.max_block_size),
- initial_block(options.initial_block),
- initial_block_size(options.initial_block_size),
- block_alloc(options.block_alloc),
- block_dealloc(options.block_dealloc) {}
+ : start_block_size(options.start_block_size),
+ max_block_size(options.max_block_size),
+ initial_block(options.initial_block),
+ initial_block_size(options.initial_block_size),
+ block_alloc(options.block_alloc),
+ block_dealloc(options.block_dealloc) {}
};
template <typename O>
@@ -193,11 +195,11 @@
void AddCleanupFallback(void* elem, void (*cleanup)(void*));
void CleanupListFallback();
- ArenaImpl* arena_; // Containing arena.
- void* owner_; // &ThreadCache of this thread;
- Block* head_; // Head of linked list of blocks.
- CleanupChunk* cleanup_; // Head of cleanup list.
- SerialArena* next_; // Next SerialArena in this linked list.
+ ArenaImpl* arena_; // Containing arena.
+ void* owner_; // &ThreadCache of this thread;
+ Block* head_; // Head of linked list of blocks.
+ CleanupChunk* cleanup_; // Head of cleanup list.
+ SerialArena* next_; // Next SerialArena in this linked list.
// Next pointer to allocate from. Always 8-byte aligned. Points inside
// head_ (and head_->pos will always be non-canonical). We keep these
@@ -227,7 +229,7 @@
void set_pos(size_t pos) { pos_ = pos; }
private:
- Block* next_; // Next block for this thread.
+ Block* next_; // Next block for this thread.
size_t pos_;
size_t size_;
// data follows
@@ -243,10 +245,10 @@
// The ThreadCache is considered valid as long as this matches the
// lifecycle_id of the arena being used.
- int64 last_lifecycle_id_seen;
+ LifecycleId last_lifecycle_id_seen;
SerialArena* last_serial_arena;
};
- static std::atomic<int64> lifecycle_id_generator_;
+ static std::atomic<LifecycleId> lifecycle_id_generator_;
#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
// Android ndk does not support GOOGLE_THREAD_LOCAL keyword so we use a custom thread
// local storage class we implemented.
@@ -279,21 +281,20 @@
hint_.store(serial, std::memory_order_release);
}
-
std::atomic<SerialArena*>
threads_; // Pointer to a linked list of SerialArena.
std::atomic<SerialArena*> hint_; // Fast thread-local block access
std::atomic<size_t> space_allocated_; // Total size of all allocated blocks.
- Block *initial_block_; // If non-NULL, points to the block that came from
- // user data.
+ Block* initial_block_; // If non-NULL, points to the block that came from
+ // user data.
Block* NewBlock(Block* last_block, size_t min_bytes);
SerialArena* GetSerialArena();
bool GetSerialArenaFast(SerialArena** arena);
SerialArena* GetSerialArenaFallback(void* me);
- int64 lifecycle_id_; // Unique for each arena. Changes on Reset().
+ LifecycleId lifecycle_id_; // Unique for each arena. Changes on Reset().
Options options_;
diff --git a/src/google/protobuf/arena_test_util.cc b/src/google/protobuf/arena_test_util.cc
index df9c5bd..da32960 100644
--- a/src/google/protobuf/arena_test_util.cc
+++ b/src/google/protobuf/arena_test_util.cc
@@ -28,9 +28,9 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include <google/protobuf/arena_test_util.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
-#include <google/protobuf/arena_test_util.h>
#define EXPECT_EQ GOOGLE_CHECK_EQ
diff --git a/src/google/protobuf/arena_test_util.h b/src/google/protobuf/arena_test_util.h
index fdbaca0..84df349 100644
--- a/src/google/protobuf/arena_test_util.h
+++ b/src/google/protobuf/arena_test_util.h
@@ -78,10 +78,9 @@
class NoHeapChecker {
public:
- NoHeapChecker() {
- capture_alloc.Hook();
- }
+ NoHeapChecker() { capture_alloc.Hook(); }
~NoHeapChecker();
+
private:
class NewDeleteCapture {
public:
diff --git a/src/google/protobuf/arena_unittest.cc b/src/google/protobuf/arena_unittest.cc
index a682a9c..6ef3094 100644
--- a/src/google/protobuf/arena_unittest.cc
+++ b/src/google/protobuf/arena_unittest.cc
@@ -71,12 +71,8 @@
class Notifier {
public:
Notifier() : count_(0) {}
- void Notify() {
- count_++;
- }
- int GetCount() {
- return count_;
- }
+ void Notify() { count_++; }
+ int GetCount() { return count_; }
private:
int count_;
@@ -85,14 +81,13 @@
class SimpleDataType {
public:
SimpleDataType() : notifier_(NULL) {}
- void SetNotifier(Notifier* notifier) {
- notifier_ = notifier;
- }
+ void SetNotifier(Notifier* notifier) { notifier_ = notifier; }
virtual ~SimpleDataType() {
if (notifier_ != NULL) {
notifier_->Notify();
}
};
+
private:
Notifier* notifier_;
};
@@ -227,8 +222,8 @@
const std::string three("3");
const PleaseDontCopyMe four(4);
const MustBeConstructedWithOneThroughFour* new_object =
- Arena::Create<MustBeConstructedWithOneThroughFour>(
- &arena, 1, "2", three, &four);
+ Arena::Create<MustBeConstructedWithOneThroughFour>(&arena, 1, "2", three,
+ &four);
EXPECT_TRUE(new_object != NULL);
ASSERT_EQ(1, new_object->one_);
ASSERT_STREQ("2", new_object->two_);
@@ -462,7 +457,7 @@
TEST(ArenaTest, SetAllocatedMessage) {
Arena arena;
- TestAllTypes *arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
+ TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes::NestedMessage* nested = new TestAllTypes::NestedMessage;
nested->set_bb(118);
arena_message->set_allocated_optional_nested_message(nested);
@@ -620,8 +615,7 @@
heap_submessage->set_bb(42);
arena1_message->set_allocated_optional_nested_message(heap_submessage);
// Should keep same object and add to arena's Own()-list.
- EXPECT_EQ(heap_submessage,
- arena1_message->mutable_optional_nested_message());
+ EXPECT_EQ(heap_submessage, arena1_message->mutable_optional_nested_message());
{
Arena arena2;
TestAllTypes::NestedMessage* arena2_submessage =
@@ -637,8 +631,7 @@
arena1_submessage->set_bb(42);
TestAllTypes* heap_message = new TestAllTypes;
heap_message->set_allocated_optional_nested_message(arena1_submessage);
- EXPECT_NE(arena1_submessage,
- heap_message->mutable_optional_nested_message());
+ EXPECT_NE(arena1_submessage, heap_message->mutable_optional_nested_message());
delete heap_message;
}
@@ -648,15 +641,14 @@
TestAllTypes* arena1_message = Arena::CreateMessage<TestAllTypes>(&arena1);
const Reflection* r = arena1_message->GetReflection();
const Descriptor* d = arena1_message->GetDescriptor();
- const FieldDescriptor* msg_field = d->FindFieldByName(
- "optional_nested_message");
+ const FieldDescriptor* msg_field =
+ d->FindFieldByName("optional_nested_message");
TestAllTypes::NestedMessage* heap_submessage =
new TestAllTypes::NestedMessage();
heap_submessage->set_bb(42);
r->SetAllocatedMessage(arena1_message, heap_submessage, msg_field);
// Should keep same object and add to arena's Own()-list.
- EXPECT_EQ(heap_submessage,
- arena1_message->mutable_optional_nested_message());
+ EXPECT_EQ(heap_submessage, arena1_message->mutable_optional_nested_message());
{
Arena arena2;
TestAllTypes::NestedMessage* arena2_submessage =
@@ -672,8 +664,7 @@
arena1_submessage->set_bb(42);
TestAllTypes* heap_message = new TestAllTypes;
r->SetAllocatedMessage(heap_message, arena1_submessage, msg_field);
- EXPECT_NE(arena1_submessage,
- heap_message->mutable_optional_nested_message());
+ EXPECT_NE(arena1_submessage, heap_message->mutable_optional_nested_message());
delete heap_message;
}
@@ -728,11 +719,10 @@
TestAllTypes::NestedMessage* heap_submessage =
new TestAllTypes::NestedMessage();
heap_submessage->set_bb(42);
- arena1_message->mutable_repeated_nested_message()->
- AddAllocated(heap_submessage);
+ arena1_message->mutable_repeated_nested_message()->AddAllocated(
+ heap_submessage);
// Should not copy object -- will use arena_->Own().
- EXPECT_EQ(heap_submessage,
- &arena1_message->repeated_nested_message(i));
+ EXPECT_EQ(heap_submessage, &arena1_message->repeated_nested_message(i));
EXPECT_EQ(42, arena1_message->repeated_nested_message(i).bb());
}
@@ -743,11 +733,10 @@
TestAllTypes::NestedMessage* arena2_submessage =
Arena::CreateMessage<TestAllTypes::NestedMessage>(&arena2);
arena2_submessage->set_bb(42);
- arena1_message->mutable_repeated_nested_message()->
- AddAllocated(arena2_submessage);
+ arena1_message->mutable_repeated_nested_message()->AddAllocated(
+ arena2_submessage);
// Should copy object.
- EXPECT_NE(arena2_submessage,
- &arena1_message->repeated_nested_message(i));
+ EXPECT_NE(arena2_submessage, &arena1_message->repeated_nested_message(i));
EXPECT_EQ(42, arena1_message->repeated_nested_message(i).bb());
}
@@ -758,11 +747,10 @@
TestAllTypes::NestedMessage* arena2_submessage =
Arena::CreateMessage<TestAllTypes::NestedMessage>(&arena2);
arena2_submessage->set_bb(42);
- heap_message->mutable_repeated_nested_message()->
- AddAllocated(arena2_submessage);
+ heap_message->mutable_repeated_nested_message()->AddAllocated(
+ arena2_submessage);
// Should copy object.
- EXPECT_NE(arena2_submessage,
- &heap_message->repeated_nested_message(i));
+ EXPECT_NE(arena2_submessage, &heap_message->repeated_nested_message(i));
EXPECT_EQ(42, heap_message->repeated_nested_message(i).bb());
}
delete heap_message;
@@ -771,8 +759,7 @@
arena1_message->Clear();
for (int i = 0; i < 10; i++) {
std::string* s = new std::string("Test");
- arena1_message->mutable_repeated_string()->
- AddAllocated(s);
+ arena1_message->mutable_repeated_string()->AddAllocated(s);
// Should not copy.
EXPECT_EQ(s, &arena1_message->repeated_string(i));
EXPECT_EQ("Test", arena1_message->repeated_string(i));
@@ -785,16 +772,14 @@
TestAllTypes* arena1_message = Arena::CreateMessage<TestAllTypes>(&arena1);
const Reflection* r = arena1_message->GetReflection();
const Descriptor* d = arena1_message->GetDescriptor();
- const FieldDescriptor* fd =
- d->FindFieldByName("repeated_nested_message");
+ const FieldDescriptor* fd = d->FindFieldByName("repeated_nested_message");
for (int i = 0; i < 10; i++) {
TestAllTypes::NestedMessage* heap_submessage =
new TestAllTypes::NestedMessage;
heap_submessage->set_bb(42);
r->AddAllocatedMessage(arena1_message, fd, heap_submessage);
// Should not copy object -- will use arena_->Own().
- EXPECT_EQ(heap_submessage,
- &arena1_message->repeated_nested_message(i));
+ EXPECT_EQ(heap_submessage, &arena1_message->repeated_nested_message(i));
EXPECT_EQ(42, arena1_message->repeated_nested_message(i).bb());
}
@@ -807,8 +792,7 @@
arena2_submessage->set_bb(42);
r->AddAllocatedMessage(arena1_message, fd, arena2_submessage);
// Should copy object.
- EXPECT_NE(arena2_submessage,
- &arena1_message->repeated_nested_message(i));
+ EXPECT_NE(arena2_submessage, &arena1_message->repeated_nested_message(i));
EXPECT_EQ(42, arena1_message->repeated_nested_message(i).bb());
}
@@ -821,8 +805,7 @@
arena2_submessage->set_bb(42);
r->AddAllocatedMessage(heap_message, fd, arena2_submessage);
// Should copy object.
- EXPECT_NE(arena2_submessage,
- &heap_message->repeated_nested_message(i));
+ EXPECT_NE(arena2_submessage, &heap_message->repeated_nested_message(i));
EXPECT_EQ(42, heap_message->repeated_nested_message(i).bb());
}
delete heap_message;
@@ -841,9 +824,9 @@
}
for (int i = 0; i < 10; i++) {
- const TestAllTypes::NestedMessage *orig_submessage =
+ const TestAllTypes::NestedMessage* orig_submessage =
&arena_message->repeated_nested_message(10 - 1 - i); // last element
- TestAllTypes::NestedMessage *released =
+ TestAllTypes::NestedMessage* released =
arena_message->mutable_repeated_nested_message()->ReleaseLast();
EXPECT_NE(released, orig_submessage);
EXPECT_EQ(42, released->bb());
@@ -859,11 +842,11 @@
}
for (int i = 0; i < 10; i++) {
- const TestAllTypes::NestedMessage *orig_submessage =
+ const TestAllTypes::NestedMessage* orig_submessage =
&arena_message->repeated_nested_message(10 - 1 - i); // last element
- TestAllTypes::NestedMessage *released =
- arena_message->mutable_repeated_nested_message()->
- UnsafeArenaReleaseLast();
+ TestAllTypes::NestedMessage* released =
+ arena_message->mutable_repeated_nested_message()
+ ->UnsafeArenaReleaseLast();
EXPECT_EQ(released, orig_submessage);
EXPECT_EQ(42, released->bb());
// no delete -- |released| is on the arena.
@@ -962,12 +945,10 @@
const Descriptor* desc = message->GetDescriptor();
const Reflection* refl = message->GetReflection();
- const FieldDescriptor* string_field = desc->FindFieldByName(
- "oneof_string");
- const FieldDescriptor* msg_field = desc->FindFieldByName(
- "oneof_nested_message");
- const OneofDescriptor* oneof = desc->FindOneofByName(
- "oneof_field");
+ const FieldDescriptor* string_field = desc->FindFieldByName("oneof_string");
+ const FieldDescriptor* msg_field =
+ desc->FindFieldByName("oneof_nested_message");
+ const OneofDescriptor* oneof = desc->FindOneofByName("oneof_field");
refl->SetString(message, string_field, "Test value");
EXPECT_TRUE(refl->HasOneof(*message, oneof));
@@ -1051,12 +1032,12 @@
// Ensure no leaks.
TestAllExtensions* message_ext =
Arena::CreateMessage<TestAllExtensions>(&arena);
- message_ext->SetExtension(
- protobuf_unittest::optional_int32_extension, 42);
+ message_ext->SetExtension(protobuf_unittest::optional_int32_extension, 42);
message_ext->SetExtension(protobuf_unittest::optional_string_extension,
std::string("test"));
- message_ext->MutableExtension(
- protobuf_unittest::optional_nested_message_extension)->set_bb(42);
+ message_ext
+ ->MutableExtension(protobuf_unittest::optional_nested_message_extension)
+ ->set_bb(42);
}
TEST(ArenaTest, RepeatedFieldOnArena) {
@@ -1119,7 +1100,7 @@
// code that may allocate messages or repeated fields of messages on an arena.
{
RepeatedPtrField<TestAllTypes>* repeated_ptr_on_arena =
- Arena::CreateMessage< RepeatedPtrField<TestAllTypes> >(&arena);
+ Arena::CreateMessage<RepeatedPtrField<TestAllTypes> >(&arena);
for (int i = 0; i < 10; i++) {
// Add some elements and let the leak-checker ensure that everything is
// freed.
@@ -1127,7 +1108,7 @@
}
RepeatedField<int>* repeated_int_on_arena =
- Arena::CreateMessage< RepeatedField<int> >(&arena);
+ Arena::CreateMessage<RepeatedField<int> >(&arena);
for (int i = 0; i < 100; i++) {
repeated_int_on_arena->Add(i);
}
@@ -1154,7 +1135,8 @@
EXPECT_EQ(submessage_expected, submessage);
EXPECT_EQ(&arena, submessage->GetArena());
- const FieldDescriptor* oneof_field = d->FindFieldByName("oneof_nested_message");
+ const FieldDescriptor* oneof_field =
+ d->FindFieldByName("oneof_nested_message");
submessage = static_cast<TestAllTypes::NestedMessage*>(
r->MutableMessage(message, oneof_field));
submessage_expected = message->mutable_oneof_nested_message();
diff --git a/src/google/protobuf/arenastring_unittest.cc b/src/google/protobuf/arenastring_unittest.cc
index edb6f6c..70a3f76 100644
--- a/src/google/protobuf/arenastring_unittest.cc
+++ b/src/google/protobuf/arenastring_unittest.cc
@@ -40,10 +40,9 @@
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
-#include <gtest/gtest.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
-
+#include <gtest/gtest.h>
namespace google {
diff --git a/src/google/protobuf/compiler/code_generator.cc b/src/google/protobuf/compiler/code_generator.cc
index 3319d5c..428ec46 100644
--- a/src/google/protobuf/compiler/code_generator.cc
+++ b/src/google/protobuf/compiler/code_generator.cc
@@ -57,8 +57,9 @@
const FileDescriptor* file = files[i];
succeeded = Generate(file, parameter, generator_context, error);
if (!succeeded && error && error->empty()) {
- *error = "Code generator returned false but provided no error "
- "description.";
+ *error =
+ "Code generator returned false but provided no error "
+ "description.";
}
if (error && !error->empty()) {
*error = file->name() + ": " + *error;
diff --git a/src/google/protobuf/compiler/code_generator.h b/src/google/protobuf/compiler/code_generator.h
index b1eb61a..528dc76 100644
--- a/src/google/protobuf/compiler/code_generator.h
+++ b/src/google/protobuf/compiler/code_generator.h
@@ -38,17 +38,19 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
#define GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
-#include <google/protobuf/stubs/common.h>
#include <string>
-#include <vector>
#include <utility>
+#include <vector>
+#include <google/protobuf/stubs/common.h>
#include <google/protobuf/port_def.inc>
namespace google {
namespace protobuf {
-namespace io { class ZeroCopyOutputStream; }
+namespace io {
+class ZeroCopyOutputStream;
+}
class FileDescriptor;
namespace compiler {
diff --git a/src/google/protobuf/compiler/command_line_interface.cc b/src/google/protobuf/compiler/command_line_interface.cc
index 126c433..02987e3 100644
--- a/src/google/protobuf/compiler/command_line_interface.cc
+++ b/src/google/protobuf/compiler/command_line_interface.cc
@@ -45,17 +45,17 @@
#ifdef minor
#undef minor
#endif
-#include <sys/stat.h>
#include <fcntl.h>
+#include <sys/stat.h>
#ifndef _MSC_VER
#include <unistd.h>
#endif
+#include <ctype.h>
#include <errno.h>
#include <fstream>
#include <iostream>
-#include <ctype.h>
-#include <limits.h> //For PATH_MAX
+#include <limits.h> //For PATH_MAX
#include <memory>
@@ -71,6 +71,7 @@
#include <google/protobuf/compiler/plugin.pb.h>
#include <google/protobuf/compiler/code_generator.h>
#include <google/protobuf/compiler/importer.h>
+#include <google/protobuf/io/io_win32.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/io/printer.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
@@ -81,7 +82,6 @@
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/stubs/map_util.h>
#include <google/protobuf/stubs/stl_util.h>
-#include <google/protobuf/stubs/io_win32.h>
#include <google/protobuf/port_def.inc>
@@ -94,7 +94,7 @@
#ifdef _O_BINARY
#define O_BINARY _O_BINARY
#else
-#define O_BINARY 0 // If this isn't defined, the platform doesn't need it.
+#define O_BINARY 0 // If this isn't defined, the platform doesn't need it.
#endif
#endif
@@ -102,12 +102,12 @@
#if defined(_WIN32)
// DO NOT include <io.h>, instead create functions in io_win32.{h,cc} and import
// them like we do below.
-using google::protobuf::internal::win32::access;
-using google::protobuf::internal::win32::close;
-using google::protobuf::internal::win32::mkdir;
-using google::protobuf::internal::win32::open;
-using google::protobuf::internal::win32::setmode;
-using google::protobuf::internal::win32::write;
+using google::protobuf::io::win32::access;
+using google::protobuf::io::win32::close;
+using google::protobuf::io::win32::mkdir;
+using google::protobuf::io::win32::open;
+using google::protobuf::io::win32::setmode;
+using google::protobuf::io::win32::write;
#endif
static const char* kDefaultDirectDependenciesViolationMsg =
@@ -118,10 +118,8 @@
// copy in importer.cc?
static bool IsWindowsAbsolutePath(const std::string& text) {
#if defined(_WIN32) || defined(__CYGWIN__)
- return text.size() >= 3 && text[1] == ':' &&
- isalpha(text[0]) &&
- (text[2] == '/' || text[2] == '\\') &&
- text.find_last_of(':') == 1;
+ return text.size() >= 3 && text[1] == ':' && isalpha(text[0]) &&
+ (text[2] == '/' || text[2] == '\\') && text.find_last_of(':') == 1;
#else
return false;
#endif
@@ -281,8 +279,8 @@
public io::ErrorCollector,
public DescriptorPool::ErrorCollector {
public:
- ErrorPrinter(ErrorFormat format, DiskSourceTree *tree = NULL)
- : format_(format), tree_(tree), found_errors_(false) {}
+ ErrorPrinter(ErrorFormat format, DiskSourceTree* tree = NULL)
+ : format_(format), tree_(tree), found_errors_(false) {}
~ErrorPrinter() {}
// implements MultiFileErrorCollector ------------------------------
@@ -327,8 +325,7 @@
std::ostream& out) {
// Print full path when running under MSVS
std::string dfile;
- if (format_ == CommandLineInterface::ERROR_FORMAT_MSVS &&
- tree_ != NULL &&
+ if (format_ == CommandLineInterface::ERROR_FORMAT_MSVS && tree_ != NULL &&
tree_->VirtualFileToDiskFile(filename, &dfile)) {
out << dfile;
} else {
@@ -344,8 +341,8 @@
out << ":" << (line + 1) << ":" << (column + 1);
break;
case CommandLineInterface::ERROR_FORMAT_MSVS:
- out << "(" << (line + 1) << ") : "
- << type << " in column=" << (column + 1);
+ out << "(" << (line + 1) << ") : " << type
+ << " in column=" << (column + 1);
break;
}
}
@@ -358,7 +355,7 @@
}
const ErrorFormat format_;
- DiskSourceTree *tree_;
+ DiskSourceTree* tree_;
bool found_errors_;
};
@@ -417,8 +414,8 @@
// implements ZeroCopyOutputStream ---------------------------------
virtual bool Next(void** data, int* size) { return inner_->Next(data, size); }
- virtual void BackUp(int count) { inner_->BackUp(count); }
- virtual int64 ByteCount() const { return inner_->ByteCount(); }
+ virtual void BackUp(int count) { inner_->BackUp(count); }
+ virtual int64 ByteCount() const { return inner_->ByteCount(); }
private:
// Checks to see if "filename_.meta" exists in directory_; if so, fixes the
@@ -447,8 +444,7 @@
CommandLineInterface::GeneratorContextImpl::GeneratorContextImpl(
const std::vector<const FileDescriptor*>& parsed_files)
- : parsed_files_(parsed_files),
- had_error_(false) {}
+ : parsed_files_(parsed_files), had_error_(false) {}
CommandLineInterface::GeneratorContextImpl::~GeneratorContextImpl() {
STLDeleteValues(&files_);
@@ -480,7 +476,7 @@
int file_descriptor;
do {
file_descriptor =
- open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
+ open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
} while (file_descriptor < 0 && errno == EINTR);
if (file_descriptor < 0) {
@@ -540,7 +536,7 @@
int file_descriptor;
do {
file_descriptor =
- open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
+ open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
} while (file_descriptor < 0 && errno == EINTR);
if (file_descriptor < 0) {
@@ -794,7 +790,8 @@
kDefaultDirectDependenciesViolationMsg),
imports_in_descriptor_set_(false),
source_info_in_descriptor_set_(false),
- disallow_services_(false) {}
+ disallow_services_(false) {
+}
CommandLineInterface::~CommandLineInterface() {}
void CommandLineInterface::RegisterGenerator(const std::string& flag_name,
@@ -986,10 +983,10 @@
break;
case PRINT_NONE:
GOOGLE_LOG(ERROR) << "If the code reaches here, it usually means a bug of "
- "flag parsing in the CommandLineInterface.";
+ "flag parsing in the CommandLineInterface.";
return 1;
- // Do not add a default case.
+ // Do not add a default case.
}
}
@@ -1021,16 +1018,15 @@
fd = open(descriptor_set_in_names_[i].c_str(), O_RDONLY | O_BINARY);
} while (fd < 0 && errno == EINTR);
if (fd < 0) {
- std::cerr << descriptor_set_in_names_[i] << ": "
- << strerror(ENOENT) << std::endl;
+ std::cerr << descriptor_set_in_names_[i] << ": " << strerror(ENOENT)
+ << std::endl;
return false;
}
FileDescriptorSet file_descriptor_set;
bool parsed = file_descriptor_set.ParseFromFileDescriptor(fd);
if (close(fd) != 0) {
- std::cerr << descriptor_set_in_names_[i] << ": close: "
- << strerror(errno)
+ std::cerr << descriptor_set_in_names_[i] << ": close: " << strerror(errno)
<< std::endl;
return false;
}
@@ -1095,8 +1091,10 @@
// Enforce --disallow_services.
if (disallow_services_ && parsed_file->service_count() > 0) {
- std::cerr << parsed_file->name() << ": This file contains services, but "
- "--disallow_services was used." << std::endl;
+ std::cerr << parsed_file->name()
+ << ": This file contains services, but "
+ "--disallow_services was used."
+ << std::endl;
return false;
}
@@ -1168,18 +1166,18 @@
}
std::string virtual_file, shadowing_disk_file;
- switch (source_tree->DiskFileToVirtualFile(
- *proto, &virtual_file, &shadowing_disk_file)) {
+ switch (source_tree->DiskFileToVirtualFile(*proto, &virtual_file,
+ &shadowing_disk_file)) {
case DiskSourceTree::SUCCESS:
*proto = virtual_file;
break;
case DiskSourceTree::SHADOWED:
- std::cerr << *proto
- << ": Input is shadowed in the --proto_path by \""
+ std::cerr << *proto << ": Input is shadowed in the --proto_path by \""
<< shadowing_disk_file
<< "\". Either use the latter file as your input or reorder "
"the --proto_path so that the former file's location "
- "comes first." << std::endl;
+ "comes first."
+ << std::endl;
return false;
case DiskSourceTree::CANNOT_OPEN:
if (in_fallback_database) {
@@ -1242,8 +1240,8 @@
return true;
}
-CommandLineInterface::ParseArgumentStatus
-CommandLineInterface::ParseArguments(int argc, const char* const argv[]) {
+CommandLineInterface::ParseArgumentStatus CommandLineInterface::ParseArguments(
+ int argc, const char* const argv[]) {
executable_name_ = argv[0];
std::vector<std::string> arguments;
@@ -1285,8 +1283,7 @@
}
ParseArgumentStatus status = InterpretArgument(name, value);
- if (status != PARSE_ARGUMENT_DONE_AND_CONTINUE)
- return status;
+ if (status != PARSE_ARGUMENT_DONE_AND_CONTINUE) return status;
}
// Make sure each plugin option has a matching plugin output.
@@ -1298,7 +1295,8 @@
continue;
}
bool foundImplicitPlugin = false;
- for (std::vector<OutputDirective>::const_iterator j = output_directives_.begin();
+ for (std::vector<OutputDirective>::const_iterator j =
+ output_directives_.begin();
j != output_directives_.end(); ++j) {
if (j->generator == NULL) {
std::string plugin_name = PluginName(plugin_prefix_, j->name);
@@ -1357,11 +1355,13 @@
}
if (imports_in_descriptor_set_ && descriptor_set_out_name_.empty()) {
std::cerr << "--include_imports only makes sense when combined with "
- "--descriptor_set_out." << std::endl;
+ "--descriptor_set_out."
+ << std::endl;
}
if (source_info_in_descriptor_set_ && descriptor_set_out_name_.empty()) {
std::cerr << "--include_source_info only makes sense when combined with "
- "--descriptor_set_out." << std::endl;
+ "--descriptor_set_out."
+ << std::endl;
}
return PARSE_ARGUMENT_DONE_AND_CONTINUE;
@@ -1411,12 +1411,9 @@
return false;
}
- if (*name == "-h" || *name == "--help" ||
- *name == "--disallow_services" ||
- *name == "--include_imports" ||
- *name == "--include_source_info" ||
- *name == "--version" ||
- *name == "--decode_raw" ||
+ if (*name == "-h" || *name == "--help" || *name == "--disallow_services" ||
+ *name == "--include_imports" || *name == "--include_source_info" ||
+ *name == "--version" || *name == "--decode_raw" ||
*name == "--print_free_field_numbers") {
// HACK: These are the only flags that don't take a value.
// They probably should not be hard-coded like this but for now it's
@@ -1436,10 +1433,12 @@
if (value.empty()) {
std::cerr
<< "You seem to have passed an empty string as one of the "
- "arguments to " << executable_name_
+ "arguments to "
+ << executable_name_
<< ". This is actually "
"sort of hard to do. Congrats. Unfortunately it is not valid "
- "input so the program is going to die now." << std::endl;
+ "input so the program is going to die now."
+ << std::endl;
return PARSE_ARGUMENT_FAIL;
}
@@ -1469,7 +1468,8 @@
if (disk_path.empty()) {
std::cerr
<< "--proto_path passed empty directory name. (Use \".\" for "
- "current directory.)" << std::endl;
+ "current directory.)"
+ << std::endl;
return PARSE_ARGUMENT_FAIL;
}
@@ -1494,9 +1494,10 @@
} else if (name == "--direct_dependencies") {
if (direct_dependencies_explicitly_set_) {
- std::cerr << name << " may only be passed once. To specify multiple "
- "direct dependencies, pass them all as a single "
- "parameter separated by ':'."
+ std::cerr << name
+ << " may only be passed once. To specify multiple "
+ "direct dependencies, pass them all as a single "
+ "parameter separated by ':'."
<< std::endl;
return PARSE_ARGUMENT_FAIL;
}
@@ -1512,11 +1513,11 @@
} else if (name == "--descriptor_set_in") {
if (!descriptor_set_in_names_.empty()) {
- std::cerr << name << " may only be passed once. To specify multiple "
- "descriptor sets, pass them all as a single "
- "parameter separated by '"
- << CommandLineInterface::kPathSeparator << "'."
- << std::endl;
+ std::cerr << name
+ << " may only be passed once. To specify multiple "
+ "descriptor sets, pass them all as a single "
+ "parameter separated by '"
+ << CommandLineInterface::kPathSeparator << "'." << std::endl;
return PARSE_ARGUMENT_FAIL;
}
if (value.empty()) {
@@ -1545,7 +1546,8 @@
if (mode_ != MODE_COMPILE) {
std::cerr
<< "Cannot use --encode or --decode and generate descriptors at the "
- "same time." << std::endl;
+ "same time."
+ << std::endl;
return PARSE_ARGUMENT_FAIL;
}
descriptor_set_out_name_ = value;
@@ -1588,9 +1590,8 @@
if (!version_info_.empty()) {
std::cout << version_info_ << std::endl;
}
- std::cout << "libprotoc "
- << internal::VersionString(PROTOBUF_VERSION)
- << std::endl;
+ std::cout << "libprotoc " << internal::VersionString(PROTOBUF_VERSION)
+ << std::endl;
return PARSE_ARGUMENT_DONE_AND_EXIT; // Exit without running compiler.
} else if (name == "--disallow_services") {
@@ -1707,7 +1708,8 @@
// It's an output flag. Add it to the output directives.
if (mode_ != MODE_COMPILE) {
std::cerr << "Cannot use --encode, --decode or print .proto info and "
- "generate code at the same time." << std::endl;
+ "generate code at the same time."
+ << std::endl;
return PARSE_ARGUMENT_FAIL;
}
@@ -1743,71 +1745,120 @@
<<
"Usage: " << executable_name_
<< " [OPTION] PROTO_FILES\n"
-"Parse PROTO_FILES and generate output based on the options given:\n"
-" -IPATH, --proto_path=PATH Specify the directory in which to search for\n"
-" imports. May be specified multiple times;\n"
-" directories will be searched in order. If not\n"
-" given, the current working directory is used.\n"
-" If not found in any of the these directories,\n"
-" the --descriptor_set_in descriptors will be\n"
-" checked for required proto file.\n"
-" --version Show version info and exit.\n"
-" -h, --help Show this text and exit.\n"
-" --encode=MESSAGE_TYPE Read a text-format message of the given type\n"
-" from standard input and write it in binary\n"
-" to standard output. The message type must\n"
-" be defined in PROTO_FILES or their imports.\n"
-" --decode=MESSAGE_TYPE Read a binary message of the given type from\n"
-" standard input and write it in text format\n"
-" to standard output. The message type must\n"
-" be defined in PROTO_FILES or their imports.\n"
-" --decode_raw Read an arbitrary protocol message from\n"
-" standard input and write the raw tag/value\n"
-" pairs in text format to standard output. No\n"
-" PROTO_FILES should be given when using this\n"
-" flag.\n"
-" --descriptor_set_in=FILES Specifies a delimited list of FILES\n"
-" each containing a FileDescriptorSet (a\n"
-" protocol buffer defined in descriptor.proto).\n"
-" The FileDescriptor for each of the PROTO_FILES\n"
-" provided will be loaded from these\n"
-" FileDescriptorSets. If a FileDescriptor\n"
-" appears multiple times, the first occurrence\n"
-" will be used.\n"
-" -oFILE, Writes a FileDescriptorSet (a protocol buffer,\n"
-" --descriptor_set_out=FILE defined in descriptor.proto) containing all of\n"
-" the input files to FILE.\n"
-" --include_imports When using --descriptor_set_out, also include\n"
-" all dependencies of the input files in the\n"
-" set, so that the set is self-contained.\n"
-" --include_source_info When using --descriptor_set_out, do not strip\n"
-" SourceCodeInfo from the FileDescriptorProto.\n"
-" This results in vastly larger descriptors that\n"
-" include information about the original\n"
-" location of each decl in the source file as\n"
-" well as surrounding comments.\n"
-" --dependency_out=FILE Write a dependency output file in the format\n"
-" expected by make. This writes the transitive\n"
-" set of input file paths to FILE\n"
-" --error_format=FORMAT Set the format in which to print errors.\n"
-" FORMAT may be 'gcc' (the default) or 'msvs'\n"
-" (Microsoft Visual Studio format).\n"
-" --print_free_field_numbers Print the free field numbers of the messages\n"
-" defined in the given proto files. Groups share\n"
-" the same field number space with the parent \n"
-" message. Extension ranges are counted as \n"
-" occupied fields numbers.\n"
+ "Parse PROTO_FILES and generate output based on the options given:\n"
+ " -IPATH, --proto_path=PATH Specify the directory in which to "
+ "search for\n"
+ " imports. May be specified multiple "
+ "times;\n"
+ " directories will be searched in order. "
+ " If not\n"
+ " given, the current working directory "
+ "is used.\n"
+ " If not found in any of the these "
+ "directories,\n"
+ " the --descriptor_set_in descriptors "
+ "will be\n"
+ " checked for required proto file.\n"
+ " --version Show version info and exit.\n"
+ " -h, --help Show this text and exit.\n"
+ " --encode=MESSAGE_TYPE Read a text-format message of the "
+ "given type\n"
+ " from standard input and write it in "
+ "binary\n"
+ " to standard output. The message type "
+ "must\n"
+ " be defined in PROTO_FILES or their "
+ "imports.\n"
+ " --decode=MESSAGE_TYPE Read a binary message of the given "
+ "type from\n"
+ " standard input and write it in text "
+ "format\n"
+ " to standard output. The message type "
+ "must\n"
+ " be defined in PROTO_FILES or their "
+ "imports.\n"
+ " --decode_raw Read an arbitrary protocol message "
+ "from\n"
+ " standard input and write the raw "
+ "tag/value\n"
+ " pairs in text format to standard "
+ "output. No\n"
+ " PROTO_FILES should be given when using "
+ "this\n"
+ " flag.\n"
+ " --descriptor_set_in=FILES Specifies a delimited list of FILES\n"
+ " each containing a FileDescriptorSet "
+ "(a\n"
+ " protocol buffer defined in "
+ "descriptor.proto).\n"
+ " The FileDescriptor for each of the "
+ "PROTO_FILES\n"
+ " provided will be loaded from these\n"
+ " FileDescriptorSets. If a "
+ "FileDescriptor\n"
+ " appears multiple times, the first "
+ "occurrence\n"
+ " will be used.\n"
+ " -oFILE, Writes a FileDescriptorSet (a protocol "
+ "buffer,\n"
+ " --descriptor_set_out=FILE defined in descriptor.proto) "
+ "containing all of\n"
+ " the input files to FILE.\n"
+ " --include_imports When using --descriptor_set_out, also "
+ "include\n"
+ " all dependencies of the input files in "
+ "the\n"
+ " set, so that the set is "
+ "self-contained.\n"
+ " --include_source_info When using --descriptor_set_out, do "
+ "not strip\n"
+ " SourceCodeInfo from the "
+ "FileDescriptorProto.\n"
+ " This results in vastly larger "
+ "descriptors that\n"
+ " include information about the "
+ "original\n"
+ " location of each decl in the source "
+ "file as\n"
+ " well as surrounding comments.\n"
+ " --dependency_out=FILE Write a dependency output file in the "
+ "format\n"
+ " expected by make. This writes the "
+ "transitive\n"
+ " set of input file paths to FILE\n"
+ " --error_format=FORMAT Set the format in which to print "
+ "errors.\n"
+ " FORMAT may be 'gcc' (the default) or "
+ "'msvs'\n"
+ " (Microsoft Visual Studio format).\n"
+ " --print_free_field_numbers Print the free field numbers of the "
+ "messages\n"
+ " defined in the given proto files. "
+ "Groups share\n"
+ " the same field number space with the "
+ "parent \n"
+ " message. Extension ranges are counted "
+ "as \n"
+ " occupied fields numbers.\n"
<< std::endl;
if (!plugin_prefix_.empty()) {
- std::cout <<
-" --plugin=EXECUTABLE Specifies a plugin executable to use.\n"
-" Normally, protoc searches the PATH for\n"
-" plugins, but you may specify additional\n"
-" executables not in the path using this flag.\n"
-" Additionally, EXECUTABLE may be of the form\n"
-" NAME=PATH, in which case the given plugin name\n"
-" is mapped to the given executable even if\n"
-" the executable's own name differs." << std::endl;
+ std::cout
+ << " --plugin=EXECUTABLE Specifies a plugin executable to "
+ "use.\n"
+ " Normally, protoc searches the PATH "
+ "for\n"
+ " plugins, but you may specify "
+ "additional\n"
+ " executables not in the path using "
+ "this flag.\n"
+ " Additionally, EXECUTABLE may be of "
+ "the form\n"
+ " NAME=PATH, in which case the given "
+ "plugin name\n"
+ " is mapped to the given executable "
+ "even if\n"
+ " the executable's own name differs."
+ << std::endl;
}
for (GeneratorMap::iterator iter = generators_by_flag_name_.begin();
@@ -1820,20 +1871,30 @@
' ') // Spaces for alignment.
<< iter->second.help_text << std::endl;
}
- std::cout <<
-" @<filename> Read options and filenames from file. If a\n"
-" relative file path is specified, the file\n"
-" will be searched in the working directory.\n"
-" The --proto_path option will not affect how\n"
-" this argument file is searched. Content of\n"
-" the file will be expanded in the position of\n"
-" @<filename> as in the argument list. Note\n"
-" that shell expansion is not applied to the\n"
-" content of the file (i.e., you cannot use\n"
-" quotes, wildcards, escapes, commands, etc.).\n"
-" Each line corresponds to a single argument,\n"
-" even if it contains spaces."
- << std::endl;
+ std::cout << " @<filename> Read options and filenames from "
+ "file. If a\n"
+ " relative file path is specified, "
+ "the file\n"
+ " will be searched in the working "
+ "directory.\n"
+ " The --proto_path option will not "
+ "affect how\n"
+ " this argument file is searched. "
+ "Content of\n"
+ " the file will be expanded in the "
+ "position of\n"
+ " @<filename> as in the argument "
+ "list. Note\n"
+ " that shell expansion is not "
+ "applied to the\n"
+ " content of the file (i.e., you "
+ "cannot use\n"
+ " quotes, wildcards, escapes, "
+ "commands, etc.).\n"
+ " Each line corresponds to a "
+ "single argument,\n"
+ " even if it contains spaces."
+ << std::endl;
}
bool CommandLineInterface::GenerateOutput(
@@ -1856,8 +1917,7 @@
}
parameters.append(plugin_parameters_[plugin_name]);
}
- if (!GeneratePluginOutput(parsed_files, plugin_name,
- parameters,
+ if (!GeneratePluginOutput(parsed_files, plugin_name, parameters,
generator_context, &error)) {
std::cerr << output_directive.name << ": " << error << std::endl;
return false;
@@ -1871,8 +1931,8 @@
}
parameters.append(generator_parameters_[output_directive.name]);
}
- if (!output_directive.generator->GenerateAll(
- parsed_files, parameters, generator_context, &error)) {
+ if (!output_directive.generator->GenerateAll(parsed_files, parameters,
+ generator_context, &error)) {
// Generator returned an error.
std::cerr << output_directive.name << ": " << error << std::endl;
return false;
@@ -1890,10 +1950,7 @@
std::set<const FileDescriptor*> already_seen;
for (int i = 0; i < parsed_files.size(); i++) {
- GetTransitiveDependencies(parsed_files[i],
- false,
- false,
- &already_seen,
+ GetTransitiveDependencies(parsed_files[i], false, false, &already_seen,
file_set.mutable_file());
}
@@ -2022,8 +2079,9 @@
current_output.reset(generator_context->Open(output_file.name()));
} else if (current_output == NULL) {
*error = strings::Substitute(
- "$0: First file chunk returned by plugin did not specify a file name.",
- plugin_name);
+ "$0: First file chunk returned by plugin did not specify a file "
+ "name.",
+ plugin_name);
return false;
}
@@ -2132,8 +2190,8 @@
for (int i = 0; i < parsed_files.size(); i++) {
GetTransitiveDependencies(parsed_files[i],
true, // Include json_name
- source_info_in_descriptor_set_,
- &already_seen, file_set.mutable_file());
+ source_info_in_descriptor_set_, &already_seen,
+ file_set.mutable_file());
}
int fd;
@@ -2164,8 +2222,7 @@
}
void CommandLineInterface::GetTransitiveDependencies(
- const FileDescriptor* file,
- bool include_json_name,
+ const FileDescriptor* file, bool include_json_name,
bool include_source_code_info,
std::set<const FileDescriptor*>* already_seen,
RepeatedPtrField<FileDescriptorProto>* output) {
@@ -2176,10 +2233,8 @@
// Add all dependencies.
for (int i = 0; i < file->dependency_count(); i++) {
- GetTransitiveDependencies(file->dependency(i),
- include_json_name,
- include_source_code_info,
- already_seen, output);
+ GetTransitiveDependencies(file->dependency(i), include_json_name,
+ include_source_code_info, already_seen, output);
}
// Add this file.
@@ -2291,8 +2346,7 @@
} // namespace
-void CommandLineInterface::PrintFreeFieldNumbers(
- const Descriptor* descriptor) {
+void CommandLineInterface::PrintFreeFieldNumbers(const Descriptor* descriptor) {
std::set<FieldRange> ranges;
std::vector<const Descriptor*> nested_messages;
GatherOccupiedFieldRanges(descriptor, &ranges, &nested_messages);
@@ -2304,7 +2358,6 @@
}
-
} // namespace compiler
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/compiler/command_line_interface.h b/src/google/protobuf/compiler/command_line_interface.h
index 520585c..6c9893f 100644
--- a/src/google/protobuf/compiler/command_line_interface.h
+++ b/src/google/protobuf/compiler/command_line_interface.h
@@ -52,14 +52,15 @@
namespace google {
namespace protobuf {
-class Descriptor; // descriptor.h
-class DescriptorDatabase; // descriptor_database.h
-class DescriptorPool; // descriptor.h
-class FileDescriptor; // descriptor.h
-class FileDescriptorSet; // descriptor.h
-class FileDescriptorProto; // descriptor.pb.h
-template<typename T> class RepeatedPtrField; // repeated_field.h
-class SimpleDescriptorDatabase; // descriptor_database.h
+class Descriptor; // descriptor.h
+class DescriptorDatabase; // descriptor_database.h
+class DescriptorPool; // descriptor.h
+class FileDescriptor; // descriptor.h
+class FileDescriptorSet; // descriptor.h
+class FileDescriptorProto; // descriptor.pb.h
+template <typename T>
+class RepeatedPtrField; // repeated_field.h
+class SimpleDescriptorDatabase; // descriptor_database.h
namespace compiler {
@@ -307,8 +308,7 @@
// If include_json_name is true, populate the json_name field of
// FieldDescriptorProto for all fields.
static void GetTransitiveDependencies(
- const FileDescriptor* file,
- bool include_json_name,
+ const FileDescriptor* file, bool include_json_name,
bool include_source_code_info,
std::set<const FileDescriptor*>* already_seen,
RepeatedPtrField<FileDescriptorProto>* output);
@@ -374,15 +374,15 @@
Mode mode_;
enum PrintMode {
- PRINT_NONE, // Not in MODE_PRINT
- PRINT_FREE_FIELDS, // --print_free_fields
+ PRINT_NONE, // Not in MODE_PRINT
+ PRINT_FREE_FIELDS, // --print_free_fields
};
PrintMode print_mode_;
enum ErrorFormat {
- ERROR_FORMAT_GCC, // GCC error output format (default).
- ERROR_FORMAT_MSVS // Visual Studio output (--error_format=msvs).
+ ERROR_FORMAT_GCC, // GCC error output format (default).
+ ERROR_FORMAT_MSVS // Visual Studio output (--error_format=msvs).
};
ErrorFormat error_format_;
@@ -403,8 +403,8 @@
// output_directives_ lists all the files we are supposed to output and what
// generator to use for each.
struct OutputDirective {
- std::string name; // E.g. "--foo_out"
- CodeGenerator* generator; // NULL for plugins
+ std::string name; // E.g. "--foo_out"
+ CodeGenerator* generator; // NULL for plugins
std::string parameter;
std::string output_location;
};
diff --git a/src/google/protobuf/compiler/command_line_interface_unittest.cc b/src/google/protobuf/compiler/command_line_interface_unittest.cc
index e4b393c..c6fad5f 100644
--- a/src/google/protobuf/compiler/command_line_interface_unittest.cc
+++ b/src/google/protobuf/compiler/command_line_interface_unittest.cc
@@ -51,6 +51,7 @@
#include <google/protobuf/compiler/command_line_interface.h>
#include <google/protobuf/test_util2.h>
#include <google/protobuf/unittest.pb.h>
+#include <google/protobuf/io/io_win32.h>
#include <google/protobuf/io/printer.h>
#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/descriptor.pb.h>
@@ -62,7 +63,6 @@
#include <gtest/gtest.h>
#include <google/protobuf/stubs/strutil.h>
-#include <google/protobuf/stubs/io_win32.h>
namespace google {
namespace protobuf {
@@ -71,12 +71,12 @@
#if defined(_WIN32)
// DO NOT include <io.h>, instead create functions in io_win32.{h,cc} and import
// them like we do below.
-using google::protobuf::internal::win32::access;
-using google::protobuf::internal::win32::dup;
-using google::protobuf::internal::win32::dup2;
-using google::protobuf::internal::win32::close;
-using google::protobuf::internal::win32::open;
-using google::protobuf::internal::win32::write;
+using google::protobuf::io::win32::access;
+using google::protobuf::io::win32::close;
+using google::protobuf::io::win32::dup;
+using google::protobuf::io::win32::dup2;
+using google::protobuf::io::win32::open;
+using google::protobuf::io::win32::write;
#endif
// Disable the whole test when we use tcmalloc for "draconian" heap checks, in
@@ -122,7 +122,7 @@
void SwitchToTempDirectory() {
File::ChangeWorkingDirectory(temp_directory_);
}
-#else // !PROTOBUF_OPENSOURCE
+#else // !PROTOBUF_OPENSOURCE
// TODO(teboring): Figure out how to change and get working directory in
// google3.
#endif // !PROTOBUF_OPENSOURCE
@@ -303,21 +303,24 @@
plugin_path = GOOGLE_PROTOBUF_TEST_PLUGIN_PATH;
#else
const char* possible_paths[] = {
- // When building with shared libraries, libtool hides the real executable
- // in .libs and puts a fake wrapper in the current directory.
- // Unfortunately, due to an apparent bug on Cygwin/MinGW, if one program
- // wrapped in this way (e.g. protobuf-tests.exe) tries to execute another
- // program wrapped in this way (e.g. test_plugin.exe), the latter fails
- // with error code 127 and no explanation message. Presumably the problem
- // is that the wrapper for protobuf-tests.exe set some environment
- // variables that confuse the wrapper for test_plugin.exe. Luckily, it
- // turns out that if we simply invoke the wrapped test_plugin.exe
- // directly, it works -- I guess the environment variables set by the
- // protobuf-tests.exe wrapper happen to be correct for it too. So we do
- // that.
- ".libs/test_plugin.exe", // Win32 w/autotool (Cygwin / MinGW)
- "test_plugin.exe", // Other Win32 (MSVC)
- "test_plugin", // Unix
+ // When building with shared libraries, libtool hides the real
+ // executable
+ // in .libs and puts a fake wrapper in the current directory.
+ // Unfortunately, due to an apparent bug on Cygwin/MinGW, if one program
+ // wrapped in this way (e.g. protobuf-tests.exe) tries to execute
+ // another
+ // program wrapped in this way (e.g. test_plugin.exe), the latter fails
+ // with error code 127 and no explanation message. Presumably the
+ // problem
+ // is that the wrapper for protobuf-tests.exe set some environment
+ // variables that confuse the wrapper for test_plugin.exe. Luckily, it
+ // turns out that if we simply invoke the wrapped test_plugin.exe
+ // directly, it works -- I guess the environment variables set by the
+ // protobuf-tests.exe wrapper happen to be correct for it too. So we do
+ // that.
+ ".libs/test_plugin.exe", // Win32 w/autotool (Cygwin / MinGW)
+ "test_plugin.exe", // Other Win32 (MSVC)
+ "test_plugin", // Unix
};
for (int i = 0; i < GOOGLE_ARRAYSIZE(possible_paths); i++) {
if (access(possible_paths[i], F_OK) == 0) {
@@ -335,7 +338,7 @@
}
}
- std::unique_ptr<const char * []> argv(new const char* [args.size()]);
+ std::unique_ptr<const char*[]> argv(new const char*[args.size()]);
for (int i = 0; i < args.size(); i++) {
args[i] = StringReplace(args[i], "$tmpdir", temp_directory_, true);
@@ -419,36 +422,34 @@
void CommandLineInterfaceTest::ExpectGenerated(
const std::string& generator_name, const std::string& parameter,
const std::string& proto_name, const std::string& message_name) {
- MockCodeGenerator::ExpectGenerated(
- generator_name, parameter, "", proto_name, message_name, proto_name,
- temp_directory_);
+ MockCodeGenerator::ExpectGenerated(generator_name, parameter, "", proto_name,
+ message_name, proto_name, temp_directory_);
}
void CommandLineInterfaceTest::ExpectGenerated(
const std::string& generator_name, const std::string& parameter,
const std::string& proto_name, const std::string& message_name,
const std::string& output_directory) {
- MockCodeGenerator::ExpectGenerated(
- generator_name, parameter, "", proto_name, message_name, proto_name,
- temp_directory_ + "/" + output_directory);
+ MockCodeGenerator::ExpectGenerated(generator_name, parameter, "", proto_name,
+ message_name, proto_name,
+ temp_directory_ + "/" + output_directory);
}
void CommandLineInterfaceTest::ExpectGeneratedWithMultipleInputs(
const std::string& generator_name, const std::string& all_proto_names,
const std::string& proto_name, const std::string& message_name) {
- MockCodeGenerator::ExpectGenerated(
- generator_name, "", "", proto_name, message_name,
- all_proto_names,
- temp_directory_);
+ MockCodeGenerator::ExpectGenerated(generator_name, "", "", proto_name,
+ message_name, all_proto_names,
+ temp_directory_);
}
void CommandLineInterfaceTest::ExpectGeneratedWithInsertions(
const std::string& generator_name, const std::string& parameter,
const std::string& insertions, const std::string& proto_name,
const std::string& message_name) {
- MockCodeGenerator::ExpectGenerated(
- generator_name, parameter, insertions, proto_name, message_name,
- proto_name, temp_directory_);
+ MockCodeGenerator::ExpectGenerated(generator_name, parameter, insertions,
+ proto_name, message_name, proto_name,
+ temp_directory_);
}
void CommandLineInterfaceTest::CheckGeneratedAnnotations(
@@ -489,8 +490,8 @@
void CommandLineInterfaceTest::ExpectCapturedStdoutSubstringWithZeroReturnCode(
const std::string& expected_substring) {
EXPECT_EQ(0, return_code_);
- EXPECT_PRED_FORMAT2(
- testing::IsSubstring, expected_substring, captured_stdout_);
+ EXPECT_PRED_FORMAT2(testing::IsSubstring, expected_substring,
+ captured_stdout_);
}
void CommandLineInterfaceTest::ExpectFileContent(const std::string& filename,
@@ -509,8 +510,8 @@
// Test that the common case works.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -539,8 +540,8 @@
// Test that basic plugins work.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --plug_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -570,8 +571,8 @@
// Invoke a generator and a plugin at the same time.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --test_out=$tmpdir --plug_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -603,11 +604,11 @@
// Test parsing multiple input files.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "message Bar {}\n");
+ "syntax = \"proto2\";\n"
+ "message Bar {}\n");
Run("protocol_compiler --test_out=$tmpdir --plug_out=$tmpdir "
"--proto_path=$tmpdir foo.proto bar.proto");
@@ -655,17 +656,17 @@
// Test parsing multiple input files with an import of a separate file.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "import \"baz.proto\";\n"
- "message Bar {\n"
- " optional Baz a = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"baz.proto\";\n"
+ "message Bar {\n"
+ " optional Baz a = 1;\n"
+ "}\n");
CreateTempFile("baz.proto",
- "syntax = \"proto2\";\n"
- "message Baz {}\n");
+ "syntax = \"proto2\";\n"
+ "message Baz {}\n");
Run("protocol_compiler --test_out=$tmpdir --plug_out=$tmpdir "
"--proto_path=$tmpdir foo.proto bar.proto");
@@ -841,8 +842,8 @@
// Test that when we output to a sub-directory, it is created.
CreateTempFile("bar/baz/foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempDir("out");
CreateTempDir("plugout");
@@ -858,8 +859,8 @@
// Test that generator parameters are correctly parsed from the command line.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --test_out=TestParameter:$tmpdir "
"--plug_out=TestPluginParameter:$tmpdir "
@@ -875,8 +876,8 @@
// correctly passed to the code generator.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
// Create the "a" and "b" sub-directories.
CreateTempDir("a");
CreateTempDir("b");
@@ -890,10 +891,10 @@
"--proto_path=$tmpdir foo.proto");
ExpectNoErrors();
- ExpectGenerated(
- "test_generator", "bar,foo1,foo2,foo3", "foo.proto", "Foo", "a");
- ExpectGenerated(
- "test_generator", "baz,foo1,foo2,foo3", "foo.proto", "Foo", "b");
+ ExpectGenerated("test_generator", "bar,foo1,foo2,foo3", "foo.proto", "Foo",
+ "a");
+ ExpectGenerated("test_generator", "baz,foo1,foo2,foo3", "foo.proto", "Foo",
+ "b");
}
TEST_F(CommandLineInterfaceTest, ExtraPluginParameters) {
@@ -901,8 +902,8 @@
// correctly passed to the code generator.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
// Create the "a" and "b" sub-directories.
CreateTempDir("a");
CreateTempDir("b");
@@ -916,16 +917,14 @@
"--proto_path=$tmpdir foo.proto");
ExpectNoErrors();
- ExpectGenerated(
- "test_plugin", "bar,foo1,foo2,foo3", "foo.proto", "Foo", "a");
- ExpectGenerated(
- "test_plugin", "baz,foo1,foo2,foo3", "foo.proto", "Foo", "b");
+ ExpectGenerated("test_plugin", "bar,foo1,foo2,foo3", "foo.proto", "Foo", "a");
+ ExpectGenerated("test_plugin", "baz,foo1,foo2,foo3", "foo.proto", "Foo", "b");
}
TEST_F(CommandLineInterfaceTest, UnrecognizedExtraParameters) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --plug_out=TestParameter:$tmpdir "
"--unknown_plug_a_opt=Foo "
@@ -948,8 +947,8 @@
// directives appear, they both are reported.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --plug_out=TestParameter:$tmpdir "
"--xyz_opt=foo=bar --xyz_out=$tmpdir "
@@ -964,8 +963,8 @@
// Test running a generator that inserts code into another's output.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler "
"--test_out=TestParameter:$tmpdir "
@@ -975,12 +974,12 @@
"--proto_path=$tmpdir foo.proto");
ExpectNoErrors();
- ExpectGeneratedWithInsertions(
- "test_generator", "TestParameter", "test_generator,test_plugin",
- "foo.proto", "Foo");
- ExpectGeneratedWithInsertions(
- "test_plugin", "TestPluginParameter", "test_generator,test_plugin",
- "foo.proto", "Foo");
+ ExpectGeneratedWithInsertions("test_generator", "TestParameter",
+ "test_generator,test_plugin", "foo.proto",
+ "Foo");
+ ExpectGeneratedWithInsertions("test_plugin", "TestPluginParameter",
+ "test_generator,test_plugin", "foo.proto",
+ "Foo");
}
TEST_F(CommandLineInterfaceTest, InsertWithAnnotationFixup) {
@@ -1007,8 +1006,7 @@
TEST_F(CommandLineInterfaceTest, WindowsOutputPath) {
// Test that the output path can be a Windows-style path.
- CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n");
+ CreateTempFile("foo.proto", "syntax = \"proto2\";\n");
Run("protocol_compiler --null_out=C:\\ "
"--proto_path=$tmpdir foo.proto");
@@ -1020,8 +1018,7 @@
TEST_F(CommandLineInterfaceTest, WindowsOutputPathAndParameter) {
// Test that we can have a windows-style output path and a parameter.
- CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n");
+ CreateTempFile("foo.proto", "syntax = \"proto2\";\n");
Run("protocol_compiler --null_out=bar:C:\\ "
"--proto_path=$tmpdir foo.proto");
@@ -1035,8 +1032,8 @@
// doesn't work on their system.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --test_out=$tmpdir\\ "
"--proto_path=$tmpdir\\ foo.proto");
@@ -1056,14 +1053,14 @@
// Test that specifying multiple directories in the proto search path works.
CreateTempFile("b/bar.proto",
- "syntax = \"proto2\";\n"
- "message Bar {}\n");
+ "syntax = \"proto2\";\n"
+ "message Bar {}\n");
CreateTempFile("a/foo.proto",
- "syntax = \"proto2\";\n"
- "import \"bar.proto\";\n"
- "message Foo {\n"
- " optional Bar a = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"bar.proto\";\n"
+ "message Foo {\n"
+ " optional Bar a = 1;\n"
+ "}\n");
CreateTempFile("b/foo.proto", "this should not be parsed\n");
Run("protocol_compiler --test_out=$tmpdir "
@@ -1077,14 +1074,14 @@
// Same as PathLookup, but we provide the proto_path in a single flag.
CreateTempFile("b/bar.proto",
- "syntax = \"proto2\";\n"
- "message Bar {}\n");
+ "syntax = \"proto2\";\n"
+ "message Bar {}\n");
CreateTempFile("a/foo.proto",
- "syntax = \"proto2\";\n"
- "import \"bar.proto\";\n"
- "message Foo {\n"
- " optional Bar a = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"bar.proto\";\n"
+ "message Foo {\n"
+ " optional Bar a = 1;\n"
+ "}\n");
CreateTempFile("b/foo.proto", "this should not be parsed\n");
Run(strings::Substitute(
@@ -1100,8 +1097,8 @@
// Test setting up a search path mapping a directory to a non-root location.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=bar=$tmpdir bar/foo.proto");
@@ -1115,8 +1112,8 @@
CreateTempDir("with=sign");
CreateTempFile("with=sign/foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir/with=sign foo.proto");
@@ -1130,8 +1127,8 @@
// each with a different output directory.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
// Create the "a" and "b" sub-directories.
CreateTempDir("a");
CreateTempDir("b");
@@ -1151,8 +1148,8 @@
// services.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --disallow_services --test_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -1165,9 +1162,9 @@
// Test that --disallow_services produces an error when there are services.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n"
- "service Bar {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n"
+ "service Bar {}\n");
Run("protocol_compiler --disallow_services --test_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -1179,9 +1176,9 @@
// Test that services work fine as long as --disallow_services is not used.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n"
- "service Bar {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n"
+ "service Bar {}\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -1263,8 +1260,7 @@
}
TEST_F(CommandLineInterfaceTest, DirectDependencies_ProvidedMultipleTimes) {
- CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n");
+ CreateTempFile("foo.proto", "syntax = \"proto2\";\n");
Run("protocol_compiler --test_out=$tmpdir --proto_path=$tmpdir "
"--direct_dependencies=bar.proto --direct_dependencies=bla.proto "
@@ -1301,8 +1297,8 @@
// Test that we can accept working-directory-relative input files.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir $tmpdir/foo.proto");
@@ -1313,14 +1309,14 @@
TEST_F(CommandLineInterfaceTest, WriteDescriptorSet) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "import \"foo.proto\";\n"
- "message Bar {\n"
- " optional Foo foo = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"foo.proto\";\n"
+ "message Bar {\n"
+ " optional Foo foo = 1;\n"
+ "}\n");
Run("protocol_compiler --descriptor_set_out=$tmpdir/descriptor_set "
"--proto_path=$tmpdir bar.proto");
@@ -1342,20 +1338,20 @@
TEST_F(CommandLineInterfaceTest, WriteDescriptorSetWithDuplicates) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "import \"foo.proto\";\n"
- "message Bar {\n"
- " optional Foo foo = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"foo.proto\";\n"
+ "message Bar {\n"
+ " optional Foo foo = 1;\n"
+ "}\n");
CreateTempFile("baz.proto",
- "syntax = \"proto2\";\n"
- "import \"foo.proto\";\n"
- "message Baz {\n"
- " optional Foo foo = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"foo.proto\";\n"
+ "message Baz {\n"
+ " optional Foo foo = 1;\n"
+ "}\n");
Run("protocol_compiler --descriptor_set_out=$tmpdir/descriptor_set "
"--proto_path=$tmpdir bar.proto foo.proto bar.proto baz.proto");
@@ -1381,14 +1377,14 @@
TEST_F(CommandLineInterfaceTest, WriteDescriptorSetWithSourceInfo) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "import \"foo.proto\";\n"
- "message Bar {\n"
- " optional Foo foo = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"foo.proto\";\n"
+ "message Bar {\n"
+ " optional Foo foo = 1;\n"
+ "}\n");
Run("protocol_compiler --descriptor_set_out=$tmpdir/descriptor_set "
"--include_source_info --proto_path=$tmpdir bar.proto");
@@ -1406,14 +1402,14 @@
TEST_F(CommandLineInterfaceTest, WriteTransitiveDescriptorSet) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "import \"foo.proto\";\n"
- "message Bar {\n"
- " optional Foo foo = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"foo.proto\";\n"
+ "message Bar {\n"
+ " optional Foo foo = 1;\n"
+ "}\n");
Run("protocol_compiler --descriptor_set_out=$tmpdir/descriptor_set "
"--include_imports --proto_path=$tmpdir bar.proto");
@@ -1437,14 +1433,14 @@
TEST_F(CommandLineInterfaceTest, WriteTransitiveDescriptorSetWithSourceInfo) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "import \"foo.proto\";\n"
- "message Bar {\n"
- " optional Foo foo = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"foo.proto\";\n"
+ "message Bar {\n"
+ " optional Foo foo = 1;\n"
+ "}\n");
Run("protocol_compiler --descriptor_set_out=$tmpdir/descriptor_set "
"--include_imports --include_source_info --proto_path=$tmpdir bar.proto");
@@ -1471,14 +1467,14 @@
#else
TEST_F(CommandLineInterfaceTest, WriteDependencyManifestFileGivenTwoInputs) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "import \"foo.proto\";\n"
- "message Bar {\n"
- " optional Foo foo = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"foo.proto\";\n"
+ "message Bar {\n"
+ " optional Foo foo = 1;\n"
+ "}\n");
Run("protocol_compiler --dependency_out=$tmpdir/manifest "
"--test_out=$tmpdir --proto_path=$tmpdir bar.proto foo.proto");
@@ -1490,14 +1486,14 @@
#ifdef PROTOBUF_OPENSOURCE
TEST_F(CommandLineInterfaceTest, WriteDependencyManifestFile) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "import \"foo.proto\";\n"
- "message Bar {\n"
- " optional Foo foo = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"foo.proto\";\n"
+ "message Bar {\n"
+ " optional Foo foo = 1;\n"
+ "}\n");
std::string current_working_directory = getcwd(NULL, 0);
SwitchToTempDirectory();
@@ -1520,14 +1516,14 @@
TEST_F(CommandLineInterfaceTest, WriteDependencyManifestFileForAbsolutePath) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "import \"foo.proto\";\n"
- "message Bar {\n"
- " optional Foo foo = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"foo.proto\";\n"
+ "message Bar {\n"
+ " optional Foo foo = 1;\n"
+ "}\n");
Run("protocol_compiler --dependency_out=$tmpdir/manifest "
"--test_out=$tmpdir --proto_path=$tmpdir bar.proto");
@@ -1544,11 +1540,11 @@
// Test parsing multiple input files using an argument file.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "message Bar {}\n");
+ "syntax = \"proto2\";\n"
+ "message Bar {}\n");
CreateTempFile("arguments.txt",
"--test_out=$tmpdir\n"
"--plug_out=$tmpdir\n"
@@ -1577,14 +1573,14 @@
// Test that parse errors are reported.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "badsyntax\n");
+ "syntax = \"proto2\";\n"
+ "badsyntax\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
ExpectErrorText(
- "foo.proto:2:1: Expected top-level statement (e.g. \"message\").\n");
+ "foo.proto:2:1: Expected top-level statement (e.g. \"message\").\n");
}
TEST_F(CommandLineInterfaceTest, ParseErrors_DescriptorSetIn) {
@@ -1594,8 +1590,7 @@
Run("protocol_compiler --test_out=$tmpdir "
"--descriptor_set_in=$tmpdir/foo.bin foo.proto");
- ExpectErrorText(
- "$tmpdir/foo.bin: Unable to parse.\n");
+ ExpectErrorText("$tmpdir/foo.bin: Unable to parse.\n");
}
TEST_F(CommandLineInterfaceTest, ParseErrorsMultipleFiles) {
@@ -1605,37 +1600,38 @@
// two ways: Directly and through baz.proto. bar.proto's errors should
// only be reported once.
CreateTempFile("bar.proto",
- "syntax = \"proto2\";\n"
- "badsyntax\n");
+ "syntax = \"proto2\";\n"
+ "badsyntax\n");
CreateTempFile("baz.proto",
- "syntax = \"proto2\";\n"
- "import \"bar.proto\";\n");
+ "syntax = \"proto2\";\n"
+ "import \"bar.proto\";\n");
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "import \"bar.proto\";\n"
- "import \"baz.proto\";\n");
+ "syntax = \"proto2\";\n"
+ "import \"bar.proto\";\n"
+ "import \"baz.proto\";\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
ExpectErrorText(
- "bar.proto:2:1: Expected top-level statement (e.g. \"message\").\n"
- "baz.proto: Import \"bar.proto\" was not found or had errors.\n"
- "foo.proto: Import \"bar.proto\" was not found or had errors.\n"
- "foo.proto: Import \"baz.proto\" was not found or had errors.\n");
+ "bar.proto:2:1: Expected top-level statement (e.g. \"message\").\n"
+ "baz.proto:2:1: Import \"bar.proto\" was not found or had errors.\n"
+ "foo.proto:2:1: Import \"bar.proto\" was not found or had errors.\n"
+ "foo.proto:3:1: Import \"baz.proto\" was not found or had errors.\n");
}
TEST_F(CommandLineInterfaceTest, RecursiveImportFails) {
// Create a proto file that imports itself.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "import \"foo.proto\";\n");
+ "syntax = \"proto2\";\n"
+ "import \"foo.proto\";\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
ExpectErrorSubstring(
- "foo.proto: File recursively imports itself: foo.proto -> foo.proto\n");
+ "foo.proto:2:1: File recursively imports itself: "
+ "foo.proto -> foo.proto\n");
}
TEST_F(CommandLineInterfaceTest, InputNotFoundError) {
@@ -1653,8 +1649,7 @@
Run("protocol_compiler --test_out=$tmpdir "
"--descriptor_set_in=$tmpdir/foo.bin foo.proto");
- ExpectErrorText(
- "$tmpdir/foo.bin: No such file or directory\n");
+ ExpectErrorText("$tmpdir/foo.bin: No such file or directory\n");
}
TEST_F(CommandLineInterfaceTest, CwdRelativeInputNotFoundError) {
@@ -1664,8 +1659,7 @@
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir $tmpdir/foo.proto");
- ExpectErrorText(
- "$tmpdir/foo.proto: No such file or directory\n");
+ ExpectErrorText("$tmpdir/foo.proto: No such file or directory\n");
}
TEST_F(CommandLineInterfaceTest, CwdRelativeInputNotMappedError) {
@@ -1673,8 +1667,8 @@
// mapped to a virtual path.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
// Create a directory called "bar" so that we can point --proto_path at it.
CreateTempFile("bar/dummy", "");
@@ -1683,7 +1677,7 @@
"--proto_path=$tmpdir/bar $tmpdir/foo.proto");
ExpectErrorText(
- "$tmpdir/foo.proto: File does not reside within any path "
+ "$tmpdir/foo.proto: File does not reside within any path "
"specified using --proto_path (or -I). You must specify a "
"--proto_path which encompasses this file. Note that the "
"proto_path must be an exact prefix of the .proto file "
@@ -1702,8 +1696,7 @@
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir/bar $tmpdir/foo.proto");
- ExpectErrorText(
- "$tmpdir/foo.proto: No such file or directory\n");
+ ExpectErrorText("$tmpdir/foo.proto: No such file or directory\n");
}
TEST_F(CommandLineInterfaceTest, CwdRelativeInputShadowedError) {
@@ -1711,21 +1704,21 @@
// by another file in the virtual path.
CreateTempFile("foo/foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
CreateTempFile("bar/foo.proto",
- "syntax = \"proto2\";\n"
- "message Bar {}\n");
+ "syntax = \"proto2\";\n"
+ "message Bar {}\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir/foo --proto_path=$tmpdir/bar "
"$tmpdir/bar/foo.proto");
ExpectErrorText(
- "$tmpdir/bar/foo.proto: Input is shadowed in the --proto_path "
- "by \"$tmpdir/foo/foo.proto\". Either use the latter "
- "file as your input or reorder the --proto_path so that the "
- "former file's location comes first.\n");
+ "$tmpdir/bar/foo.proto: Input is shadowed in the --proto_path "
+ "by \"$tmpdir/foo/foo.proto\". Either use the latter "
+ "file as your input or reorder the --proto_path so that the "
+ "former file's location comes first.\n");
}
TEST_F(CommandLineInterfaceTest, ProtoPathNotFoundError) {
@@ -1812,8 +1805,8 @@
TEST_F(CommandLineInterfaceTest, MissingOutputError) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --proto_path=$tmpdir foo.proto");
@@ -1822,8 +1815,8 @@
TEST_F(CommandLineInterfaceTest, OutputWriteError) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
std::string output_file =
MockCodeGenerator::GetOutputFileName("test_generator", "foo.proto");
@@ -1851,8 +1844,8 @@
TEST_F(CommandLineInterfaceTest, PluginOutputWriteError) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
std::string output_file =
MockCodeGenerator::GetOutputFileName("test_plugin", "foo.proto");
@@ -1875,8 +1868,8 @@
TEST_F(CommandLineInterfaceTest, OutputDirectoryNotFoundError) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --test_out=$tmpdir/nosuchdir "
"--proto_path=$tmpdir foo.proto");
@@ -1886,8 +1879,8 @@
TEST_F(CommandLineInterfaceTest, PluginOutputDirectoryNotFoundError) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --plug_out=$tmpdir/nosuchdir "
"--proto_path=$tmpdir foo.proto");
@@ -1897,8 +1890,8 @@
TEST_F(CommandLineInterfaceTest, OutputDirectoryIsFileError) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --test_out=$tmpdir/foo.proto "
"--proto_path=$tmpdir foo.proto");
@@ -1915,8 +1908,8 @@
TEST_F(CommandLineInterfaceTest, GeneratorError) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message MockCodeGenerator_Error {}\n");
+ "syntax = \"proto2\";\n"
+ "message MockCodeGenerator_Error {}\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -1929,8 +1922,8 @@
// Test a generator plugin that returns an error.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message MockCodeGenerator_Error {}\n");
+ "syntax = \"proto2\";\n"
+ "message MockCodeGenerator_Error {}\n");
Run("protocol_compiler --plug_out=TestParameter:$tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -1943,8 +1936,8 @@
// Test a generator plugin that exits with an error code.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message MockCodeGenerator_Exit {}\n");
+ "syntax = \"proto2\";\n"
+ "message MockCodeGenerator_Exit {}\n");
Run("protocol_compiler --plug_out=TestParameter:$tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -1958,8 +1951,8 @@
// Test a generator plugin that crashes.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message MockCodeGenerator_Abort {}\n");
+ "syntax = \"proto2\";\n"
+ "message MockCodeGenerator_Abort {}\n");
Run("protocol_compiler --plug_out=TestParameter:$tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -1973,15 +1966,14 @@
"--plug_out: prefix-gen-plug: Plugin failed with status code");
#else
// Don't depend on the exact signal number.
- ExpectErrorSubstring(
- "--plug_out: prefix-gen-plug: Plugin killed by signal");
+ ExpectErrorSubstring("--plug_out: prefix-gen-plug: Plugin killed by signal");
#endif
}
TEST_F(CommandLineInterfaceTest, PluginReceivesSourceCodeInfo) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message MockCodeGenerator_HasSourceCodeInfo {}\n");
+ "syntax = \"proto2\";\n"
+ "message MockCodeGenerator_HasSourceCodeInfo {}\n");
Run("protocol_compiler --plug_out=$tmpdir --proto_path=$tmpdir foo.proto");
@@ -1991,10 +1983,10 @@
TEST_F(CommandLineInterfaceTest, PluginReceivesJsonName) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message MockCodeGenerator_HasJsonName {\n"
- " optional int32 value = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "message MockCodeGenerator_HasJsonName {\n"
+ " optional int32 value = 1;\n"
+ "}\n");
Run("protocol_compiler --plug_out=$tmpdir --proto_path=$tmpdir foo.proto");
@@ -2003,25 +1995,24 @@
TEST_F(CommandLineInterfaceTest, PluginReceivesCompilerVersion) {
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message MockCodeGenerator_ShowVersionNumber {\n"
- " optional int32 value = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "message MockCodeGenerator_ShowVersionNumber {\n"
+ " optional int32 value = 1;\n"
+ "}\n");
Run("protocol_compiler --plug_out=$tmpdir --proto_path=$tmpdir foo.proto");
- ExpectErrorSubstring(
- StringPrintf("Saw compiler_version: %d %s",
- GOOGLE_PROTOBUF_VERSION,
- GOOGLE_PROTOBUF_VERSION_SUFFIX));
+ ExpectErrorSubstring(StringPrintf("Saw compiler_version: %d %s",
+ GOOGLE_PROTOBUF_VERSION,
+ GOOGLE_PROTOBUF_VERSION_SUFFIX));
}
TEST_F(CommandLineInterfaceTest, GeneratorPluginNotFound) {
// Test what happens if the plugin isn't found.
CreateTempFile("error.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --badplug_out=TestParameter:$tmpdir "
"--plugin=prefix-gen-badplug=no_such_file "
@@ -2029,11 +2020,10 @@
#ifdef _WIN32
ExpectErrorSubstring("--badplug_out: prefix-gen-badplug: " +
- Subprocess::Win32ErrorMessage(ERROR_FILE_NOT_FOUND));
+ Subprocess::Win32ErrorMessage(ERROR_FILE_NOT_FOUND));
#else
// Error written to stdout by child process after exec() fails.
- ExpectErrorSubstring(
- "no_such_file: program not found or is not executable");
+ ExpectErrorSubstring("no_such_file: program not found or is not executable");
// Error written by parent process when child fails.
ExpectErrorSubstring(
@@ -2045,8 +2035,8 @@
// Test what happens if plugins aren't allowed.
CreateTempFile("error.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
DisallowPlugins();
Run("protocol_compiler --plug_out=TestParameter:$tmpdir "
@@ -2070,28 +2060,28 @@
// that it can be set explicitly).
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "badsyntax\n");
+ "syntax = \"proto2\";\n"
+ "badsyntax\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir --error_format=gcc foo.proto");
ExpectErrorText(
- "foo.proto:2:1: Expected top-level statement (e.g. \"message\").\n");
+ "foo.proto:2:1: Expected top-level statement (e.g. \"message\").\n");
}
TEST_F(CommandLineInterfaceTest, MsvsFormatErrors) {
// Test --error_format=msvs
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "badsyntax\n");
+ "syntax = \"proto2\";\n"
+ "badsyntax\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir --error_format=msvs foo.proto");
ExpectErrorText(
- "$tmpdir/foo.proto(2) : error in column=1: Expected top-level statement "
+ "$tmpdir/foo.proto(2) : error in column=1: Expected top-level statement "
"(e.g. \"message\").\n");
}
@@ -2099,14 +2089,13 @@
// Test --error_format=msvs
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "badsyntax\n");
+ "syntax = \"proto2\";\n"
+ "badsyntax\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir --error_format=invalid foo.proto");
- ExpectErrorText(
- "Unknown error format: invalid\n");
+ ExpectErrorText("Unknown error format: invalid\n");
}
// -------------------------------------------------------------------
@@ -2116,8 +2105,8 @@
// Test that a single-character flag works.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler -t$tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -2130,8 +2119,8 @@
// Test that separating the flag value with a space works.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler --test_out $tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -2145,8 +2134,8 @@
// single-character flags.
CreateTempFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
Run("protocol_compiler -t $tmpdir "
"--proto_path=$tmpdir foo.proto");
@@ -2173,38 +2162,35 @@
}
TEST_F(CommandLineInterfaceTest, PrintFreeFieldNumbers) {
- CreateTempFile(
- "foo.proto",
- "syntax = \"proto2\";\n"
- "package foo;\n"
- "message Foo {\n"
- " optional int32 a = 2;\n"
- " optional string b = 4;\n"
- " optional string c = 5;\n"
- " optional int64 d = 8;\n"
- " optional double e = 10;\n"
- "}\n");
- CreateTempFile(
- "bar.proto",
- "syntax = \"proto2\";\n"
- "message Bar {\n"
- " optional int32 a = 2;\n"
- " extensions 4 to 5;\n"
- " optional int64 d = 8;\n"
- " extensions 10;\n"
- "}\n");
- CreateTempFile(
- "baz.proto",
- "syntax = \"proto2\";\n"
- "message Baz {\n"
- " optional int32 a = 2;\n"
- " optional int64 d = 8;\n"
- " extensions 15 to max;\n" // unordered.
- " extensions 13;\n"
- " extensions 10 to 12;\n"
- " extensions 5;\n"
- " extensions 4;\n"
- "}\n");
+ CreateTempFile("foo.proto",
+ "syntax = \"proto2\";\n"
+ "package foo;\n"
+ "message Foo {\n"
+ " optional int32 a = 2;\n"
+ " optional string b = 4;\n"
+ " optional string c = 5;\n"
+ " optional int64 d = 8;\n"
+ " optional double e = 10;\n"
+ "}\n");
+ CreateTempFile("bar.proto",
+ "syntax = \"proto2\";\n"
+ "message Bar {\n"
+ " optional int32 a = 2;\n"
+ " extensions 4 to 5;\n"
+ " optional int64 d = 8;\n"
+ " extensions 10;\n"
+ "}\n");
+ CreateTempFile("baz.proto",
+ "syntax = \"proto2\";\n"
+ "message Baz {\n"
+ " optional int32 a = 2;\n"
+ " optional int64 d = 8;\n"
+ " extensions 15 to max;\n" // unordered.
+ " extensions 13;\n"
+ " extensions 10 to 12;\n"
+ " extensions 5;\n"
+ " extensions 4;\n"
+ "}\n");
CreateTempFile(
"quz.proto",
"syntax = \"proto2\";\n"
@@ -2249,10 +2235,7 @@
// platforms that don't have a Bourne-compatible shell available (especially
// Windows/MSVC).
-enum EncodeDecodeTestMode {
- PROTO_PATH,
- DESCRIPTOR_SET_IN
-};
+enum EncodeDecodeTestMode { PROTO_PATH, DESCRIPTOR_SET_IN };
class EncodeDecodeTest : public testing::TestWithParam<EncodeDecodeTestMode> {
protected:
@@ -2312,7 +2295,7 @@
ADD_FAILURE() << "unexpected EncodeDecodeTestMode: " << GetParam();
}
- std::unique_ptr<const char * []> argv(new const char* [args.size()]);
+ std::unique_ptr<const char*[]> argv(new const char*[args.size()]);
for (int i = 0; i < args.size(); i++) {
argv[i] = args[i].c_str();
}
@@ -2365,7 +2348,6 @@
protobuf_unittest_import::ImportMessage import_message;
import_message.descriptor()->file()->CopyTo(file_descriptor_set.add_file());
-
protobuf_unittest_import::PublicImportMessage public_import_message;
public_import_message.descriptor()->file()->CopyTo(
file_descriptor_set.add_file());
@@ -2373,10 +2355,8 @@
std::string binary_proto;
GOOGLE_CHECK(file_descriptor_set.SerializeToString(&binary_proto));
- GOOGLE_CHECK_OK(File::SetContents(
- unittest_proto_descriptor_set_filename_,
- binary_proto,
- true));
+ GOOGLE_CHECK_OK(File::SetContents(unittest_proto_descriptor_set_filename_,
+ binary_proto, true));
}
int duped_stdin_;
@@ -2416,7 +2396,7 @@
" --encode=protobuf_unittest.TestRequired"));
ExpectStdoutMatchesText("");
ExpectStderrMatchesText(
- "warning: Input message is missing required fields: a, b, c\n");
+ "warning: Input message is missing required fields: a, b, c\n");
}
TEST_P(EncodeDecodeTest, DecodeRaw) {
@@ -2428,8 +2408,9 @@
RedirectStdinFromText(data);
EXPECT_TRUE(Run("--decode_raw"));
- ExpectStdoutMatchesText("1: 123\n"
- "14: \"foo\"\n");
+ ExpectStdoutMatchesText(
+ "1: 123\n"
+ "14: \"foo\"\n");
ExpectStderrMatchesText("");
}
diff --git a/src/google/protobuf/compiler/cpp/cpp_bootstrap_unittest.cc b/src/google/protobuf/compiler/cpp/cpp_bootstrap_unittest.cc
index c197dae..d73cfb7 100644
--- a/src/google/protobuf/compiler/cpp/cpp_bootstrap_unittest.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_bootstrap_unittest.cc
@@ -77,8 +77,8 @@
// implements ErrorCollector ---------------------------------------
void AddError(const std::string& filename, int line, int column,
const std::string& message) {
- strings::SubstituteAndAppend(&text_, "$0:$1:$2: $3\n",
- filename, line, column, message);
+ strings::SubstituteAndAppend(&text_, "$0:$1:$2: $3\n", filename, line,
+ column, message);
}
};
@@ -92,7 +92,7 @@
std::string* expected_contents =
FindPtrOrNull(files_, virtual_filename);
ASSERT_TRUE(expected_contents != NULL)
- << "Generator failed to generate file: " << virtual_filename;
+ << "Generator failed to generate file: " << virtual_filename;
std::string actual_contents;
GOOGLE_CHECK_OK(
@@ -101,10 +101,11 @@
<< physical_filename;
CleanStringLineEndings(&actual_contents, false);
-#ifdef WRITE_FILES // Define to debug mismatched files.
+#ifdef WRITE_FILES // Define to debug mismatched files.
+ GOOGLE_CHECK_OK(File::SetContents("/tmp/expected.cc", *expected_contents,
+ true));
GOOGLE_CHECK_OK(
- File::SetContents("/tmp/expected.cc", *expected_contents, true));
- GOOGLE_CHECK_OK(File::SetContents("/tmp/actual.cc", actual_contents, true));
+ File::SetContents("/tmp/actual.cc", actual_contents, true));
#endif
ASSERT_EQ(*expected_contents, actual_contents)
@@ -142,10 +143,14 @@
// of the data to compare to.
std::map<std::string, std::string> vpath_map;
std::map<std::string, std::string> rpath_map;
- rpath_map["third_party/protobuf/src/google/protobuf/test_messages_proto2"] =
- "net/proto2/z_generated_example/test_messages_proto2";
- rpath_map["third_party/protobuf/src/google/protobuf/test_messages_proto3"] =
- "net/proto2/z_generated_example/test_messages_proto3";
+ rpath_map
+ ["third_party/protobuf_legacy_opensource/src/google/protobuf/"
+ "test_messages_proto2"] =
+ "net/proto2/z_generated_example/test_messages_proto2";
+ rpath_map
+ ["third_party/protobuf_legacy_opensource/src/google/protobuf/"
+ "test_messages_proto3"] =
+ "net/proto2/z_generated_example/test_messages_proto3";
rpath_map["net/proto2/internal/proto2_weak"] =
"net/proto2/z_generated_example/proto2_weak";
diff --git a/src/google/protobuf/compiler/cpp/cpp_enum.cc b/src/google/protobuf/compiler/cpp/cpp_enum.cc
index 9220ddb..e59099e 100644
--- a/src/google/protobuf/compiler/cpp/cpp_enum.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_enum.cc
@@ -70,7 +70,6 @@
variables_["classname"] = classname_;
variables_["classtype"] = QualifiedClassName(descriptor_, options);
variables_["short_name"] = descriptor_->name();
- variables_["enumbase"] = options_.proto_h ? " : int" : "";
variables_["nested_name"] = descriptor_->name();
variables_["resolved_name"] = ResolveKeyword(descriptor_->name());
variables_["prefix"] =
@@ -81,7 +80,7 @@
void EnumGenerator::GenerateDefinition(io::Printer* printer) {
Formatter format(printer, variables_);
- format("enum ${1$$classname$$}$$enumbase$ {\n", descriptor_);
+ format("enum ${1$$classname$$}$ : int {\n", descriptor_);
format.Indent();
const EnumValueDescriptor* min_value = descriptor_->value(0);
@@ -145,28 +144,18 @@
"$dllexport_decl $const ::$proto_ns$::EnumDescriptor* "
"$classname$_descriptor();\n");
// The _Name and _Parse methods
- if (options_.opensource_runtime) {
- // TODO(haberman): consider removing this in favor of the stricter
- // version below. Would this break our compatibility guarantees?
- format(
- "inline const std::string& $classname$_Name($classname$ value) {\n"
- " return ::$proto_ns$::internal::NameOfEnum(\n"
- " $classname$_descriptor(), value);\n"
- "}\n");
- } else {
- // Support a stricter, type-checked enum-to-string method that
- // statically checks whether the parameter is the exact enum type or is
- // an integral type.
- format(
- "template<typename T>\n"
- "inline const std::string& $classname$_Name(T enum_t_value) {\n"
- " static_assert(::std::is_same<T, $classname$>::value ||\n"
- " ::std::is_integral<T>::value,\n"
- " \"Incorrect type passed to function $classname$_Name.\");\n"
- " return ::$proto_ns$::internal::NameOfEnum(\n"
- " $classname$_descriptor(), enum_t_value);\n"
- "}\n");
- }
+ // Support a stricter, type-checked enum-to-string method that
+ // statically checks whether the parameter is the exact enum type or is
+ // an integral type.
+ format(
+ "template<typename T>\n"
+ "inline const std::string& $classname$_Name(T enum_t_value) {\n"
+ " static_assert(::std::is_same<T, $classname$>::value ||\n"
+ " ::std::is_integral<T>::value,\n"
+ " \"Incorrect type passed to function $classname$_Name.\");\n"
+ " return ::$proto_ns$::internal::NameOfEnum(\n"
+ " $classname$_descriptor(), enum_t_value);\n"
+ "}\n");
format(
"inline bool $classname$_Parse(\n"
" const std::string& name, $classname$* value) {\n"
@@ -227,29 +216,18 @@
"$nested_name$_descriptor() {\n"
" return $classname$_descriptor();\n"
"}\n");
- if (options_.opensource_runtime) {
- // TODO(haberman): consider removing this in favor of the stricter
- // version below. Would this break our compatibility guarantees?
- format(
- "static inline const std::string& "
- "$nested_name$_Name($resolved_name$ value) {"
- "\n"
- " return $classname$_Name(value);\n"
- "}\n");
- } else {
- // Support a stricter, type-checked enum-to-string method that
- // statically checks whether the parameter is the exact enum type or is
- // an integral type.
- format(
- "template<typename T>\n"
- "static inline const std::string& $nested_name$_Name(T enum_t_value) "
- "{\n"
- " static_assert(::std::is_same<T, $resolved_name$>::value ||\n"
- " ::std::is_integral<T>::value,\n"
- " \"Incorrect type passed to function $nested_name$_Name.\");\n"
- " return $classname$_Name(enum_t_value);\n"
- "}\n");
- }
+ // Support a stricter, type-checked enum-to-string method that
+ // statically checks whether the parameter is the exact enum type or is
+ // an integral type.
+ format(
+ "template<typename T>\n"
+ "static inline const std::string& $nested_name$_Name(T enum_t_value) "
+ "{\n"
+ " static_assert(::std::is_same<T, $resolved_name$>::value ||\n"
+ " ::std::is_integral<T>::value,\n"
+ " \"Incorrect type passed to function $nested_name$_Name.\");\n"
+ " return $classname$_Name(enum_t_value);\n"
+ "}\n");
format(
"static inline bool $nested_name$_Parse(const std::string& name,\n"
" $resolved_name$* value) {\n"
@@ -301,8 +279,9 @@
// Before C++17, we must define the static constants which were
// declared in the header, to give the linker a place to put them.
// But pre-2015 MSVC++ insists that we not.
- format("#if (__cplusplus < 201703) && "
- "(!defined(_MSC_VER) || _MSC_VER >= 1900)\n");
+ format(
+ "#if (__cplusplus < 201703) && "
+ "(!defined(_MSC_VER) || _MSC_VER >= 1900)\n");
for (int i = 0; i < descriptor_->value_count(); i++) {
format("constexpr $classname$ $1$::$2$;\n", parent,
@@ -316,8 +295,9 @@
format("constexpr int $1$::$nested_name$_ARRAYSIZE;\n", parent);
}
- format("#endif // (__cplusplus < 201703) && "
- "(!defined(_MSC_VER) || _MSC_VER >= 1900)\n");
+ format(
+ "#endif // (__cplusplus < 201703) && "
+ "(!defined(_MSC_VER) || _MSC_VER >= 1900)\n");
}
}
diff --git a/src/google/protobuf/compiler/cpp/cpp_enum.h b/src/google/protobuf/compiler/cpp/cpp_enum.h
index cce8cf2..3687f04 100644
--- a/src/google/protobuf/compiler/cpp/cpp_enum.h
+++ b/src/google/protobuf/compiler/cpp/cpp_enum.h
@@ -43,9 +43,9 @@
namespace google {
namespace protobuf {
- namespace io {
- class Printer; // printer.h
- }
+namespace io {
+class Printer; // printer.h
+}
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/compiler/cpp/cpp_extension.cc b/src/google/protobuf/compiler/cpp/cpp_extension.cc
index b03ca83..97be5e6 100644
--- a/src/google/protobuf/compiler/cpp/cpp_extension.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_extension.cc
@@ -60,8 +60,7 @@
ExtensionGenerator::ExtensionGenerator(const FieldDescriptor* descriptor,
const Options& options)
- : descriptor_(descriptor),
- options_(options) {
+ : descriptor_(descriptor), options_(options) {
// Construct type_traits_.
if (descriptor_->is_repeated()) {
type_traits_ = "Repeated";
diff --git a/src/google/protobuf/compiler/cpp/cpp_field.cc b/src/google/protobuf/compiler/cpp/cpp_field.cc
index 48e6cec..7aae57d 100644
--- a/src/google/protobuf/compiler/cpp/cpp_field.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_field.cc
@@ -77,7 +77,7 @@
(*variables)["clear_hasbit"] = "";
if (HasFieldPresence(descriptor->file())) {
(*variables)["set_hasbit_io"] =
- "HasBitSetters::set_has_" + FieldName(descriptor) + "(this);";
+ "HasBitSetters::set_has_" + FieldName(descriptor) + "(&_has_bits_);";
} else {
(*variables)["set_hasbit_io"] = "";
}
@@ -113,8 +113,8 @@
FieldGenerator::~FieldGenerator() {}
-void FieldGenerator::
-GenerateMergeFromCodedStreamWithPacking(io::Printer* printer) const {
+void FieldGenerator::GenerateMergeFromCodedStreamWithPacking(
+ io::Printer* printer) const {
// Reaching here indicates a bug. Cases are:
// - This FieldGenerator should support packing, but this method should be
// overridden.
@@ -122,7 +122,6 @@
// never have been called.
GOOGLE_LOG(FATAL) << "GenerateMergeFromCodedStreamWithPacking() "
<< "called on field generator that does not support packing.";
-
}
FieldGeneratorMap::FieldGeneratorMap(const Descriptor* descriptor,
diff --git a/src/google/protobuf/compiler/cpp/cpp_file.cc b/src/google/protobuf/compiler/cpp/cpp_file.cc
index d9a7bde..7164bd7 100644
--- a/src/google/protobuf/compiler/cpp/cpp_file.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_file.cc
@@ -75,7 +75,6 @@
variables_["add_descriptors"] = UniqueName("AddDescriptors", file_, options_);
variables_["filename"] = file_->name();
variables_["package_ns"] = Namespace(file_, options);
- variables_["init_defaults"] = UniqueName("InitDefaults", file_, options_);
std::vector<const Descriptor*> msgs = FlattenMessagesInFile(file);
for (int i = 0; i < msgs.size(); i++) {
@@ -150,11 +149,6 @@
format("#define $1$$ dllexport_decl$\n",
UniqueName("PROTOBUF_INTERNAL_EXPORT", file_, options_));
GenerateMacroUndefs(printer);
- if (IsProto2MessageSetFile(file_, options_)) {
- // Proto2 MessageSet overrides GetMapper() so we forward declare TagMapper
- // to avoid inclusion of "tagmapper.h".
- format("class TagMapper;\n");
- }
// For Any support with lite protos, we need to friend AnyMetadata, so we
// forward-declare it here.
@@ -165,18 +159,6 @@
"} // namespace internal\n"
"PROTOBUF_NAMESPACE_CLOSE\n");
- if (!options_.opensource_runtime) {
- // EmbeddedMessageHolder is a proxy class to provide access into arena
- // constructors for proto1 message objects.
- // See net/proto/proto_arena_internal.h
- format(
- "namespace proto {\n"
- "namespace internal {\n"
- "template <typename T> struct EmbeddedMessageHolder;\n"
- "} // namespace internal\n"
- "} // namespace proto\n");
- }
-
GenerateGlobalStateFunctionDeclarations(printer);
GenerateForwardDeclarations(printer);
@@ -249,14 +231,7 @@
for (int i = 0; i < file_->public_dependency_count(); i++) {
const FileDescriptor* dep = file_->public_dependency(i);
- const char* extension = ".proto.h";
- // The proto1 compiler only generates .pb.h files, so even if we are
- // running in proto-h mode, we can only use the .pb.h.
- if (IsProto1(dep, options_)) {
- extension = ".pb.h";
- }
- std::string dependency = StripProto(dep->name()) + extension;
- format("#include \"$1$\"\n", dependency);
+ format("#include \"$1$.proto.h\"\n", StripProto(dep->name()));
}
format("// @@protoc_insertion_point(includes)\n");
@@ -413,20 +388,13 @@
// Use the smaller .proto.h files.
for (int i = 0; i < file_->dependency_count(); i++) {
const FileDescriptor* dep = file_->dependency(i);
- const char* extension = ".proto.h";
- std::string basename = StripProto(dep->name());
// Do not import weak deps.
if (!options_.opensource_runtime && IsDepWeak(dep)) continue;
- // The proto1 compiler only generates .pb.h files, so even if we are
- // running in proto-h mode, we can only use the .pb.h.
- if (IsProto1(dep, options_)) {
- extension = ".pb.h";
- }
+ std::string basename = StripProto(dep->name());
if (IsBootstrapProto(options_, file_)) {
GetBootstrapBasename(options_, basename, &basename);
}
- std::string dependency = basename + extension;
- format("#include \"$1$\"\n", dependency);
+ format("#include \"$1$.proto.h\"\n", basename);
}
}
@@ -479,7 +447,7 @@
}
std::string dllexport =
UniqueName("PROTOBUF_INTERNAL_EXPORT", msg, options_);
- if (IsProto1(msg->file(), options_) || IsWeak(field, options_)) {
+ if (IsWeak(field, options_)) {
dllexport = "";
}
auto scc = scc_analyzer->GetSCC(msg);
@@ -626,19 +594,6 @@
}
if (HasDescriptorMethods(file_, options_)) {
- // TODO(gerbens) This is for proto1 interoperability. Remove when proto1
- // is gone.
- format("void $init_defaults$() {\n");
- for (int i = 0; i < message_generators_.size(); i++) {
- if (!IsSCCRepresentative(message_generators_[i]->descriptor_)) continue;
- std::string scc_name =
- UniqueName(ClassName(message_generators_[i]->descriptor_),
- message_generators_[i]->descriptor_, options_);
- format(" ::$proto_ns$::internal::InitSCC(&scc_info_$1$.base);\n",
- scc_name);
- }
- format("}\n\n");
-
// Define the code to initialize reflection. This code uses a global
// constructor to register reflection data with the runtime pre-main.
GenerateReflectionInitializationCode(printer);
@@ -781,8 +736,8 @@
format(
"reinterpret_cast<const "
"::$proto_ns$::Message*>(&$1$::_$2$_default_instance_),\n",
- Namespace(descriptor, options_), // 1
- ClassName(descriptor)); // 2
+ Namespace(descriptor, options_), // 1
+ ClassName(descriptor)); // 2
}
format.Outdent();
format(
@@ -823,7 +778,7 @@
// built into real descriptors at initialization time.
const std::string protodef_name =
UniqueName("descriptor_table_protodef", file_, options_);
- format( "const char $1$[] =\n", protodef_name);
+ format("const char $1$[] =\n", protodef_name);
format.Indent();
FileDescriptorProto file_proto;
file_->CopyTo(&file_proto);
@@ -861,10 +816,8 @@
format(
"static "
"::$proto_ns$::internal::DescriptorTable $1$ = {\n"
- " false, $init_defaults$, \n"
- " $2$,\n",
- UniqueName("descriptor_table", file_, options_),
- protodef_name);
+ " false, $2$,\n",
+ UniqueName("descriptor_table", file_, options_), protodef_name);
const int num_deps = file_->dependency_count();
format(
@@ -878,8 +831,18 @@
const FileDescriptor* dependency = file_->dependency(i);
format(" ::$1$,\n", UniqueName("AddDescriptors", dependency, options_));
}
+ format(" };\n");
+ // Reflection referes to the default instances so make sure they are
+ // initialized.
+ for (int i = 0; i < message_generators_.size(); i++) {
+ if (!IsSCCRepresentative(message_generators_[i]->descriptor_)) continue;
+ std::string scc_name =
+ UniqueName(ClassName(message_generators_[i]->descriptor_),
+ message_generators_[i]->descriptor_, options_);
+ format(" ::$proto_ns$::internal::InitSCC(&scc_info_$1$.base);\n",
+ scc_name);
+ }
format(
- " };\n"
" ::$proto_ns$::internal::AddDescriptors(&$1$, deps, $2$);\n"
"}\n\n",
UniqueName("descriptor_table", file_, options_), // 1
@@ -904,15 +867,6 @@
format.Indent();
- if (!options_.opensource_runtime) {
- for (int i = 0; i < scc->children.size(); i++) {
- const SCC* child_scc = scc->children[i];
- const FileDescriptor* dependency = child_scc->GetRepresentative()->file();
- if (!IsProto1(dependency, options_)) continue;
- format("$1$();\n", UniqueName("InitDefaults", dependency, options_));
- }
- }
-
// First construct all the necessary default instances.
for (int i = 0; i < message_generators_.size(); i++) {
if (scc_analyzer_.GetSCC(message_generators_[i]->descriptor_) != scc) {
@@ -961,11 +915,6 @@
options_));
for (const SCC* child : scc->children) {
auto repr = child->GetRepresentative();
- if (IsProto1(repr->file(), options_)) {
- GOOGLE_CHECK(!options_.opensource_runtime);
- format("\n nullptr,");
- continue;
- }
format("\n &scc_info_$1$.base,",
UniqueName(ClassName(repr), repr, options_));
}
@@ -1243,7 +1192,7 @@
"#endif\n"
"\n",
PROTOBUF_MIN_HEADER_VERSION_FOR_PROTOC, // 1
- PROTOBUF_VERSION); // 2
+ PROTOBUF_VERSION); // 2
IncludeFile("net/proto2/public/port_undef.inc", printer);
}
@@ -1381,11 +1330,6 @@
std::max(size_t(1), message_generators_.size()));
if (HasDescriptorMethods(file_, options_)) {
format("void $dllexport_decl $$add_descriptors$();\n");
- if (!options_.opensource_runtime) {
- // TODO(gerbens) This is for proto1 interoperability. Remove when proto1
- // is gone.
- format("void $dllexport_decl $$init_defaults$();\n");
- }
}
}
diff --git a/src/google/protobuf/compiler/cpp/cpp_file.h b/src/google/protobuf/compiler/cpp/cpp_file.h
index a7308ab..ca90672 100644
--- a/src/google/protobuf/compiler/cpp/cpp_file.h
+++ b/src/google/protobuf/compiler/cpp/cpp_file.h
@@ -163,9 +163,7 @@
const Descriptor* GetSCCRepresentative(const Descriptor* d) {
return GetSCC(d)->GetRepresentative();
}
- const SCC* GetSCC(const Descriptor* d) {
- return scc_analyzer_.GetSCC(d);
- }
+ const SCC* GetSCC(const Descriptor* d) { return scc_analyzer_.GetSCC(d); }
bool IsDepWeak(const FileDescriptor* dep) const {
if (weak_deps_.count(dep) != 0) {
diff --git a/src/google/protobuf/compiler/cpp/cpp_generator.cc b/src/google/protobuf/compiler/cpp/cpp_generator.cc
index fe7131f..7de0765 100644
--- a/src/google/protobuf/compiler/cpp/cpp_generator.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_generator.cc
@@ -34,9 +34,9 @@
#include <google/protobuf/compiler/cpp/cpp_generator.h>
-#include <vector>
#include <memory>
#include <utility>
+#include <vector>
#include <google/protobuf/stubs/strutil.h>
#include <google/protobuf/compiler/cpp/cpp_file.h>
@@ -101,8 +101,8 @@
file_options.enforce_mode = EnforceOptimizeMode::kLiteRuntime;
file_options.lite_implicit_weak_fields = true;
if (!options[i].second.empty()) {
- file_options.num_cc_files = strto32(options[i].second.c_str(),
- NULL, 10);
+ file_options.num_cc_files =
+ strto32(options[i].second.c_str(), NULL, 10);
}
} else if (options[i].first == "table_driven_parsing") {
file_options.table_driven_parsing = true;
@@ -142,9 +142,9 @@
io::AnnotationProtoCollector<GeneratedCodeInfo> annotation_collector(
&annotations);
std::string info_path = basename + ".proto.h.meta";
- io::Printer printer(output.get(), '$', file_options.annotate_headers
- ? &annotation_collector
- : NULL);
+ io::Printer printer(
+ output.get(), '$',
+ file_options.annotate_headers ? &annotation_collector : NULL);
file_generator.GenerateProtoHeader(
&printer, file_options.annotate_headers ? info_path : "");
if (file_options.annotate_headers) {
@@ -161,9 +161,9 @@
io::AnnotationProtoCollector<GeneratedCodeInfo> annotation_collector(
&annotations);
std::string info_path = basename + ".pb.h.meta";
- io::Printer printer(output.get(), '$', file_options.annotate_headers
- ? &annotation_collector
- : NULL);
+ io::Printer printer(
+ output.get(), '$',
+ file_options.annotate_headers ? &annotation_collector : NULL);
file_generator.GeneratePBHeader(
&printer, file_options.annotate_headers ? info_path : "");
if (file_options.annotate_headers) {
@@ -175,40 +175,32 @@
// Generate cc file(s).
if (UsingImplicitWeakFields(file, file_options)) {
- if (file->name() == "net/proto2/proto/descriptor.proto") {
- // If we are building with implicit weak fields then we do not want to
- // produce any symbols for descriptor.proto, so we just create an empty
- // pb.cc file.
+ {
+ // This is the global .cc file, containing
+ // enum/services/tables/reflection
std::unique_ptr<io::ZeroCopyOutputStream> output(
generator_context->Open(basename + ".pb.cc"));
- } else {
- {
- // This is the global .cc file, containing
- // enum/services/tables/reflection
- std::unique_ptr<io::ZeroCopyOutputStream> output(
- generator_context->Open(basename + ".pb.cc"));
- io::Printer printer(output.get(), '$');
- file_generator.GenerateGlobalSource(&printer);
- }
+ io::Printer printer(output.get(), '$');
+ file_generator.GenerateGlobalSource(&printer);
+ }
- int num_cc_files = file_generator.NumMessages();
+ int num_cc_files = file_generator.NumMessages();
- // If we're using implicit weak fields then we allow the user to
- // optionally specify how many files to generate, not counting the global
- // pb.cc file. If we have more files than messages, then some files will
- // be generated as empty placeholders.
- if (file_options.num_cc_files > 0) {
- GOOGLE_CHECK_LE(file_generator.NumMessages(), file_options.num_cc_files)
- << "There must be at least as many numbered .cc files as messages.";
- num_cc_files = file_options.num_cc_files;
- }
- for (int i = 0; i < num_cc_files; i++) {
- std::unique_ptr<io::ZeroCopyOutputStream> output(
- generator_context->Open(StrCat(basename, ".out/", i, ".cc")));
- io::Printer printer(output.get(), '$');
- if (i < file_generator.NumMessages()) {
- file_generator.GenerateSourceForMessage(i, &printer);
- }
+ // If we're using implicit weak fields then we allow the user to
+ // optionally specify how many files to generate, not counting the global
+ // pb.cc file. If we have more files than messages, then some files will
+ // be generated as empty placeholders.
+ if (file_options.num_cc_files > 0) {
+ GOOGLE_CHECK_LE(file_generator.NumMessages(), file_options.num_cc_files)
+ << "There must be at least as many numbered .cc files as messages.";
+ num_cc_files = file_options.num_cc_files;
+ }
+ for (int i = 0; i < num_cc_files; i++) {
+ std::unique_ptr<io::ZeroCopyOutputStream> output(
+ generator_context->Open(StrCat(basename, ".out/", i, ".cc")));
+ io::Printer printer(output.get(), '$');
+ if (i < file_generator.NumMessages()) {
+ file_generator.GenerateSourceForMessage(i, &printer);
}
}
} else {
diff --git a/src/google/protobuf/compiler/cpp/cpp_helpers.cc b/src/google/protobuf/compiler/cpp/cpp_helpers.cc
index 21af61f..4225dc0 100644
--- a/src/google/protobuf/compiler/cpp/cpp_helpers.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_helpers.cc
@@ -55,7 +55,6 @@
#include <google/protobuf/stubs/hash.h>
-
#include <google/protobuf/port_def.inc>
namespace google {
@@ -358,8 +357,10 @@
if (IsWellKnownMessage(d) && options.opensource_runtime) {
// Written with string concatenation to prevent rewriting of
// ::google::protobuf.
- ret = StringReplace(ret, "::google::" "protobuf", "PROTOBUF_NAMESPACE_ID",
- false);
+ ret = StringReplace(ret,
+ "::google::"
+ "protobuf",
+ "PROTOBUF_NAMESPACE_ID", false);
}
return ret;
}
@@ -1123,6 +1124,8 @@
!field->is_required() && !field->is_map() &&
field->containing_oneof() == nullptr &&
!IsWellKnownMessage(field->message_type()->file()) &&
+ field->message_type()->file()->name() !=
+ "net/proto2/proto/descriptor.proto" &&
// We do not support implicit weak fields between messages in the same
// strongly-connected component.
scc_analyzer->GetSCC(field->containing_type()) !=
@@ -1230,7 +1233,7 @@
bool GetBootstrapBasename(const Options& options, const std::string& basename,
std::string* bootstrap_basename) {
- if (options.opensource_runtime || options.lite_implicit_weak_fields) {
+ if (options.opensource_runtime) {
return false;
}
@@ -1336,21 +1339,27 @@
bool ShouldRepeat(const FieldDescriptor* descriptor,
internal::WireFormatLite::WireType wiretype) {
- return descriptor->is_repeated() &&
+ constexpr int kMaxTwoByteFieldNumber = 16 * 128;
+ return descriptor->number() < kMaxTwoByteFieldNumber &&
+ descriptor->is_repeated() &&
(!descriptor->is_packable() ||
wiretype != internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
}
class ParseLoopGenerator {
public:
- ParseLoopGenerator(const Options& options, MessageSCCAnalyzer* scc_analyzer,
- io::Printer* printer)
- : scc_analyzer_(scc_analyzer), options_(options), format_(printer) {}
+ ParseLoopGenerator(int num_hasbits, const Options& options,
+ MessageSCCAnalyzer* scc_analyzer, io::Printer* printer)
+ : scc_analyzer_(scc_analyzer),
+ options_(options),
+ format_(printer),
+ num_hasbits_(num_hasbits) {}
void GenerateParserLoop(const Descriptor* descriptor) {
format_.Set("classname", ClassName(descriptor));
format_.Set("p_ns", "::" + ProtobufNamespace(options_));
- format_.Set("pi_ns", StrCat("::", ProtobufNamespace(options_), "::internal"));
+ format_.Set("pi_ns",
+ StrCat("::", ProtobufNamespace(options_), "::internal"));
format_.Set("GOOGLE_PROTOBUF", MacroPrefix(options_));
std::map<std::string, std::string> vars;
SetCommonVars(options_, &vars);
@@ -1358,9 +1367,6 @@
std::vector<const FieldDescriptor*> ordered_fields;
for (auto field : FieldRange(descriptor)) {
- if (IsProto1(descriptor->file(), options_)) {
- if (field->number() >= (1 << 14)) continue;
- }
ordered_fields.push_back(field);
}
std::sort(ordered_fields.begin(), ordered_fields.end(),
@@ -1370,20 +1376,43 @@
format_(
"const char* $classname$::_InternalParse(const char* ptr, "
- "$pi_ns$::ParseContext* ctx) {\n");
+ "$pi_ns$::ParseContext* ctx) {\n"
+ "#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure\n");
format_.Indent();
+ int hasbits_size = 0;
+ if (HasFieldPresence(descriptor->file())) {
+ hasbits_size = (num_hasbits_ + 31) / 32;
+ }
+ // For now only optimize small hasbits.
+ if (hasbits_size != 1) hasbits_size = 0;
+ if (hasbits_size) {
+ format_("HasBitSetters::HasBits has_bits{};\n");
+ format_.Set("has_bits", "has_bits");
+ } else {
+ format_.Set("has_bits", "_has_bits_");
+ }
+
if (descriptor->file()->options().cc_enable_arenas()) {
format_("$p_ns$::Arena* arena = GetArenaNoVirtual(); (void)arena;\n");
}
GenerateParseLoop(descriptor, ordered_fields);
format_.Outdent();
- format_("}\n");
+ format_("success:\n");
+ if (hasbits_size) format_(" _has_bits_.Or(has_bits);\n");
+ format_(
+ " return ptr;\n"
+ "failure:\n"
+ " ptr = nullptr;\n"
+ " goto success;\n"
+ "#undef CHK_\n"
+ "}\n");
}
private:
MessageSCCAnalyzer* scc_analyzer_;
const Options& options_;
Formatter format_;
+ int num_hasbits_;
using WireFormat = internal::WireFormat;
using WireFormatLite = internal::WireFormatLite;
@@ -1396,7 +1425,7 @@
field_name = ", kFieldName";
}
if (HasFieldPresence(field->file())) {
- format_("HasBitSetters::set_has_$1$(this);\n", FieldName(field));
+ format_("HasBitSetters::set_has_$1$(&$has_bits$);\n", FieldName(field));
}
string default_string =
field->default_value_string().empty()
@@ -1432,18 +1461,12 @@
if (!options_.opensource_runtime) {
// Open source doesn't support other ctypes;
ctype = field->options().ctype();
- if (IsProto1(field->file(), options_) &&
- ctype == FieldOptions::STRING_PIECE) {
- // proto1 doesn't support STRING_PIECE
- ctype = FieldOptions::STRING;
- }
}
if (field->file()->options().cc_enable_arenas() && !field->is_repeated() &&
!options_.opensource_runtime &&
GetOptimizeFor(field->file(), options_) != FileOptions::LITE_RUNTIME &&
// For now only use arena string for strings with empty defaults.
field->default_value_string().empty() &&
- !IsProto1(field->file(), options_) &&
!IsStringInlined(field, options_) &&
field->containing_oneof() == nullptr && ctype == FieldOptions::STRING) {
GenerateArenaString(field, utf8, field_name);
@@ -1461,14 +1484,13 @@
name = "StringPieceParser" + utf8;
break;
}
- format_(
- "ptr = $pi_ns$::Inline$1$($2$_$3$(), ptr, ctx$4$);\n",
- name, field->is_repeated() && !field->is_packable() ? "add" : "mutable",
- FieldName(field), field_name);
+ format_("ptr = $pi_ns$::Inline$1$($2$_$3$(), ptr, ctx$4$);\n", name,
+ field->is_repeated() && !field->is_packable() ? "add" : "mutable",
+ FieldName(field), field_name);
}
void GenerateLengthDelim(const FieldDescriptor* field) {
- if (!IsProto1(field->file(), options_) && field->is_packable()) {
+ if (field->is_packable()) {
std::string enum_validator;
if (field->type() == FieldDescriptor::TYPE_ENUM &&
!HasPreservingUnknownEnumSemantics(field)) {
@@ -1476,22 +1498,11 @@
", ", QualifiedClassName(field->enum_type(), options_),
"_IsValid, mutable_unknown_fields(), ", field->number());
}
- format_(
- "ptr = $pi_ns$::Packed$1$Parser(mutable_$2$(), ptr, ctx$3$);\n",
- DeclaredTypeMethodName(field->type()), FieldName(field),
- enum_validator);
+ format_("ptr = $pi_ns$::Packed$1$Parser(mutable_$2$(), ptr, ctx$3$);\n",
+ DeclaredTypeMethodName(field->type()), FieldName(field),
+ enum_validator);
} else {
auto field_type = field->type();
- if (IsProto1(field->file(), options_)) {
- if (field->is_packable()) {
- // Sigh ... packed fields endup as a string in proto1
- field_type = FieldDescriptor::TYPE_BYTES;
- }
- if (field_type == FieldDescriptor::TYPE_STRING) {
- // In proto1 strings are treated as bytes
- field_type = FieldDescriptor::TYPE_BYTES;
- }
- }
switch (field_type) {
case FieldDescriptor::TYPE_STRING:
GenerateStrings(field, true /* utf8 */);
@@ -1500,7 +1511,7 @@
GenerateStrings(field, false /* utf8 */);
break;
case FieldDescriptor::TYPE_MESSAGE: {
- if (!IsProto1(field->file(), options_) && field->is_map()) {
+ if (field->is_map()) {
const FieldDescriptor* val =
field->message_type()->FindFieldByName("value");
GOOGLE_CHECK(val);
@@ -1516,8 +1527,7 @@
format_("ptr = ctx->ParseMessage(&$1$_, ptr);\n",
FieldName(field));
}
- } else if (!IsProto1(field->file(), options_) &&
- IsLazy(field, options_)) {
+ } else if (IsLazy(field, options_)) {
if (field->containing_oneof() != nullptr) {
format_(
"if (!has_$1$()) {\n"
@@ -1531,12 +1541,12 @@
FieldName(field), field->containing_oneof()->name());
} else if (HasFieldPresence(field->file())) {
format_(
- "HasBitSetters::set_has_$1$(this);\n"
+ "HasBitSetters::set_has_$1$(&$has_bits$);\n"
"ptr = ctx->ParseMessage(&$1$_, ptr);\n",
FieldName(field));
} else {
- format_(
- "ptr = ctx->ParseMessage(&$1$_, ptr);\n", FieldName(field));
+ format_("ptr = ctx->ParseMessage(&$1$_, ptr);\n",
+ FieldName(field));
}
} else if (IsImplicitWeakField(field, options_, scc_analyzer_)) {
if (!field->is_repeated()) {
@@ -1554,18 +1564,10 @@
ClassName(field->message_type()));
}
} else if (IsWeak(field, options_)) {
- if (IsProto1(field->file(), options_)) {
- format_(
- "ptr = ctx->ParseMessage("
- "reinterpret_cast<$p_ns$::MessageLite*>(internal_mutable_$1$("
- ")), ptr);\n",
- FieldName(field));
- } else {
- format_(
- "ptr = ctx->ParseMessage(_weak_field_map_.MutableMessage($1$,"
- " _$classname$_default_instance_.$2$_), ptr);\n",
- field->number(), FieldName(field));
- }
+ format_(
+ "ptr = ctx->ParseMessage(_weak_field_map_.MutableMessage($1$,"
+ " _$classname$_default_instance_.$2$_), ptr);\n",
+ field->number(), FieldName(field));
} else {
format_("ptr = ctx->ParseMessage($1$_$2$(), ptr);\n",
field->is_repeated() ? "add" : "mutable", FieldName(field));
@@ -1582,18 +1584,17 @@
void GenerateCaseBody(internal::WireFormatLite::WireType wiretype,
const FieldDescriptor* field) {
if (ShouldRepeat(field, wiretype)) {
- format_("do {\n");
+ format_("while (true) {\n");
format_.Indent();
}
switch (wiretype) {
case WireFormatLite::WIRETYPE_VARINT: {
std::string type = PrimitiveTypeName(options_, field->cpp_type());
std::string prefix = field->is_repeated() ? "add" : "set";
- if (field->type() == FieldDescriptor::TYPE_ENUM &&
- !IsProto1(field->file(), options_)) {
+ if (field->type() == FieldDescriptor::TYPE_ENUM) {
format_(
"$uint64$ val = $pi_ns$::ReadVarint(&ptr);\n"
- "$GOOGLE_PROTOBUF$_PARSER_ASSERT(ptr);\n");
+ "CHK_(ptr);\n");
if (!HasPreservingUnknownEnumSemantics(field)) {
format_(
"if (!$1$_IsValid(val)) {\n"
@@ -1610,36 +1611,58 @@
int size = field->type() == FieldDescriptor::TYPE_SINT32 ? 32 : 64;
std::string zigzag;
if ((field->type() == FieldDescriptor::TYPE_SINT32 ||
- field->type() == FieldDescriptor::TYPE_SINT64) &&
- !IsProto1(field->file(), options_)) {
+ field->type() == FieldDescriptor::TYPE_SINT64)) {
zigzag = StrCat("ZigZag", size);
}
- format_(
- "$1$_$2$($pi_ns$::ReadVarint$3$(&ptr));\n"
- "$GOOGLE_PROTOBUF$_PARSER_ASSERT(ptr);\n",
- prefix, FieldName(field), zigzag);
+ if (field->is_repeated() || field->containing_oneof()) {
+ string prefix = field->is_repeated() ? "add" : "set";
+ format_(
+ "$1$_$2$($pi_ns$::ReadVarint$3$(&ptr));\n"
+ "CHK_(ptr);\n",
+ prefix, FieldName(field), zigzag);
+ } else {
+ if (HasFieldPresence(field->file())) {
+ format_("HasBitSetters::set_has_$1$(&$has_bits$);\n",
+ FieldName(field));
+ }
+ format_(
+ "$1$_ = $pi_ns$::ReadVarint$2$(&ptr);\n"
+ "CHK_(ptr);\n",
+ FieldName(field), zigzag);
+ }
}
break;
}
case WireFormatLite::WIRETYPE_FIXED32:
case WireFormatLite::WIRETYPE_FIXED64: {
- std::string prefix = field->is_repeated() ? "add" : "set";
std::string type = PrimitiveTypeName(options_, field->cpp_type());
- format_(
- "$1$_$2$($pi_ns$::UnalignedLoad<$3$>(ptr));\n"
- "ptr += sizeof($3$);\n",
- prefix, FieldName(field), type);
+ if (field->is_repeated() || field->containing_oneof()) {
+ string prefix = field->is_repeated() ? "add" : "set";
+ format_(
+ "$1$_$2$($pi_ns$::UnalignedLoad<$3$>(ptr));\n"
+ "ptr += sizeof($3$);\n",
+ prefix, FieldName(field), type);
+ } else {
+ if (HasFieldPresence(field->file())) {
+ format_("HasBitSetters::set_has_$1$(&$has_bits$);\n",
+ FieldName(field));
+ }
+ format_(
+ "$1$_ = $pi_ns$::UnalignedLoad<$2$>(ptr);\n"
+ "ptr += sizeof($2$);\n",
+ FieldName(field), type);
+ }
break;
}
case WireFormatLite::WIRETYPE_LENGTH_DELIMITED: {
GenerateLengthDelim(field);
- format_("$GOOGLE_PROTOBUF$_PARSER_ASSERT(ptr);\n");
+ format_("CHK_(ptr);\n");
break;
}
case WireFormatLite::WIRETYPE_START_GROUP: {
format_(
"ptr = ctx->ParseGroup($1$_$2$(), ptr, tag);\n"
- "$GOOGLE_PROTOBUF$_PARSER_ASSERT(ptr);\n",
+ "CHK_(ptr);\n",
field->is_repeated() ? "add" : "mutable", FieldName(field));
break;
}
@@ -1651,26 +1674,26 @@
if (ShouldRepeat(field, wiretype)) {
uint32 x = field->number() * 8 + wiretype;
- uint64 y = 0;
- int cnt = 0;
- do {
- y += static_cast<uint64>((x & 0x7F) + (x >= 128 ? 128 : 0))
- << (cnt++ * 8);
- x >>= 7;
- } while (x);
- uint64 mask = (1ull << (cnt * 8)) - 1;
- format_("if (ctx->Done(&ptr)) return ptr;\n");
- format_.Outdent();
+ int cnt = 1;
+ string type = "uint8";
+ if (x >= 128) {
+ x += (x & 0xFF80) + 128;
+ cnt = 2;
+ type = "uint16";
+ }
format_(
- "} while (($pi_ns$::UnalignedLoad<$uint64$>(ptr)"
- " & $1$) == $2$ && (ptr += $3$));\n",
- mask, y, cnt);
+ "if (!ctx->DataAvailable(ptr)) break;\n"
+ "if ($pi_ns$::UnalignedLoad<$1$>(ptr) != $2$) break;\n"
+ "ptr += $3$;\n",
+ IntTypeName(options_, type), x, cnt);
+ format_.Outdent();
+ format_("}\n");
}
format_("break;\n");
}
void GenerateCaseBody(const FieldDescriptor* field) {
- if (!IsProto1(field->file(), options_) && field->is_packable()) {
+ if (field->is_packable()) {
auto expected_wiretype = WireFormat::WireTypeForFieldType(field->type());
GOOGLE_CHECK(expected_wiretype != WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
uint32 expected_tag =
@@ -1707,7 +1730,7 @@
"while (!ctx->Done(&ptr)) {\n"
" $uint32$ tag;\n"
" ptr = $pi_ns$::ReadTag(ptr, &tag);\n"
- " $GOOGLE_PROTOBUF$_PARSER_ASSERT(ptr);\n"
+ " CHK_(ptr);\n"
" switch (tag >> 3) {\n");
format_.Indent();
@@ -1741,7 +1764,7 @@
format_(
" if ((tag & 7) == 4 || tag == 0) {\n"
" ctx->SetLastTag(tag);\n"
- " return ptr;\n"
+ " goto success;\n"
" }\n");
if (IsMapEntryMessage(descriptor)) {
format_(" break;\n");
@@ -1769,13 +1792,13 @@
" ptr = _extensions_.ParseField(tag, ptr, \n"
" internal_default_instance(), &_internal_metadata_, "
"ctx);\n"
- " $GOOGLE_PROTOBUF$_PARSER_ASSERT(ptr != nullptr);\n"
+ " CHK_(ptr != nullptr);\n"
" break;\n"
"}\n");
}
format_(
" ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);\n"
- " $GOOGLE_PROTOBUF$_PARSER_ASSERT(ptr != nullptr);\n"
+ " CHK_(ptr != nullptr);\n"
" break;\n");
}
format_("}\n"); // default case
@@ -1783,15 +1806,15 @@
format_.Outdent();
format_(
" } // switch\n"
- "} // while\n"
- "return ptr;\n");
+ "} // while\n");
}
};
-void GenerateParserLoop(const Descriptor* descriptor, const Options& options,
+void GenerateParserLoop(const Descriptor* descriptor, int num_hasbits,
+ const Options& options,
MessageSCCAnalyzer* scc_analyzer,
io::Printer* printer) {
- ParseLoopGenerator generator(options, scc_analyzer, printer);
+ ParseLoopGenerator generator(num_hasbits, options, scc_analyzer, printer);
generator.GenerateParserLoop(descriptor);
}
diff --git a/src/google/protobuf/compiler/cpp/cpp_helpers.h b/src/google/protobuf/compiler/cpp/cpp_helpers.h
index 895749d..f4cf005 100644
--- a/src/google/protobuf/compiler/cpp/cpp_helpers.h
+++ b/src/google/protobuf/compiler/cpp/cpp_helpers.h
@@ -75,10 +75,6 @@
extern const char kThickSeparator[];
extern const char kThinSeparator[];
-inline bool IsProto1(const FileDescriptor* file, const Options& options) {
- return false;
-}
-
void SetCommonVars(const Options& options,
std::map<std::string, std::string>* variables);
@@ -168,8 +164,8 @@
// Returns the scope where the field was defined (for extensions, this is
// different from the message type to which the field applies).
inline const Descriptor* FieldScope(const FieldDescriptor* field) {
- return field->is_extension() ?
- field->extension_scope() : field->containing_type();
+ return field->is_extension() ? field->extension_scope()
+ : field->containing_type();
}
// Returns the fully-qualified type name field->message_type(). Usually this
@@ -776,16 +772,15 @@
};
Iterator begin() const { return {0, descriptor}; }
- Iterator end() const {
- return {descriptor->oneof_decl_count(), descriptor};
- }
+ Iterator end() const { return {descriptor->oneof_decl_count(), descriptor}; }
const Descriptor* descriptor;
};
inline OneOfRangeImpl OneOfRange(const Descriptor* desc) { return {desc}; }
-void GenerateParserLoop(const Descriptor* descriptor, const Options& options,
+void GenerateParserLoop(const Descriptor* descriptor, int num_hasbits,
+ const Options& options,
MessageSCCAnalyzer* scc_analyzer, io::Printer* printer);
} // namespace cpp
diff --git a/src/google/protobuf/compiler/cpp/cpp_map_field.cc b/src/google/protobuf/compiler/cpp/cpp_map_field.cc
index 7ed5530..0738b91 100644
--- a/src/google/protobuf/compiler/cpp/cpp_map_field.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_map_field.cc
@@ -89,8 +89,7 @@
(*variables)["lite"] = "Lite";
}
- if (!IsProto3Field(descriptor) &&
- val->type() == FieldDescriptor::TYPE_ENUM) {
+ if (!IsProto3Field(descriptor) && val->type() == FieldDescriptor::TYPE_ENUM) {
const EnumValueDescriptor* default_value = val->default_value_enum();
(*variables)["default_enum_value"] = Int32ToString(default_value->number());
} else {
@@ -106,8 +105,7 @@
MapFieldGenerator::~MapFieldGenerator() {}
-void MapFieldGenerator::
-GeneratePrivateMembers(io::Printer* printer) const {
+void MapFieldGenerator::GeneratePrivateMembers(io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"::$proto_ns$::internal::MapField$lite$<\n"
@@ -118,8 +116,8 @@
" $default_enum_value$ > $name$_;\n");
}
-void MapFieldGenerator::
-GenerateAccessorDeclarations(io::Printer* printer) const {
+void MapFieldGenerator::GenerateAccessorDeclarations(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"$deprecated_attr$const ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >&\n"
@@ -129,8 +127,8 @@
descriptor_);
}
-void MapFieldGenerator::
-GenerateInlineAccessorDefinitions(io::Printer* printer) const {
+void MapFieldGenerator::GenerateInlineAccessorDefinitions(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline const ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >&\n"
@@ -145,32 +143,29 @@
"}\n");
}
-void MapFieldGenerator::
-GenerateClearingCode(io::Printer* printer) const {
+void MapFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.Clear();\n");
}
-void MapFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void MapFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.MergeFrom(from.$name$_);\n");
}
-void MapFieldGenerator::
-GenerateSwappingCode(io::Printer* printer) const {
+void MapFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.Swap(&other->$name$_);\n");
}
-void MapFieldGenerator::
-GenerateCopyConstructorCode(io::Printer* printer) const {
+void MapFieldGenerator::GenerateCopyConstructorCode(
+ io::Printer* printer) const {
GenerateConstructorCode(printer);
GenerateMergingCode(printer);
}
-void MapFieldGenerator::
-GenerateMergeFromCodedStream(io::Printer* printer) const {
+void MapFieldGenerator::GenerateMergeFromCodedStream(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
const FieldDescriptor* key_field =
descriptor_->message_type()->FindFieldByName("key");
@@ -278,13 +273,13 @@
format("}\n");
}
-void MapFieldGenerator::
-GenerateSerializeWithCachedSizes(io::Printer* printer) const {
+void MapFieldGenerator::GenerateSerializeWithCachedSizes(
+ io::Printer* printer) const {
GenerateSerializeWithCachedSizes(printer, false);
}
-void MapFieldGenerator::
-GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
+void MapFieldGenerator::GenerateSerializeWithCachedSizesToArray(
+ io::Printer* printer) const {
GenerateSerializeWithCachedSizes(printer, true);
}
@@ -367,8 +362,7 @@
format("}\n");
}
-void MapFieldGenerator::
-GenerateByteSize(io::Printer* printer) const {
+void MapFieldGenerator::GenerateByteSize(io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"total_size += $tag_size$ *\n"
diff --git a/src/google/protobuf/compiler/cpp/cpp_message.cc b/src/google/protobuf/compiler/cpp/cpp_message.cc
index bd17215..c56cf5b 100644
--- a/src/google/protobuf/compiler/cpp/cpp_message.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_message.cc
@@ -154,8 +154,7 @@
// Non-repeated, non-lazy message fields are simply raw pointers, so we can
// use memset to initialize these in SharedCtor. We cannot use this in
// Clear, as we need to potentially delete the existing value.
- ret = ret || (!field->is_repeated() &&
- !IsLazy(field, options) &&
+ ret = ret || (!field->is_repeated() && !IsLazy(field, options) &&
field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE);
return ret;
}
@@ -270,16 +269,6 @@
options.opensource_runtime;
}
-bool ShouldMarkMergePartialAsFinal(const Descriptor* descriptor,
- const Options& options) {
- static std::set<std::string> exclusions{
- };
-
- const std::string name = ClassName(descriptor, true);
- return exclusions.find(name) == exclusions.end() ||
- options.opensource_runtime;
-}
-
bool ShouldMarkNewAsFinal(const Descriptor* descriptor,
const Options& options) {
static std::set<std::string> exclusions{
@@ -437,10 +426,10 @@
// Collects neighboring fields based on a given criteria (equivalent predicate).
template <typename Predicate>
-std::vector<std::vector<const FieldDescriptor*> > CollectFields(
+std::vector<std::vector<const FieldDescriptor*>> CollectFields(
const std::vector<const FieldDescriptor*>& fields,
const Predicate& equivalent) {
- std::vector<std::vector<const FieldDescriptor*> > chunks;
+ std::vector<std::vector<const FieldDescriptor*>> chunks;
if (fields.empty()) {
return chunks;
}
@@ -520,7 +509,7 @@
return has_bit_indices_[chunks_[chunk][offset]->index()] / 32;
}
- const std::vector<std::vector<const FieldDescriptor*> >& chunks_;
+ const std::vector<std::vector<const FieldDescriptor*>>& chunks_;
const std::vector<int>& has_bit_indices_;
const AccessInfoMap* access_info_map_;
const double cold_threshold_;
@@ -848,8 +837,7 @@
}
void MessageGenerator::GenerateFieldClear(const FieldDescriptor* field,
- bool is_inline,
- Formatter format) {
+ bool is_inline, Formatter format) {
// Generate clear_$name$().
if (is_inline) {
format("inline ");
@@ -933,7 +921,7 @@
void MessageGenerator::GenerateClassDefinition(io::Printer* printer) {
Formatter format(printer, variables_);
format.Set("class_final",
- ShouldMarkClassAsFinal(descriptor_, options_) ? "final": "");
+ ShouldMarkClassAsFinal(descriptor_, options_) ? "final" : "");
if (IsMapEntryMessage(descriptor_)) {
std::map<std::string, std::string> vars;
@@ -965,19 +953,19 @@
!suffix.empty()) {
if (suffix == "UTF8") {
format(
- " bool ValidateKey() const {\n"
+ " static bool ValidateKey(std::string* s) {\n"
" return ::$proto_ns$::internal::WireFormatLite::"
- "VerifyUtf8String(key().data(), key().size(), "
+ "VerifyUtf8String(s->data(), s->size(), "
"::$proto_ns$::internal::WireFormatLite::PARSE, \"$1$\");\n"
" }\n",
descriptor_->field(0)->full_name());
} else {
GOOGLE_CHECK(suffix == "UTF8Verify");
format(
- " bool ValidateKey() const {\n"
+ " static bool ValidateKey(std::string* s) {\n"
"#ifndef NDEBUG\n"
" ::$proto_ns$::internal::WireFormatLite::VerifyUtf8String(\n"
- " key().data(), key().size(), ::$proto_ns$::internal::"
+ " s->data(), s->size(), ::$proto_ns$::internal::"
"WireFormatLite::PARSE, \"$1$\");\n"
"#endif\n"
" return true;\n"
@@ -985,25 +973,25 @@
descriptor_->field(0)->full_name());
}
} else {
- format(" bool ValidateKey() const { return true; }\n");
+ format(" static bool ValidateKey(void*) { return true; }\n");
}
if (descriptor_->field(1)->type() == FieldDescriptor::TYPE_STRING &&
!suffix.empty()) {
if (suffix == "UTF8") {
format(
- " bool ValidateValue() const {\n"
+ " static bool ValidateValue(std::string* s) {\n"
" return ::$proto_ns$::internal::WireFormatLite::"
- "VerifyUtf8String(value().data(), value().size(), "
+ "VerifyUtf8String(s->data(), s->size(), "
"::$proto_ns$::internal::WireFormatLite::PARSE, \"$1$\");\n"
" }\n",
descriptor_->field(1)->full_name());
} else {
GOOGLE_CHECK(suffix == "UTF8Verify");
format(
- " bool ValidateValue() const {\n"
+ " static bool ValidateValue(std::string* s) {\n"
"#ifndef NDEBUG\n"
" ::$proto_ns$::internal::WireFormatLite::VerifyUtf8String(\n"
- " value().data(), value().size(), ::$proto_ns$::internal::"
+ " s->data(), s->size(), ::$proto_ns$::internal::"
"WireFormatLite::PARSE, \"$1$\");\n"
"#endif\n"
" return true;\n"
@@ -1011,7 +999,7 @@
descriptor_->field(1)->full_name());
}
} else {
- format(" bool ValidateValue() const { return true; }\n");
+ format(" static bool ValidateValue(void*) { return true; }\n");
}
if (HasDescriptorMethods(descriptor_->file(), options_)) {
format(
@@ -1133,7 +1121,8 @@
"}\n"
"static constexpr int kIndexInFileMessages =\n"
" $1$;\n"
- "\n", index_in_file_messages_);
+ "\n",
+ index_in_file_messages_);
if (SupportsArenas(descriptor_)) {
format("void UnsafeArenaSwap($classname$* other);\n");
@@ -1218,9 +1207,6 @@
format.Set(
"is_initialized_final",
ShouldMarkIsInitializedAsFinal(descriptor_, options_) ? "final" : "");
- format.Set(
- "merge_partial_final",
- ShouldMarkMergePartialAsFinal(descriptor_, options_) ? "final" : "");
format(
"void CopyFrom(const $classname$& from);\n"
@@ -1234,8 +1220,7 @@
"::$proto_ns$::internal::ParseContext* ctx) final;\n"
"#else\n"
"bool MergePartialFromCodedStream(\n"
- " ::$proto_ns$::io::CodedInputStream* input)$ "
- "merge_partial_final$;\n"
+ " ::$proto_ns$::io::CodedInputStream* input) final;\n"
"#endif // $GOOGLE_PROTOBUF$_ENABLE_EXPERIMENTAL_PARSER\n");
if (!options_.table_driven_serialization ||
@@ -1432,11 +1417,6 @@
}
if (SupportsArenas(descriptor_)) {
- if (!options_.opensource_runtime) {
- format(
- "template <typename T> friend struct "
- "::proto::internal::EmbeddedMessageHolder;\n");
- }
format(
"template <typename T> friend class "
"::$proto_ns$::Arena::InternalHelper;\n"
@@ -1702,13 +1682,10 @@
vars["ptr"] = "nullptr";
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
GOOGLE_CHECK(!IsMapEntryMessage(field->message_type()));
- if (!IsProto1(field->message_type()->file(), options_)) {
- vars["ptr"] =
- "::" +
- UniqueName("TableStruct", field->message_type(), options_) +
- "::serialization_table + " +
- StrCat(FindMessageIndexInFile(field->message_type()));
- }
+ vars["ptr"] =
+ "::" + UniqueName("TableStruct", field->message_type(), options_) +
+ "::serialization_table + " +
+ StrCat(FindMessageIndexInFile(field->message_type()));
}
Formatter::SaveState saver(&format);
format.AddMap(vars);
@@ -1777,9 +1754,8 @@
tag, FindMessageIndexInFile(field->message_type()),
QualifiedClassName(field->message_type(), options_));
continue;
- } else if (!IsProto1(field->message_type()->file(), options_) &&
- !field->message_type()->options().message_set_wire_format()) {
- // Proto1 or message_set don't have the usual table and we need to
+ } else if (!field->message_type()->options().message_set_wire_format()) {
+ // message_set doesn't have the usual table and we need to
// dispatch to generated serializer, hence ptr stays zero.
ptr =
"::" + UniqueName("TableStruct", field->message_type(), options_) +
@@ -1869,8 +1845,7 @@
for (auto field : FieldRange(descriptor_)) {
Formatter::SaveState saver(&format);
- if (!field->is_repeated() &&
- !IsLazy(field, options_) &&
+ if (!field->is_repeated() && !IsLazy(field, options_) &&
field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
(field->containing_oneof() == NULL ||
HasDescriptorMethods(descriptor_->file(), options_))) {
@@ -1977,21 +1952,21 @@
"class $classname$::HasBitSetters {\n"
" public:\n");
format.Indent();
+ if (HasFieldPresence(descriptor_->file()) && HasBitsSize() != 0) {
+ format(
+ "using HasBits = decltype(std::declval<$classname$>()._has_bits_);\n");
+ }
for (auto field : FieldRange(descriptor_)) {
field_generators_.get(field).GenerateInternalAccessorDeclarations(printer);
if (HasFieldPresence(descriptor_->file()) && !field->is_repeated() &&
!field->options().weak() && !field->containing_oneof()) {
int has_bit_index = has_bit_indices_[field->index()];
GOOGLE_CHECK_GE(has_bit_index, 0);
-
- format.Set("has_array_index", has_bit_index / 32);
- format.Set("has_mask",
- strings::Hex(1u << (has_bit_index % 32), strings::ZERO_PAD_8));
format(
- "static void set_has_$1$($classname$* msg) {\n"
- " msg->_has_bits_[$has_array_index$] |= 0x$has_mask$u;\n"
+ "static void set_has_$1$(HasBits* has_bits) {\n"
+ " (*has_bits)[$2$] |= $3$u;\n"
"}\n",
- FieldName(field));
+ FieldName(field), has_bit_index / 32, (1u << (has_bit_index % 32)));
}
}
format.Outdent();
@@ -2259,7 +2234,8 @@
default_val = field->default_value_string().empty()
? "&::" + variables_["proto_ns"] +
"::internal::fixed_address_empty_string"
- : "&" + QualifiedClassName(descriptor_, options_) +
+ : "&" +
+ QualifiedClassName(descriptor_, options_) +
"::" + MakeDefaultName(field);
break;
case FieldOptions::CORD:
@@ -2355,8 +2331,7 @@
Formatter format(printer, variables_);
format("void $classname$::SharedCtor() {\n");
- if (scc_analyzer_
- ->GetSCCAnalysis(scc_analyzer_->GetSCC(descriptor_))
+ if (scc_analyzer_->GetSCCAnalysis(scc_analyzer_->GetSCC(descriptor_))
.constructor_requires_initialization) {
format(
" ::$proto_ns$::internal::InitSCC(\n"
@@ -2784,14 +2759,14 @@
unconditional_budget -= EstimateAlignmentSize(field);
}
- std::vector<std::vector<const FieldDescriptor*> > chunks_frag = CollectFields(
+ std::vector<std::vector<const FieldDescriptor*>> chunks_frag = CollectFields(
optimized_order_,
MatchRepeatedAndHasByteAndZeroInits(
&has_bit_indices_, HasFieldPresence(descriptor_->file())));
// Merge next non-zero initializable chunk if it has the same has_byte index
// and not meeting unconditional clear condition.
- std::vector<std::vector<const FieldDescriptor*> > chunks;
+ std::vector<std::vector<const FieldDescriptor*>> chunks;
if (!HasFieldPresence(descriptor_->file())) {
// Don't bother with merging without has_bit field.
chunks = chunks_frag;
@@ -3068,8 +3043,7 @@
}
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
- format(
- "swap(_oneof_case_[$1$], other->_oneof_case_[$1$]);\n", i);
+ format("swap(_oneof_case_[$1$], other->_oneof_case_[$1$]);\n", i);
}
if (num_weak_fields_) {
@@ -3387,7 +3361,8 @@
return;
}
format("#if $GOOGLE_PROTOBUF$_ENABLE_EXPERIMENTAL_PARSER\n");
- GenerateParserLoop(descriptor_, options_, scc_analyzer_, printer);
+ GenerateParserLoop(descriptor_, max_has_bit_index_, options_, scc_analyzer_,
+ printer);
format("#else // $GOOGLE_PROTOBUF$_ENABLE_EXPERIMENTAL_PARSER\n");
std::vector<const FieldDescriptor*> ordered_fields =
SortFieldsByNumber(descriptor_);
@@ -3539,9 +3514,8 @@
// Emit code to parse the common, expected case.
// MSVC is warning about truncating constant in the static_cast so
// we truncate the tag explicitly.
- format(
- "if (static_cast< $uint8$>(tag) == ($1$ & 0xFF)) {\n",
- WireFormat::MakeTag(field));
+ format("if (static_cast< $uint8$>(tag) == ($1$ & 0xFF)) {\n",
+ WireFormat::MakeTag(field));
format.Indent();
if (field->is_packed()) {
@@ -3557,9 +3531,8 @@
WireFormat::WireTypeForFieldType(field->type());
const uint32 tag =
internal::WireFormatLite::MakeTag(field->number(), wiretype);
- format(
- "} else if (static_cast< $uint8$>(tag) == ($1$ & 0xFF)) {\n",
- tag);
+ format("} else if (static_cast< $uint8$>(tag) == ($1$ & 0xFF)) {\n",
+ tag);
format.Indent();
field_generator.GenerateMergeFromCodedStream(printer);
@@ -3569,9 +3542,8 @@
internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
const uint32 tag =
internal::WireFormatLite::MakeTag(field->number(), wiretype);
- format(
- "} else if (static_cast< $uint8$>(tag) == ($1$ & 0xFF)) {\n",
- tag);
+ format("} else if (static_cast< $uint8$>(tag) == ($1$ & 0xFF)) {\n",
+ tag);
format.Indent();
field_generator.GenerateMergeFromCodedStreamWithPacking(printer);
format.Outdent();
@@ -4178,7 +4150,7 @@
}
}
- std::vector<std::vector<const FieldDescriptor*> > chunks = CollectFields(
+ std::vector<std::vector<const FieldDescriptor*>> chunks = CollectFields(
optimized_order_,
MatchRepeatedAndHasByteAndRequired(
&has_bit_indices_, HasFieldPresence(descriptor_->file())));
diff --git a/src/google/protobuf/compiler/cpp/cpp_message_field.cc b/src/google/protobuf/compiler/cpp/cpp_message_field.cc
index 32653bb..053e4fc 100644
--- a/src/google/protobuf/compiler/cpp/cpp_message_field.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_message_field.cc
@@ -91,8 +91,7 @@
// NOTE: Escaped here to unblock proto1->proto2 migration.
// TODO(liujisi): Extend this to apply for other conflicting methods.
(*variables)["release_name"] =
- SafeFunctionName(descriptor->containing_type(),
- descriptor, "release_");
+ SafeFunctionName(descriptor->containing_type(), descriptor, "release_");
(*variables)["full_name"] = descriptor->full_name();
}
@@ -111,8 +110,7 @@
MessageFieldGenerator::~MessageFieldGenerator() {}
-void MessageFieldGenerator::
-GeneratePrivateMembers(io::Printer* printer) const {
+void MessageFieldGenerator::GeneratePrivateMembers(io::Printer* printer) const {
Formatter format(printer, variables_);
if (implicit_weak_field_) {
format("::$proto_ns$::MessageLite* $name$_;\n");
@@ -121,8 +119,8 @@
}
}
-void MessageFieldGenerator::
-GenerateAccessorDeclarations(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateAccessorDeclarations(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"$deprecated_attr$const $type$& ${1$$name$$}$() const;\n"
@@ -165,8 +163,8 @@
}
}
-void MessageFieldGenerator::
-GenerateInlineAccessorDefinitions(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline const $type$& $classname$::$name$() const {\n"
@@ -271,8 +269,8 @@
"}\n");
}
-void MessageFieldGenerator::
-GenerateInternalAccessorDeclarations(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateInternalAccessorDeclarations(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (implicit_weak_field_) {
format(
@@ -285,8 +283,8 @@
}
}
-void MessageFieldGenerator::
-GenerateInternalAccessorDefinitions(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateInternalAccessorDefinitions(
+ io::Printer* printer) const {
// In theory, these accessors could be inline in HasBitSetters. However, in
// practice, the linker is then not able to throw them out making implicit
// weak dependencies not work at all.
@@ -363,8 +361,7 @@
}
}
-void MessageFieldGenerator::
-GenerateClearingCode(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
if (!HasFieldPresence(descriptor_->file())) {
// If we don't have has-bits, message presence is indicated only by ptr !=
@@ -379,8 +376,8 @@
}
}
-void MessageFieldGenerator::
-GenerateMessageClearingCode(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateMessageClearingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (!HasFieldPresence(descriptor_->file())) {
// If we don't have has-bits, message presence is indicated only by ptr !=
@@ -397,8 +394,7 @@
}
}
-void MessageFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
if (implicit_weak_field_) {
format(
@@ -409,14 +405,12 @@
}
}
-void MessageFieldGenerator::
-GenerateSwappingCode(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("swap($name$_, other->$name$_);\n");
}
-void MessageFieldGenerator::
-GenerateDestructorCode(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateDestructorCode(io::Printer* printer) const {
Formatter format(printer, variables_);
if (options_.opensource_runtime) {
// TODO(gerbens) Remove this when we don't need to destruct default
@@ -429,14 +423,14 @@
format("delete $name$_;\n");
}
-void MessageFieldGenerator::
-GenerateConstructorCode(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateConstructorCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_ = nullptr;\n");
}
-void MessageFieldGenerator::
-GenerateCopyConstructorCode(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateCopyConstructorCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"if (from.has_$name$()) {\n"
@@ -446,8 +440,8 @@
"}\n");
}
-void MessageFieldGenerator::
-GenerateMergeFromCodedStream(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateMergeFromCodedStream(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (implicit_weak_field_) {
format(
@@ -464,16 +458,16 @@
}
}
-void MessageFieldGenerator::
-GenerateSerializeWithCachedSizes(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateSerializeWithCachedSizes(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"::$proto_ns$::internal::WireFormatLite::Write$stream_writer$(\n"
" $number$, HasBitSetters::$name$(this), output);\n");
}
-void MessageFieldGenerator::
-GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateSerializeWithCachedSizesToArray(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"target = ::$proto_ns$::internal::WireFormatLite::\n"
@@ -481,8 +475,7 @@
" $number$, HasBitSetters::$name$(this), target);\n");
}
-void MessageFieldGenerator::
-GenerateByteSize(io::Printer* printer) const {
+void MessageFieldGenerator::GenerateByteSize(io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"total_size += $tag_size$ +\n"
@@ -536,8 +529,8 @@
"}\n");
}
-void MessageOneofFieldGenerator::
-GenerateInlineAccessorDefinitions(io::Printer* printer) const {
+void MessageOneofFieldGenerator::GenerateInlineAccessorDefinitions(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline $type$* $classname$::$release_name$() {\n"
@@ -609,8 +602,8 @@
"}\n");
}
-void MessageOneofFieldGenerator::
-GenerateClearingCode(io::Printer* printer) const {
+void MessageOneofFieldGenerator::GenerateClearingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (SupportsArenas(descriptor_)) {
format(
@@ -622,24 +615,24 @@
}
}
-void MessageOneofFieldGenerator::
-GenerateMessageClearingCode(io::Printer* printer) const {
+void MessageOneofFieldGenerator::GenerateMessageClearingCode(
+ io::Printer* printer) const {
GenerateClearingCode(printer);
}
-void MessageOneofFieldGenerator::
-GenerateSwappingCode(io::Printer* printer) const {
+void MessageOneofFieldGenerator::GenerateSwappingCode(
+ io::Printer* printer) const {
// Don't print any swapping code. Swapping the union will swap this field.
}
-void MessageOneofFieldGenerator::
-GenerateDestructorCode(io::Printer* printer) const {
+void MessageOneofFieldGenerator::GenerateDestructorCode(
+ io::Printer* printer) const {
// We inherit from MessageFieldGenerator, so we need to override the default
// behavior.
}
-void MessageOneofFieldGenerator::
-GenerateConstructorCode(io::Printer* printer) const {
+void MessageOneofFieldGenerator::GenerateConstructorCode(
+ io::Printer* printer) const {
// Don't print any constructor code. The field is in a union. We allocate
// space only when this field is used.
}
@@ -657,14 +650,14 @@
RepeatedMessageFieldGenerator::~RepeatedMessageFieldGenerator() {}
-void RepeatedMessageFieldGenerator::
-GeneratePrivateMembers(io::Printer* printer) const {
+void RepeatedMessageFieldGenerator::GeneratePrivateMembers(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("::$proto_ns$::RepeatedPtrField< $type$ > $name$_;\n");
}
-void RepeatedMessageFieldGenerator::
-GenerateAccessorDeclarations(io::Printer* printer) const {
+void RepeatedMessageFieldGenerator::GenerateAccessorDeclarations(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"$deprecated_attr$$type$* ${1$mutable_$name$$}$(int index);\n"
@@ -677,8 +670,8 @@
descriptor_);
}
-void RepeatedMessageFieldGenerator::
-GenerateInlineAccessorDefinitions(io::Printer* printer) const {
+void RepeatedMessageFieldGenerator::GenerateInlineAccessorDefinitions(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline $type$* $classname$::mutable_$name$(int index) {\n"
@@ -725,8 +718,8 @@
"}\n");
}
-void RepeatedMessageFieldGenerator::
-GenerateClearingCode(io::Printer* printer) const {
+void RepeatedMessageFieldGenerator::GenerateClearingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (implicit_weak_field_) {
format(
@@ -737,8 +730,8 @@
}
}
-void RepeatedMessageFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void RepeatedMessageFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (implicit_weak_field_) {
format(
@@ -750,19 +743,19 @@
}
}
-void RepeatedMessageFieldGenerator::
-GenerateSwappingCode(io::Printer* printer) const {
+void RepeatedMessageFieldGenerator::GenerateSwappingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("CastToBase(&$name$_)->InternalSwap(CastToBase(&other->$name$_));\n");
}
-void RepeatedMessageFieldGenerator::
-GenerateConstructorCode(io::Printer* printer) const {
+void RepeatedMessageFieldGenerator::GenerateConstructorCode(
+ io::Printer* printer) const {
// Not needed for repeated fields.
}
-void RepeatedMessageFieldGenerator::
-GenerateMergeFromCodedStream(io::Printer* printer) const {
+void RepeatedMessageFieldGenerator::GenerateMergeFromCodedStream(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (descriptor_->type() == FieldDescriptor::TYPE_MESSAGE) {
if (implicit_weak_field_) {
@@ -784,8 +777,8 @@
}
}
-void RepeatedMessageFieldGenerator::
-GenerateSerializeWithCachedSizes(io::Printer* printer) const {
+void RepeatedMessageFieldGenerator::GenerateSerializeWithCachedSizes(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"for (unsigned int i = 0,\n"
@@ -805,8 +798,8 @@
"}\n");
}
-void RepeatedMessageFieldGenerator::
-GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
+void RepeatedMessageFieldGenerator::GenerateSerializeWithCachedSizesToArray(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"for (unsigned int i = 0,\n"
@@ -817,8 +810,8 @@
"}\n");
}
-void RepeatedMessageFieldGenerator::
-GenerateByteSize(io::Printer* printer) const {
+void RepeatedMessageFieldGenerator::GenerateByteSize(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"{\n"
diff --git a/src/google/protobuf/compiler/cpp/cpp_options.h b/src/google/protobuf/compiler/cpp/cpp_options.h
index 4056ecc..6616e4b 100644
--- a/src/google/protobuf/compiler/cpp/cpp_options.h
+++ b/src/google/protobuf/compiler/cpp/cpp_options.h
@@ -44,7 +44,7 @@
enum class EnforceOptimizeMode {
kNoEnforcement, // Use the runtime specified by the file specific options.
- kSpeed, // This is the full runtime.
+ kSpeed, // This is the full runtime.
kLiteRuntime,
};
@@ -73,5 +73,4 @@
} // namespace protobuf
} // namespace google
-
#endif // GOOGLE_PROTOBUF_COMPILER_CPP_OPTIONS_H__
diff --git a/src/google/protobuf/compiler/cpp/cpp_plugin_unittest.cc b/src/google/protobuf/compiler/cpp/cpp_plugin_unittest.cc
index 96b5a8b..10e468b 100644
--- a/src/google/protobuf/compiler/cpp/cpp_plugin_unittest.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_plugin_unittest.cc
@@ -38,8 +38,8 @@
#include <google/protobuf/compiler/cpp/cpp_generator.h>
#include <google/protobuf/compiler/command_line_interface.h>
-#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/io/printer.h>
+#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/testing/file.h>
#include <google/protobuf/testing/file.h>
@@ -128,7 +128,8 @@
// Check field accessors for a message inside oneof{}:
TryInsert("test.pb.h", "field_get:foo.Bar.oneOfMessage", context);
TryInsert("test.pb.h", "field_mutable:foo.Bar.oneOfMessage", context);
- TryInsert("test.pb.cc", "field_set_allocated:foo.Bar.oneOfMessage", context);
+ TryInsert("test.pb.cc", "field_set_allocated:foo.Bar.oneOfMessage",
+ context);
// Check field accessors for an optional enum:
TryInsert("test.pb.h", "field_get:foo.Bar.optEnum", context);
@@ -231,13 +232,8 @@
std::string cpp_out = "--cpp_out=" + TestTempDir();
std::string test_out = "--test_out=" + TestTempDir();
- const char* argv[] = {
- "protoc",
- proto_path.c_str(),
- cpp_out.c_str(),
- test_out.c_str(),
- "test.proto"
- };
+ const char* argv[] = {"protoc", proto_path.c_str(), cpp_out.c_str(),
+ test_out.c_str(), "test.proto"};
EXPECT_EQ(0, cli.Run(5, argv));
}
diff --git a/src/google/protobuf/compiler/cpp/cpp_primitive_field.cc b/src/google/protobuf/compiler/cpp/cpp_primitive_field.cc
index 9ab20c1..164bb1c 100644
--- a/src/google/protobuf/compiler/cpp/cpp_primitive_field.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_primitive_field.cc
@@ -52,29 +52,47 @@
// returns -1.
int FixedSize(FieldDescriptor::Type type) {
switch (type) {
- case FieldDescriptor::TYPE_INT32 : return -1;
- case FieldDescriptor::TYPE_INT64 : return -1;
- case FieldDescriptor::TYPE_UINT32 : return -1;
- case FieldDescriptor::TYPE_UINT64 : return -1;
- case FieldDescriptor::TYPE_SINT32 : return -1;
- case FieldDescriptor::TYPE_SINT64 : return -1;
- case FieldDescriptor::TYPE_FIXED32 : return WireFormatLite::kFixed32Size;
- case FieldDescriptor::TYPE_FIXED64 : return WireFormatLite::kFixed64Size;
- case FieldDescriptor::TYPE_SFIXED32: return WireFormatLite::kSFixed32Size;
- case FieldDescriptor::TYPE_SFIXED64: return WireFormatLite::kSFixed64Size;
- case FieldDescriptor::TYPE_FLOAT : return WireFormatLite::kFloatSize;
- case FieldDescriptor::TYPE_DOUBLE : return WireFormatLite::kDoubleSize;
+ case FieldDescriptor::TYPE_INT32:
+ return -1;
+ case FieldDescriptor::TYPE_INT64:
+ return -1;
+ case FieldDescriptor::TYPE_UINT32:
+ return -1;
+ case FieldDescriptor::TYPE_UINT64:
+ return -1;
+ case FieldDescriptor::TYPE_SINT32:
+ return -1;
+ case FieldDescriptor::TYPE_SINT64:
+ return -1;
+ case FieldDescriptor::TYPE_FIXED32:
+ return WireFormatLite::kFixed32Size;
+ case FieldDescriptor::TYPE_FIXED64:
+ return WireFormatLite::kFixed64Size;
+ case FieldDescriptor::TYPE_SFIXED32:
+ return WireFormatLite::kSFixed32Size;
+ case FieldDescriptor::TYPE_SFIXED64:
+ return WireFormatLite::kSFixed64Size;
+ case FieldDescriptor::TYPE_FLOAT:
+ return WireFormatLite::kFloatSize;
+ case FieldDescriptor::TYPE_DOUBLE:
+ return WireFormatLite::kDoubleSize;
- case FieldDescriptor::TYPE_BOOL : return WireFormatLite::kBoolSize;
- case FieldDescriptor::TYPE_ENUM : return -1;
+ case FieldDescriptor::TYPE_BOOL:
+ return WireFormatLite::kBoolSize;
+ case FieldDescriptor::TYPE_ENUM:
+ return -1;
- case FieldDescriptor::TYPE_STRING : return -1;
- case FieldDescriptor::TYPE_BYTES : return -1;
- case FieldDescriptor::TYPE_GROUP : return -1;
- case FieldDescriptor::TYPE_MESSAGE : return -1;
+ case FieldDescriptor::TYPE_STRING:
+ return -1;
+ case FieldDescriptor::TYPE_BYTES:
+ return -1;
+ case FieldDescriptor::TYPE_GROUP:
+ return -1;
+ case FieldDescriptor::TYPE_MESSAGE:
+ return -1;
- // No default because we want the compiler to complain if any new
- // types are added.
+ // No default because we want the compiler to complain if any new
+ // types are added.
}
GOOGLE_LOG(FATAL) << "Can't get here.";
return -1;
@@ -108,14 +126,14 @@
PrimitiveFieldGenerator::~PrimitiveFieldGenerator() {}
-void PrimitiveFieldGenerator::
-GeneratePrivateMembers(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GeneratePrivateMembers(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$type$ $name$_;\n");
}
-void PrimitiveFieldGenerator::
-GenerateAccessorDeclarations(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GenerateAccessorDeclarations(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"$deprecated_attr$$type$ ${1$$name$$}$() const;\n"
@@ -123,8 +141,8 @@
descriptor_);
}
-void PrimitiveFieldGenerator::
-GenerateInlineAccessorDefinitions(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::$name$() const {\n"
@@ -138,38 +156,35 @@
"}\n");
}
-void PrimitiveFieldGenerator::
-GenerateClearingCode(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_ = $default$;\n");
}
-void PrimitiveFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("set_$name$(from.$name$());\n");
}
-void PrimitiveFieldGenerator::
-GenerateSwappingCode(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("swap($name$_, other->$name$_);\n");
}
-void PrimitiveFieldGenerator::
-GenerateConstructorCode(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GenerateConstructorCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_ = $default$;\n");
}
-void PrimitiveFieldGenerator::
-GenerateCopyConstructorCode(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GenerateCopyConstructorCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_ = from.$name$_;\n");
}
-void PrimitiveFieldGenerator::
-GenerateMergeFromCodedStream(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GenerateMergeFromCodedStream(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"$set_hasbit_io$\n"
@@ -179,16 +194,16 @@
" input, &$name$_)));\n");
}
-void PrimitiveFieldGenerator::
-GenerateSerializeWithCachedSizes(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GenerateSerializeWithCachedSizes(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"::$proto_ns$::internal::WireFormatLite::Write$declared_type$("
"$number$, this->$name$(), output);\n");
}
-void PrimitiveFieldGenerator::
-GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GenerateSerializeWithCachedSizesToArray(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"target = "
@@ -196,8 +211,7 @@
"$number$, this->$name$(), target);\n");
}
-void PrimitiveFieldGenerator::
-GenerateByteSize(io::Printer* printer) const {
+void PrimitiveFieldGenerator::GenerateByteSize(io::Printer* printer) const {
Formatter format(printer, variables_);
int fixed_size = FixedSize(descriptor_->type());
if (fixed_size == -1) {
@@ -212,17 +226,16 @@
// ===================================================================
-PrimitiveOneofFieldGenerator::
-PrimitiveOneofFieldGenerator(const FieldDescriptor* descriptor,
- const Options& options)
- : PrimitiveFieldGenerator(descriptor, options) {
+PrimitiveOneofFieldGenerator::PrimitiveOneofFieldGenerator(
+ const FieldDescriptor* descriptor, const Options& options)
+ : PrimitiveFieldGenerator(descriptor, options) {
SetCommonOneofFieldVariables(descriptor, &variables_);
}
PrimitiveOneofFieldGenerator::~PrimitiveOneofFieldGenerator() {}
-void PrimitiveOneofFieldGenerator::
-GenerateInlineAccessorDefinitions(io::Printer* printer) const {
+void PrimitiveOneofFieldGenerator::GenerateInlineAccessorDefinitions(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::$name$() const {\n"
@@ -242,25 +255,25 @@
"}\n");
}
-void PrimitiveOneofFieldGenerator::
-GenerateClearingCode(io::Printer* printer) const {
+void PrimitiveOneofFieldGenerator::GenerateClearingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$field_member$ = $default$;\n");
}
-void PrimitiveOneofFieldGenerator::
-GenerateSwappingCode(io::Printer* printer) const {
+void PrimitiveOneofFieldGenerator::GenerateSwappingCode(
+ io::Printer* printer) const {
// Don't print any swapping code. Swapping the union will swap this field.
}
-void PrimitiveOneofFieldGenerator::
-GenerateConstructorCode(io::Printer* printer) const {
+void PrimitiveOneofFieldGenerator::GenerateConstructorCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$ns$::_$classname$_default_instance_.$name$_ = $default$;\n");
}
-void PrimitiveOneofFieldGenerator::
-GenerateMergeFromCodedStream(io::Printer* printer) const {
+void PrimitiveOneofFieldGenerator::GenerateMergeFromCodedStream(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"clear_$oneof_name$();\n"
@@ -289,8 +302,8 @@
RepeatedPrimitiveFieldGenerator::~RepeatedPrimitiveFieldGenerator() {}
-void RepeatedPrimitiveFieldGenerator::
-GeneratePrivateMembers(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GeneratePrivateMembers(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("::$proto_ns$::RepeatedField< $type$ > $name$_;\n");
if (descriptor_->is_packed() &&
@@ -299,8 +312,8 @@
}
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateAccessorDeclarations(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateAccessorDeclarations(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"$deprecated_attr$$type$ ${1$$name$$}$(int index) const;\n"
@@ -313,8 +326,8 @@
descriptor_);
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateInlineAccessorDefinitions(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::$name$(int index) const {\n"
@@ -341,37 +354,37 @@
"}\n");
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateClearingCode(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateClearingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.Clear();\n");
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.MergeFrom(from.$name$_);\n");
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateSwappingCode(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateSwappingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.InternalSwap(&other->$name$_);\n");
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateConstructorCode(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateConstructorCode(
+ io::Printer* printer) const {
// Not needed for repeated fields.
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateCopyConstructorCode(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateCopyConstructorCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.CopyFrom(from.$name$_);\n");
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateMergeFromCodedStream(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateMergeFromCodedStream(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"DO_((::$proto_ns$::internal::WireFormatLite::$repeated_reader$<\n"
@@ -380,8 +393,8 @@
" $tag_size$, $tag$u, input, this->mutable_$name$())));\n");
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateMergeFromCodedStreamWithPacking(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateMergeFromCodedStreamWithPacking(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"DO_((::$proto_ns$::internal::WireFormatLite::$packed_reader$<\n"
@@ -390,8 +403,8 @@
" input, this->mutable_$name$())));\n");
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateSerializeWithCachedSizes(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateSerializeWithCachedSizes(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
bool array_written = false;
if (descriptor_->is_packed()) {
@@ -433,8 +446,8 @@
}
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateSerializeWithCachedSizesToArray(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (descriptor_->is_packed()) {
// Write the tag and the size.
@@ -459,8 +472,8 @@
}
}
-void RepeatedPrimitiveFieldGenerator::
-GenerateByteSize(io::Printer* printer) const {
+void RepeatedPrimitiveFieldGenerator::GenerateByteSize(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("{\n");
format.Indent();
diff --git a/src/google/protobuf/compiler/cpp/cpp_string_field.cc b/src/google/protobuf/compiler/cpp/cpp_string_field.cc
index a5a0a60..bd25d7a 100644
--- a/src/google/protobuf/compiler/cpp/cpp_string_field.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_string_field.cc
@@ -68,8 +68,7 @@
// NOTE: Escaped here to unblock proto1->proto2 migration.
// TODO(liujisi): Extend this to apply for other conflicting methods.
(*variables)["release_name"] =
- SafeFunctionName(descriptor->containing_type(),
- descriptor, "release_");
+ SafeFunctionName(descriptor->containing_type(), descriptor, "release_");
(*variables)["full_name"] = descriptor->full_name();
if (options.opensource_runtime) {
@@ -96,8 +95,7 @@
StringFieldGenerator::~StringFieldGenerator() {}
-void StringFieldGenerator::
-GeneratePrivateMembers(io::Printer* printer) const {
+void StringFieldGenerator::GeneratePrivateMembers(io::Printer* printer) const {
Formatter format(printer, variables_);
if (inlined_) {
format("::$proto_ns$::internal::InlinedStringField $name$_;\n");
@@ -118,8 +116,7 @@
}
}
-void StringFieldGenerator::
-GenerateStaticMembers(io::Printer* printer) const {
+void StringFieldGenerator::GenerateStaticMembers(io::Printer* printer) const {
Formatter format(printer, variables_);
if (!descriptor_->default_value_string().empty()) {
// We make the default instance public, so it can be initialized by
@@ -132,8 +129,8 @@
}
}
-void StringFieldGenerator::
-GenerateAccessorDeclarations(io::Printer* printer) const {
+void StringFieldGenerator::GenerateAccessorDeclarations(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
// If we're using StringFieldGenerator for a field with a ctype, it's
// because that ctype isn't actually implemented. In particular, this is
@@ -208,8 +205,8 @@
}
}
-void StringFieldGenerator::
-GenerateInlineAccessorDefinitions(io::Printer* printer) const {
+void StringFieldGenerator::GenerateInlineAccessorDefinitions(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (SupportsArenas(descriptor_)) {
format(
@@ -389,8 +386,8 @@
}
}
-void StringFieldGenerator::
-GenerateNonInlineAccessorDefinitions(io::Printer* printer) const {
+void StringFieldGenerator::GenerateNonInlineAccessorDefinitions(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (!descriptor_->default_value_string().empty()) {
// Initialized in GenerateDefaultInstanceAllocator.
@@ -400,8 +397,7 @@
}
}
-void StringFieldGenerator::
-GenerateClearingCode(io::Printer* printer) const {
+void StringFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
// Two-dimension specialization here: supporting arenas or not, and default
// value is the empty string or not. Complexity here ensures the minimal
@@ -424,8 +420,8 @@
}
}
-void StringFieldGenerator::
-GenerateMessageClearingCode(io::Printer* printer) const {
+void StringFieldGenerator::GenerateMessageClearingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
// Two-dimension specialization here: supporting arenas, field presence, or
// not, and default value is the empty string or not. Complexity here ensures
@@ -435,8 +431,7 @@
// If we have field presence, then the Clear() method of the protocol buffer
// will have checked that this field is set. If so, we can avoid redundant
// checks against default_variable.
- const bool must_be_present =
- HasFieldPresence(descriptor_->file());
+ const bool must_be_present = HasFieldPresence(descriptor_->file());
if (inlined_ && must_be_present) {
// Calling mutable_$name$() gives us a string reference and sets the has bit
@@ -481,8 +476,7 @@
}
}
-void StringFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void StringFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
if (SupportsArenas(descriptor_) || descriptor_->containing_oneof() != NULL) {
// TODO(gpike): improve this
@@ -494,8 +488,7 @@
}
}
-void StringFieldGenerator::
-GenerateSwappingCode(io::Printer* printer) const {
+void StringFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
if (inlined_) {
format("$name$_.Swap(&other->$name$_);\n");
@@ -506,8 +499,7 @@
}
}
-void StringFieldGenerator::
-GenerateConstructorCode(io::Printer* printer) const {
+void StringFieldGenerator::GenerateConstructorCode(io::Printer* printer) const {
Formatter format(printer, variables_);
// TODO(ckennelly): Construct non-empty strings as part of the initializer
// list.
@@ -519,8 +511,8 @@
format("$name$_.UnsafeSetDefault($default_variable$);\n");
}
-void StringFieldGenerator::
-GenerateCopyConstructorCode(io::Printer* printer) const {
+void StringFieldGenerator::GenerateCopyConstructorCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
GenerateConstructorCode(printer);
@@ -545,8 +537,7 @@
format("}\n");
}
-void StringFieldGenerator::
-GenerateDestructorCode(io::Printer* printer) const {
+void StringFieldGenerator::GenerateDestructorCode(io::Printer* printer) const {
Formatter format(printer, variables_);
if (inlined_) {
// The destructor is automatically invoked.
@@ -567,8 +558,8 @@
return true;
}
-void StringFieldGenerator::
-GenerateDefaultInstanceAllocator(io::Printer* printer) const {
+void StringFieldGenerator::GenerateDefaultInstanceAllocator(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (!descriptor_->default_value_string().empty()) {
format(
@@ -580,8 +571,8 @@
}
}
-void StringFieldGenerator::
-GenerateMergeFromCodedStream(io::Printer* printer) const {
+void StringFieldGenerator::GenerateMergeFromCodedStream(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
// The google3 version of proto2 has ArenaStrings and parses into them
// directly, but for the open-source release, we always parse into std::string
@@ -617,13 +608,12 @@
}
}
-bool StringFieldGenerator::
-MergeFromCodedStreamNeedsArena() const {
+bool StringFieldGenerator::MergeFromCodedStreamNeedsArena() const {
return !lite_ && !inlined_ && !options_.opensource_runtime;
}
-void StringFieldGenerator::
-GenerateSerializeWithCachedSizes(io::Printer* printer) const {
+void StringFieldGenerator::GenerateSerializeWithCachedSizes(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (descriptor_->type() == FieldDescriptor::TYPE_STRING) {
GenerateUtf8CheckCodeForString(
@@ -637,8 +627,8 @@
" $number$, this->$name$(), output);\n");
}
-void StringFieldGenerator::
-GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
+void StringFieldGenerator::GenerateSerializeWithCachedSizesToArray(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (descriptor_->type() == FieldDescriptor::TYPE_STRING) {
GenerateUtf8CheckCodeForString(
@@ -652,8 +642,7 @@
" $number$, this->$name$(), target);\n");
}
-void StringFieldGenerator::
-GenerateByteSize(io::Printer* printer) const {
+void StringFieldGenerator::GenerateByteSize(io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"total_size += $tag_size$ +\n"
@@ -677,8 +666,8 @@
StringOneofFieldGenerator::~StringOneofFieldGenerator() {}
-void StringOneofFieldGenerator::
-GenerateInlineAccessorDefinitions(io::Printer* printer) const {
+void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (SupportsArenas(descriptor_)) {
format(
@@ -906,8 +895,8 @@
}
}
-void StringOneofFieldGenerator::
-GenerateClearingCode(io::Printer* printer) const {
+void StringOneofFieldGenerator::GenerateClearingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (SupportsArenas(descriptor_)) {
format(
@@ -918,26 +907,26 @@
}
}
-void StringOneofFieldGenerator::
-GenerateMessageClearingCode(io::Printer* printer) const {
+void StringOneofFieldGenerator::GenerateMessageClearingCode(
+ io::Printer* printer) const {
return GenerateClearingCode(printer);
}
-void StringOneofFieldGenerator::
-GenerateSwappingCode(io::Printer* printer) const {
+void StringOneofFieldGenerator::GenerateSwappingCode(
+ io::Printer* printer) const {
// Don't print any swapping code. Swapping the union will swap this field.
}
-void StringOneofFieldGenerator::
-GenerateConstructorCode(io::Printer* printer) const {
+void StringOneofFieldGenerator::GenerateConstructorCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"$ns$::_$classname$_default_instance_.$name$_.UnsafeSetDefault(\n"
" $default_variable$);\n");
}
-void StringOneofFieldGenerator::
-GenerateDestructorCode(io::Printer* printer) const {
+void StringOneofFieldGenerator::GenerateDestructorCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"if (has_$name$()) {\n"
@@ -945,8 +934,8 @@
"}\n");
}
-void StringOneofFieldGenerator::
-GenerateMergeFromCodedStream(io::Printer* printer) const {
+void StringOneofFieldGenerator::GenerateMergeFromCodedStream(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
// See above: ArenaString is not included in the open-source release.
if (!options_.opensource_runtime && SupportsArenas(descriptor_) && !lite_) {
@@ -982,7 +971,6 @@
}
}
-
// ===================================================================
RepeatedStringFieldGenerator::RepeatedStringFieldGenerator(
@@ -993,14 +981,14 @@
RepeatedStringFieldGenerator::~RepeatedStringFieldGenerator() {}
-void RepeatedStringFieldGenerator::
-GeneratePrivateMembers(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GeneratePrivateMembers(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("::$proto_ns$::RepeatedPtrField<std::string> $name$_;\n");
}
-void RepeatedStringFieldGenerator::
-GenerateAccessorDeclarations(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GenerateAccessorDeclarations(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
// See comment above about unknown ctypes.
bool unknown_ctype = descriptor_->options().ctype() !=
@@ -1062,8 +1050,8 @@
}
}
-void RepeatedStringFieldGenerator::
-GenerateInlineAccessorDefinitions(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GenerateInlineAccessorDefinitions(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
if (options_.safe_boundary_check) {
format(
@@ -1157,37 +1145,37 @@
"}\n");
}
-void RepeatedStringFieldGenerator::
-GenerateClearingCode(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GenerateClearingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.Clear();\n");
}
-void RepeatedStringFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.MergeFrom(from.$name$_);\n");
}
-void RepeatedStringFieldGenerator::
-GenerateSwappingCode(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GenerateSwappingCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.InternalSwap(CastToBase(&other->$name$_));\n");
}
-void RepeatedStringFieldGenerator::
-GenerateConstructorCode(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GenerateConstructorCode(
+ io::Printer* printer) const {
// Not needed for repeated fields.
}
-void RepeatedStringFieldGenerator::
-GenerateCopyConstructorCode(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GenerateCopyConstructorCode(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.CopyFrom(from.$name$_);");
}
-void RepeatedStringFieldGenerator::
-GenerateMergeFromCodedStream(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GenerateMergeFromCodedStream(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"DO_(::$proto_ns$::internal::WireFormatLite::Read$declared_type$(\n"
@@ -1201,8 +1189,8 @@
}
}
-void RepeatedStringFieldGenerator::
-GenerateSerializeWithCachedSizes(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GenerateSerializeWithCachedSizes(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("for (int i = 0, n = this->$name$_size(); i < n; i++) {\n");
format.Indent();
@@ -1219,8 +1207,8 @@
"}\n");
}
-void RepeatedStringFieldGenerator::
-GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GenerateSerializeWithCachedSizesToArray(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format("for (int i = 0, n = this->$name$_size(); i < n; i++) {\n");
format.Indent();
@@ -1237,8 +1225,8 @@
"}\n");
}
-void RepeatedStringFieldGenerator::
-GenerateByteSize(io::Printer* printer) const {
+void RepeatedStringFieldGenerator::GenerateByteSize(
+ io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"total_size += $tag_size$ *\n"
diff --git a/src/google/protobuf/compiler/cpp/cpp_unittest.cc b/src/google/protobuf/compiler/cpp/cpp_unittest.cc
index 4a52460..74310a7 100644
--- a/src/google/protobuf/compiler/cpp/cpp_unittest.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_unittest.cc
@@ -47,8 +47,8 @@
#include <google/protobuf/compiler/cpp/cpp_unittest.h>
#include <google/protobuf/unittest.pb.h>
-#include <google/protobuf/unittest_optimize_for.pb.h>
#include <google/protobuf/unittest_embed_optimize_for.pb.h>
+#include <google/protobuf/unittest_optimize_for.pb.h>
#include <google/protobuf/test_util.h>
@@ -96,8 +96,7 @@
// parameter names.
typedef protobuf_unittest::TestConflictingSymbolNamesExtension ExtensionMessage;
message.AddExtension(ExtensionMessage::repeated_int32_ext, 123);
- EXPECT_EQ(123,
- message.GetExtension(ExtensionMessage::repeated_int32_ext, 0));
+ EXPECT_EQ(123, message.GetExtension(ExtensionMessage::repeated_int32_ext, 0));
}
TEST(GENERATED_MESSAGE_TEST_NAME, TestConflictingEnumNames) {
@@ -128,7 +127,6 @@
EXPECT_EQ(123, message.GetExtension(protobuf_unittest::void_));
}
-
} // namespace cpp_unittest
} // namespace cpp
} // namespace compiler
diff --git a/src/google/protobuf/compiler/cpp/metadata_test.cc b/src/google/protobuf/compiler/cpp/metadata_test.cc
index 3cdda93..045c6a3 100644
--- a/src/google/protobuf/compiler/cpp/metadata_test.cc
+++ b/src/google/protobuf/compiler/cpp/metadata_test.cc
@@ -69,8 +69,7 @@
"annotation_guard_name=guard_name:" +
TestTempDir();
- const bool result =
- atu::RunProtoCompiler(filename, cpp_out, &cli, file);
+ const bool result = atu::RunProtoCompiler(filename, cpp_out, &cli, file);
if (!result) {
return result;
diff --git a/src/google/protobuf/compiler/importer.cc b/src/google/protobuf/compiler/importer.cc
index 54ddfb8..715d999 100644
--- a/src/google/protobuf/compiler/importer.cc
+++ b/src/google/protobuf/compiler/importer.cc
@@ -37,10 +37,10 @@
#else
#include <unistd.h>
#endif
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
#include <algorithm>
#include <memory>
@@ -48,12 +48,12 @@
#include <google/protobuf/compiler/importer.h>
#include <google/protobuf/compiler/parser.h>
+#include <google/protobuf/io/io_win32.h>
#include <google/protobuf/io/tokenizer.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/stubs/strutil.h>
-#include <google/protobuf/stubs/io_win32.h>
#ifdef _WIN32
#include <ctype.h>
@@ -66,8 +66,8 @@
#ifdef _WIN32
// DO NOT include <io.h>, instead create functions in io_win32.{h,cc} and import
// them like we do below.
-using google::protobuf::internal::win32::access;
-using google::protobuf::internal::win32::open;
+using google::protobuf::io::win32::access;
+using google::protobuf::io::win32::open;
#endif
// Returns true if the text looks like a Windows-style absolute path, starting
@@ -75,10 +75,8 @@
// copy in command_line_interface.cc?
static bool IsWindowsAbsolutePath(const std::string& text) {
#if defined(_WIN32) || defined(__CYGWIN__)
- return text.size() >= 3 && text[1] == ':' &&
- isalpha(text[0]) &&
- (text[2] == '/' || text[2] == '\\') &&
- text.find_last_of(':') == 1;
+ return text.size() >= 3 && text[1] == ':' && isalpha(text[0]) &&
+ (text[2] == '/' || text[2] == '\\') && text.find_last_of(':') == 1;
#else
return false;
#endif
@@ -165,8 +163,7 @@
// Parse it.
output->set_name(filename);
- return parser.Parse(&tokenizer, output) &&
- !file_error_collector.had_errors();
+ return parser.Parse(&tokenizer, output) && !file_error_collector.had_errors();
}
bool SourceTreeDescriptorDatabase::FindFileContainingSymbol(
@@ -183,11 +180,11 @@
// -------------------------------------------------------------------
SourceTreeDescriptorDatabase::ValidationErrorCollector::
-ValidationErrorCollector(SourceTreeDescriptorDatabase* owner)
- : owner_(owner) {}
+ ValidationErrorCollector(SourceTreeDescriptorDatabase* owner)
+ : owner_(owner) {}
SourceTreeDescriptorDatabase::ValidationErrorCollector::
-~ValidationErrorCollector() {}
+ ~ValidationErrorCollector() {}
void SourceTreeDescriptorDatabase::ValidationErrorCollector::AddError(
const std::string& filename, const std::string& element_name,
@@ -196,7 +193,12 @@
if (owner_->error_collector_ == NULL) return;
int line, column;
- owner_->source_locations_.Find(descriptor, location, &line, &column);
+ if (location == DescriptorPool::ErrorCollector::IMPORT) {
+ owner_->source_locations_.FindImport(descriptor, element_name, &line,
+ &column);
+ } else {
+ owner_->source_locations_.Find(descriptor, location, &line, &column);
+ }
owner_->error_collector_->AddError(filename, line, column, message);
}
@@ -207,7 +209,12 @@
if (owner_->error_collector_ == NULL) return;
int line, column;
- owner_->source_locations_.Find(descriptor, location, &line, &column);
+ if (location == DescriptorPool::ErrorCollector::IMPORT) {
+ owner_->source_locations_.FindImport(descriptor, element_name, &line,
+ &column);
+ } else {
+ owner_->source_locations_.Find(descriptor, location, &line, &column);
+ }
owner_->error_collector_->AddWarning(filename, line, column, message);
}
@@ -215,8 +222,8 @@
Importer::Importer(SourceTree* source_tree,
MultiFileErrorCollector* error_collector)
- : database_(source_tree),
- pool_(&database_, database_.GetValidationErrorCollector()) {
+ : database_(source_tree),
+ pool_(&database_, database_.GetValidationErrorCollector()) {
pool_.EnforceWeakDependencies(true);
database_.RecordErrorsTo(error_collector);
}
@@ -297,8 +304,8 @@
// Restore leading slash.
result = '/' + result;
}
- if (!path.empty() && LastChar(path) == '/' &&
- !result.empty() && LastChar(result) != '/') {
+ if (!path.empty() && LastChar(path) == '/' && !result.empty() &&
+ LastChar(result) != '/') {
// Restore trailing slash.
result += '/';
}
@@ -453,8 +460,9 @@
// We do not allow importing of paths containing things like ".." or
// consecutive slashes since the compiler expects files to be uniquely
// identified by file name.
- last_error_message_ = "Backslashes, consecutive slashes, \".\", or \"..\" "
- "are not allowed in the virtual path";
+ last_error_message_ =
+ "Backslashes, consecutive slashes, \".\", or \"..\" "
+ "are not allowed in the virtual path";
return NULL;
}
@@ -472,8 +480,8 @@
if (errno == EACCES) {
// The file exists but is not readable.
- last_error_message_ = "Read access is denied for file: " +
- temp_disk_file;
+ last_error_message_ =
+ "Read access is denied for file: " + temp_disk_file;
return NULL;
}
}
diff --git a/src/google/protobuf/compiler/importer.h b/src/google/protobuf/compiler/importer.h
index 5f7ed39..1a0b47a 100644
--- a/src/google/protobuf/compiler/importer.h
+++ b/src/google/protobuf/compiler/importer.h
@@ -37,20 +37,22 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
#define GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
-#include <string>
-#include <vector>
#include <set>
+#include <string>
#include <utility>
+#include <vector>
+#include <google/protobuf/compiler/parser.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/descriptor_database.h>
-#include <google/protobuf/compiler/parser.h>
#include <google/protobuf/port_def.inc>
namespace google {
namespace protobuf {
-namespace io { class ZeroCopyInputStream; }
+namespace io {
+class ZeroCopyInputStream;
+}
namespace compiler {
@@ -154,8 +156,7 @@
// TODO(kenton): I feel like this class is not well-named.
class PROTOBUF_EXPORT Importer {
public:
- Importer(SourceTree* source_tree,
- MultiFileErrorCollector* error_collector);
+ Importer(SourceTree* source_tree, MultiFileErrorCollector* error_collector);
~Importer();
// Import the given file and build a FileDescriptor representing it. If
@@ -175,9 +176,7 @@
// The DescriptorPool in which all imported FileDescriptors and their
// contents are stored.
- inline const DescriptorPool* pool() const {
- return &pool_;
- }
+ inline const DescriptorPool* pool() const { return &pool_; }
void AddUnusedImportTrackFile(const std::string& file_name);
void ClearUnusedImportTrackFiles();
diff --git a/src/google/protobuf/compiler/importer_unittest.cc b/src/google/protobuf/compiler/importer_unittest.cc
index 355fccd..6d22e85 100644
--- a/src/google/protobuf/compiler/importer_unittest.cc
+++ b/src/google/protobuf/compiler/importer_unittest.cc
@@ -74,14 +74,14 @@
// implements ErrorCollector ---------------------------------------
void AddError(const std::string& filename, int line, int column,
const std::string& message) {
- strings::SubstituteAndAppend(&text_, "$0:$1:$2: $3\n",
- filename, line, column, message);
+ strings::SubstituteAndAppend(&text_, "$0:$1:$2: $3\n", filename, line,
+ column, message);
}
void AddWarning(const std::string& filename, int line, int column,
const std::string& message) {
- strings::SubstituteAndAppend(&warning_text_, "$0:$1:$2: $3\n",
- filename, line, column, message);
+ strings::SubstituteAndAppend(&warning_text_, "$0:$1:$2: $3\n", filename,
+ line, column, message);
}
};
@@ -117,8 +117,7 @@
class ImporterTest : public testing::Test {
protected:
- ImporterTest()
- : importer_(&source_tree_, &error_collector_) {}
+ ImporterTest() : importer_(&source_tree_, &error_collector_) {}
void AddFile(const std::string& filename, const char* text) {
source_tree_.AddFile(filename, text);
@@ -136,8 +135,8 @@
TEST_F(ImporterTest, Import) {
// Test normal importing.
AddFile("foo.proto",
- "syntax = \"proto2\";\n"
- "message Foo {}\n");
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n");
const FileDescriptor* file = importer_.Import("foo.proto");
EXPECT_EQ("", error_collector_.text_);
@@ -153,14 +152,14 @@
TEST_F(ImporterTest, ImportNested) {
// Test that importing a file which imports another file works.
AddFile("foo.proto",
- "syntax = \"proto2\";\n"
- "import \"bar.proto\";\n"
- "message Foo {\n"
- " optional Bar bar = 1;\n"
- "}\n");
+ "syntax = \"proto2\";\n"
+ "import \"bar.proto\";\n"
+ "message Foo {\n"
+ " optional Bar bar = 1;\n"
+ "}\n");
AddFile("bar.proto",
- "syntax = \"proto2\";\n"
- "message Bar {}\n");
+ "syntax = \"proto2\";\n"
+ "message Bar {}\n");
// Note that both files are actually parsed by the first call to Import()
// here, since foo.proto imports bar.proto. The second call just returns
@@ -190,42 +189,73 @@
TEST_F(ImporterTest, FileNotFound) {
// Error: Parsing a file that doesn't exist.
EXPECT_TRUE(importer_.Import("foo.proto") == NULL);
- EXPECT_EQ(
- "foo.proto:-1:0: File not found.\n",
- error_collector_.text_);
+ EXPECT_EQ("foo.proto:-1:0: File not found.\n", error_collector_.text_);
}
TEST_F(ImporterTest, ImportNotFound) {
// Error: Importing a file that doesn't exist.
AddFile("foo.proto",
- "syntax = \"proto2\";\n"
- "import \"bar.proto\";\n");
+ "syntax = \"proto2\";\n"
+ "import \"bar.proto\";\n");
EXPECT_TRUE(importer_.Import("foo.proto") == NULL);
EXPECT_EQ(
- "bar.proto:-1:0: File not found.\n"
- "foo.proto:-1:0: Import \"bar.proto\" was not found or had errors.\n",
- error_collector_.text_);
+ "bar.proto:-1:0: File not found.\n"
+ "foo.proto:1:0: Import \"bar.proto\" was not found or had errors.\n",
+ error_collector_.text_);
}
TEST_F(ImporterTest, RecursiveImport) {
// Error: Recursive import.
AddFile("recursive1.proto",
- "syntax = \"proto2\";\n"
- "import \"recursive2.proto\";\n");
+ "syntax = \"proto2\";\n"
+ "\n"
+ "import \"recursive2.proto\";\n");
AddFile("recursive2.proto",
- "syntax = \"proto2\";\n"
- "import \"recursive1.proto\";\n");
+ "syntax = \"proto2\";\n"
+ "import \"recursive1.proto\";\n");
EXPECT_TRUE(importer_.Import("recursive1.proto") == NULL);
EXPECT_EQ(
- "recursive1.proto:-1:0: File recursively imports itself: recursive1.proto "
+ "recursive1.proto:2:0: File recursively imports itself: "
+ "recursive1.proto "
"-> recursive2.proto -> recursive1.proto\n"
- "recursive2.proto:-1:0: Import \"recursive1.proto\" was not found "
+ "recursive2.proto:1:0: Import \"recursive1.proto\" was not found "
"or had errors.\n"
- "recursive1.proto:-1:0: Import \"recursive2.proto\" was not found "
+ "recursive1.proto:2:0: Import \"recursive2.proto\" was not found "
"or had errors.\n",
- error_collector_.text_);
+ error_collector_.text_);
+}
+
+TEST_F(ImporterTest, RecursiveImportSelf) {
+ // Error: Recursive import.
+ AddFile("recursive.proto",
+ "syntax = \"proto2\";\n"
+ "\n"
+ "import \"recursive.proto\";\n");
+
+ EXPECT_TRUE(importer_.Import("recursive.proto") == nullptr);
+ EXPECT_EQ(
+ "recursive.proto:2:0: File recursively imports itself: "
+ "recursive.proto -> recursive.proto\n",
+ error_collector_.text_);
+}
+
+TEST_F(ImporterTest, LiteRuntimeImport) {
+ // Error: Recursive import.
+ AddFile("bar.proto",
+ "syntax = \"proto2\";\n"
+ "option optimize_for = LITE_RUNTIME;\n");
+ AddFile("foo.proto",
+ "syntax = \"proto2\";\n"
+ "import \"bar.proto\";\n");
+
+ EXPECT_TRUE(importer_.Import("foo.proto") == nullptr);
+ EXPECT_EQ(
+ "foo.proto:1:0: Files that do not use optimize_for = LITE_RUNTIME "
+ "cannot import files which do use this option. This file is not "
+ "lite, but it imports \"bar.proto\" which is.\n",
+ error_collector_.text_);
}
@@ -396,23 +426,23 @@
std::string shadowing_disk_file;
EXPECT_EQ(DiskSourceTree::NO_MAPPING,
- source_tree_.DiskFileToVirtualFile(
- "/foo", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile("/foo", &virtual_file,
+ &shadowing_disk_file));
EXPECT_EQ(DiskSourceTree::SHADOWED,
- source_tree_.DiskFileToVirtualFile(
- dirnames_[1] + "/foo", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile(
+ dirnames_[1] + "/foo", &virtual_file, &shadowing_disk_file));
EXPECT_EQ("bar/foo", virtual_file);
EXPECT_EQ(dirnames_[0] + "/foo", shadowing_disk_file);
EXPECT_EQ(DiskSourceTree::CANNOT_OPEN,
- source_tree_.DiskFileToVirtualFile(
- dirnames_[1] + "/baz", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile(
+ dirnames_[1] + "/baz", &virtual_file, &shadowing_disk_file));
EXPECT_EQ("bar/baz", virtual_file);
EXPECT_EQ(DiskSourceTree::SUCCESS,
- source_tree_.DiskFileToVirtualFile(
- dirnames_[0] + "/foo", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile(
+ dirnames_[0] + "/foo", &virtual_file, &shadowing_disk_file));
EXPECT_EQ("bar/foo", virtual_file);
}
@@ -431,55 +461,55 @@
// "../.." should not be considered to be under "..".
EXPECT_EQ(DiskSourceTree::NO_MAPPING,
- source_tree_.DiskFileToVirtualFile(
- "../../baz", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile("../../baz", &virtual_file,
+ &shadowing_disk_file));
// "/foo" is not mapped (it should not be misintepreted as being under ".").
EXPECT_EQ(DiskSourceTree::NO_MAPPING,
- source_tree_.DiskFileToVirtualFile(
- "/foo", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile("/foo", &virtual_file,
+ &shadowing_disk_file));
#ifdef WIN32
// "C:\foo" is not mapped (it should not be misintepreted as being under ".").
EXPECT_EQ(DiskSourceTree::NO_MAPPING,
- source_tree_.DiskFileToVirtualFile(
- "C:\\foo", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile("C:\\foo", &virtual_file,
+ &shadowing_disk_file));
#endif // WIN32
// But "../baz" should be.
EXPECT_EQ(DiskSourceTree::CANNOT_OPEN,
- source_tree_.DiskFileToVirtualFile(
- "../baz", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile("../baz", &virtual_file,
+ &shadowing_disk_file));
EXPECT_EQ("dir1/baz", virtual_file);
// "../../foo/baz" is under "../../foo".
EXPECT_EQ(DiskSourceTree::CANNOT_OPEN,
- source_tree_.DiskFileToVirtualFile(
- "../../foo/baz", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile("../../foo/baz", &virtual_file,
+ &shadowing_disk_file));
EXPECT_EQ("dir2/baz", virtual_file);
// "foo/./bar/baz" is under "./foo/bar/.".
EXPECT_EQ(DiskSourceTree::CANNOT_OPEN,
- source_tree_.DiskFileToVirtualFile(
- "foo/bar/baz", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile("foo/bar/baz", &virtual_file,
+ &shadowing_disk_file));
EXPECT_EQ("dir3/baz", virtual_file);
// "bar" is under ".".
EXPECT_EQ(DiskSourceTree::CANNOT_OPEN,
- source_tree_.DiskFileToVirtualFile(
- "bar", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile("bar", &virtual_file,
+ &shadowing_disk_file));
EXPECT_EQ("dir4/bar", virtual_file);
// "/qux/baz" is under "/qux".
EXPECT_EQ(DiskSourceTree::CANNOT_OPEN,
- source_tree_.DiskFileToVirtualFile(
- "/qux/baz", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile("/qux/baz", &virtual_file,
+ &shadowing_disk_file));
EXPECT_EQ("baz", virtual_file);
// "/quux/bar" is under "/quux".
EXPECT_EQ(DiskSourceTree::CANNOT_OPEN,
- source_tree_.DiskFileToVirtualFile(
- "/quux/bar", &virtual_file, &shadowing_disk_file));
+ source_tree_.DiskFileToVirtualFile("/quux/bar", &virtual_file,
+ &shadowing_disk_file));
EXPECT_EQ("dir5/bar", virtual_file);
}
diff --git a/src/google/protobuf/compiler/java/java_context.cc b/src/google/protobuf/compiler/java/java_context.cc
index 8c8ab83..778d3ba 100644
--- a/src/google/protobuf/compiler/java/java_context.cc
+++ b/src/google/protobuf/compiler/java/java_context.cc
@@ -48,8 +48,7 @@
InitializeFieldGeneratorInfo(file);
}
-Context::~Context() {
-}
+Context::~Context() {}
ClassNameResolver* Context::GetNameResolver() const {
return name_resolver_.get();
diff --git a/src/google/protobuf/compiler/java/java_context.h b/src/google/protobuf/compiler/java/java_context.h
index fd41a27..3fa6af1 100644
--- a/src/google/protobuf/compiler/java/java_context.h
+++ b/src/google/protobuf/compiler/java/java_context.h
@@ -40,16 +40,16 @@
namespace google {
namespace protobuf {
- class FileDescriptor;
- class FieldDescriptor;
- class OneofDescriptor;
- class Descriptor;
- class EnumDescriptor;
- namespace compiler {
- namespace java {
- class ClassNameResolver; // name_resolver.h
- }
- }
+class FileDescriptor;
+class FieldDescriptor;
+class OneofDescriptor;
+class Descriptor;
+class EnumDescriptor;
+namespace compiler {
+namespace java {
+class ClassNameResolver; // name_resolver.h
+}
+} // namespace compiler
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/compiler/java/java_doc_comment.cc b/src/google/protobuf/compiler/java/java_doc_comment.cc
index 280b052..29447ac 100644
--- a/src/google/protobuf/compiler/java/java_doc_comment.cc
+++ b/src/google/protobuf/compiler/java/java_doc_comment.cc
@@ -102,8 +102,8 @@
return result;
}
-static void WriteDocCommentBodyForLocation(
- io::Printer* printer, const SourceLocation& location) {
+static void WriteDocCommentBodyForLocation(io::Printer* printer,
+ const SourceLocation& location) {
std::string comments = location.leading_comments.empty()
? location.trailing_comments
: location.leading_comments;
@@ -139,8 +139,8 @@
}
template <typename DescriptorType>
-static void WriteDocCommentBody(
- io::Printer* printer, const DescriptorType* descriptor) {
+static void WriteDocCommentBody(io::Printer* printer,
+ const DescriptorType* descriptor) {
SourceLocation location;
if (descriptor->GetSourceLocation(&location)) {
WriteDocCommentBodyForLocation(printer, location);
@@ -167,9 +167,9 @@
printer->Print("/**\n");
WriteDocCommentBody(printer, message);
printer->Print(
- " * Protobuf type {@code $fullname$}\n"
- " */\n",
- "fullname", EscapeJavadoc(message->full_name()));
+ " * Protobuf type {@code $fullname$}\n"
+ " */\n",
+ "fullname", EscapeJavadoc(message->full_name()));
}
void WriteFieldDocComment(io::Printer* printer, const FieldDescriptor* field) {
@@ -183,9 +183,8 @@
// If the field is a group, the debug string might end with {.
printer->Print("/**\n");
WriteDocCommentBody(printer, field);
- printer->Print(
- " * <code>$def$</code>\n",
- "def", EscapeJavadoc(FirstLineOf(field->DebugString())));
+ printer->Print(" * <code>$def$</code>\n", "def",
+ EscapeJavadoc(FirstLineOf(field->DebugString())));
printer->Print(" */\n");
}
@@ -193,9 +192,9 @@
printer->Print("/**\n");
WriteDocCommentBody(printer, enum_);
printer->Print(
- " * Protobuf enum {@code $fullname$}\n"
- " */\n",
- "fullname", EscapeJavadoc(enum_->full_name()));
+ " * Protobuf enum {@code $fullname$}\n"
+ " */\n",
+ "fullname", EscapeJavadoc(enum_->full_name()));
}
void WriteEnumValueDocComment(io::Printer* printer,
@@ -203,9 +202,9 @@
printer->Print("/**\n");
WriteDocCommentBody(printer, value);
printer->Print(
- " * <code>$def$</code>\n"
- " */\n",
- "def", EscapeJavadoc(FirstLineOf(value->DebugString())));
+ " * <code>$def$</code>\n"
+ " */\n",
+ "def", EscapeJavadoc(FirstLineOf(value->DebugString())));
}
void WriteServiceDocComment(io::Printer* printer,
@@ -213,9 +212,9 @@
printer->Print("/**\n");
WriteDocCommentBody(printer, service);
printer->Print(
- " * Protobuf service {@code $fullname$}\n"
- " */\n",
- "fullname", EscapeJavadoc(service->full_name()));
+ " * Protobuf service {@code $fullname$}\n"
+ " */\n",
+ "fullname", EscapeJavadoc(service->full_name()));
}
void WriteMethodDocComment(io::Printer* printer,
@@ -223,9 +222,9 @@
printer->Print("/**\n");
WriteDocCommentBody(printer, method);
printer->Print(
- " * <code>$def$</code>\n"
- " */\n",
- "def", EscapeJavadoc(FirstLineOf(method->DebugString())));
+ " * <code>$def$</code>\n"
+ " */\n",
+ "def", EscapeJavadoc(FirstLineOf(method->DebugString())));
}
} // namespace java
diff --git a/src/google/protobuf/compiler/java/java_enum.cc b/src/google/protobuf/compiler/java/java_enum.cc
index cab34ca..0dade1c 100644
--- a/src/google/protobuf/compiler/java/java_enum.cc
+++ b/src/google/protobuf/compiler/java/java_enum.cc
@@ -51,15 +51,15 @@
namespace java {
EnumGenerator::EnumGenerator(const EnumDescriptor* descriptor,
- bool immutable_api,
- Context* context)
- : descriptor_(descriptor), immutable_api_(immutable_api),
- context_(context),
- name_resolver_(context->GetNameResolver()) {
+ bool immutable_api, Context* context)
+ : descriptor_(descriptor),
+ immutable_api_(immutable_api),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
for (int i = 0; i < descriptor_->value_count(); i++) {
const EnumValueDescriptor* value = descriptor_->value(i);
const EnumValueDescriptor* canonical_value =
- descriptor_->FindValueByNumber(value->number());
+ descriptor_->FindValueByNumber(value->number());
if (value == canonical_value) {
canonical_values_.push_back(value);
@@ -104,11 +104,9 @@
printer->Print("@java.lang.Deprecated\n");
}
if (ordinal_is_index) {
- printer->Print(vars,
- "$name$($number$),\n");
+ printer->Print(vars, "$name$($number$),\n");
} else {
- printer->Print(vars,
- "$name$($index$, $number$),\n");
+ printer->Print(vars, "$name$($index$, $number$),\n");
}
printer->Annotate("name", canonical_values_[i]);
}
@@ -123,8 +121,8 @@
}
printer->Print(
- ";\n"
- "\n");
+ ";\n"
+ "\n");
// -----------------------------------------------------------------
@@ -134,8 +132,8 @@
vars["name"] = aliases_[i].value->name();
vars["canonical_name"] = aliases_[i].canonical_value->name();
WriteEnumValueDocComment(printer, aliases_[i].value);
- printer->Print(vars,
- "public static final $classname$ $name$ = $canonical_name$;\n");
+ printer->Print(
+ vars, "public static final $classname$ $name$ = $canonical_name$;\n");
printer->Annotate("name", aliases_[i].value);
}
@@ -147,7 +145,7 @@
vars["}"] = "";
WriteEnumValueDocComment(printer, descriptor_->value(i));
printer->Print(vars,
- "public static final int ${$$name$_VALUE$}$ = $number$;\n");
+ "public static final int ${$$name$_VALUE$}$ = $number$;\n");
printer->Annotate("{", "}", descriptor_->value(i));
}
printer->Print("\n");
@@ -155,38 +153,38 @@
// -----------------------------------------------------------------
printer->Print(
- "\n"
- "public final int getNumber() {\n");
+ "\n"
+ "public final int getNumber() {\n");
if (SupportUnknownEnumValue(descriptor_->file())) {
if (ordinal_is_index) {
printer->Print(
- " if (this == UNRECOGNIZED) {\n"
- " throw new java.lang.IllegalArgumentException(\n"
- " \"Can't get the number of an unknown enum value.\");\n"
- " }\n");
+ " if (this == UNRECOGNIZED) {\n"
+ " throw new java.lang.IllegalArgumentException(\n"
+ " \"Can't get the number of an unknown enum value.\");\n"
+ " }\n");
} else {
printer->Print(
- " if (index == -1) {\n"
- " throw new java.lang.IllegalArgumentException(\n"
- " \"Can't get the number of an unknown enum value.\");\n"
- " }\n");
+ " if (index == -1) {\n"
+ " throw new java.lang.IllegalArgumentException(\n"
+ " \"Can't get the number of an unknown enum value.\");\n"
+ " }\n");
}
}
printer->Print(
- " return value;\n"
- "}\n"
- "\n"
- "/**\n"
- " * @deprecated Use {@link #forNumber(int)} instead.\n"
- " */\n"
- "@java.lang.Deprecated\n"
- "public static $classname$ valueOf(int value) {\n"
- " return forNumber(value);\n"
- "}\n"
- "\n"
- "public static $classname$ forNumber(int value) {\n"
- " switch (value) {\n",
- "classname", descriptor_->name());
+ " return value;\n"
+ "}\n"
+ "\n"
+ "/**\n"
+ " * @deprecated Use {@link #forNumber(int)} instead.\n"
+ " */\n"
+ "@java.lang.Deprecated\n"
+ "public static $classname$ valueOf(int value) {\n"
+ " return forNumber(value);\n"
+ "}\n"
+ "\n"
+ "public static $classname$ forNumber(int value) {\n"
+ " switch (value) {\n",
+ "classname", descriptor_->name());
printer->Indent();
printer->Indent();
@@ -199,40 +197,40 @@
printer->Outdent();
printer->Outdent();
printer->Print(
- " default: return null;\n"
- " }\n"
- "}\n"
- "\n"
- "public static com.google.protobuf.Internal.EnumLiteMap<$classname$>\n"
- " internalGetValueMap() {\n"
- " return internalValueMap;\n"
- "}\n"
- "private static final com.google.protobuf.Internal.EnumLiteMap<\n"
- " $classname$> internalValueMap =\n"
- " new com.google.protobuf.Internal.EnumLiteMap<$classname$>() {\n"
- " public $classname$ findValueByNumber(int number) {\n"
- " return $classname$.forNumber(number);\n"
- " }\n"
- " };\n"
- "\n",
- "classname", descriptor_->name());
+ " default: return null;\n"
+ " }\n"
+ "}\n"
+ "\n"
+ "public static com.google.protobuf.Internal.EnumLiteMap<$classname$>\n"
+ " internalGetValueMap() {\n"
+ " return internalValueMap;\n"
+ "}\n"
+ "private static final com.google.protobuf.Internal.EnumLiteMap<\n"
+ " $classname$> internalValueMap =\n"
+ " new com.google.protobuf.Internal.EnumLiteMap<$classname$>() {\n"
+ " public $classname$ findValueByNumber(int number) {\n"
+ " return $classname$.forNumber(number);\n"
+ " }\n"
+ " };\n"
+ "\n",
+ "classname", descriptor_->name());
// -----------------------------------------------------------------
// Reflection
if (HasDescriptorMethods(descriptor_, context_->EnforceLite())) {
printer->Print(
- "public final com.google.protobuf.Descriptors.EnumValueDescriptor\n"
- " getValueDescriptor() {\n"
- " return getDescriptor().getValues().get($index_text$);\n"
- "}\n"
- "public final com.google.protobuf.Descriptors.EnumDescriptor\n"
- " getDescriptorForType() {\n"
- " return getDescriptor();\n"
- "}\n"
- "public static final com.google.protobuf.Descriptors.EnumDescriptor\n"
- " getDescriptor() {\n",
- "index_text", index_text);
+ "public final com.google.protobuf.Descriptors.EnumValueDescriptor\n"
+ " getValueDescriptor() {\n"
+ " return getDescriptor().getValues().get($index_text$);\n"
+ "}\n"
+ "public final com.google.protobuf.Descriptors.EnumDescriptor\n"
+ " getDescriptorForType() {\n"
+ " return getDescriptor();\n"
+ "}\n"
+ "public static final com.google.protobuf.Descriptors.EnumDescriptor\n"
+ " getDescriptor() {\n",
+ "index_text", index_text);
// TODO(kenton): Cache statically? Note that we can't access descriptors
// at module init time because it wouldn't work with descriptor.proto, but
@@ -262,10 +260,10 @@
}
printer->Print(
- "}\n"
- "\n"
- "private static final $classname$[] VALUES = ",
- "classname", descriptor_->name());
+ "}\n"
+ "\n"
+ "private static final $classname$[] VALUES = ",
+ "classname", descriptor_->name());
if (CanUseEnumValues()) {
// If the constants we are going to output are exactly the ones we
@@ -275,11 +273,10 @@
printer->Print("values();\n");
} else {
printer->Print(
- "{\n"
- " ");
+ "{\n"
+ " ");
for (int i = 0; i < descriptor_->value_count(); i++) {
- printer->Print("$name$, ",
- "name", descriptor_->value(i)->name());
+ printer->Print("$name$, ", "name", descriptor_->value(i)->name());
}
printer->Print(
"\n"
@@ -287,24 +284,24 @@
}
printer->Print(
- "\n"
- "public static $classname$ valueOf(\n"
- " com.google.protobuf.Descriptors.EnumValueDescriptor desc) {\n"
- " if (desc.getType() != getDescriptor()) {\n"
- " throw new java.lang.IllegalArgumentException(\n"
- " \"EnumValueDescriptor is not for this type.\");\n"
- " }\n",
- "classname", descriptor_->name());
+ "\n"
+ "public static $classname$ valueOf(\n"
+ " com.google.protobuf.Descriptors.EnumValueDescriptor desc) {\n"
+ " if (desc.getType() != getDescriptor()) {\n"
+ " throw new java.lang.IllegalArgumentException(\n"
+ " \"EnumValueDescriptor is not for this type.\");\n"
+ " }\n",
+ "classname", descriptor_->name());
if (SupportUnknownEnumValue(descriptor_->file())) {
printer->Print(
- " if (desc.getIndex() == -1) {\n"
- " return UNRECOGNIZED;\n"
- " }\n");
+ " if (desc.getIndex() == -1) {\n"
+ " return UNRECOGNIZED;\n"
+ " }\n");
}
printer->Print(
- " return VALUES[desc.getIndex()];\n"
- "}\n"
- "\n");
+ " return VALUES[desc.getIndex()];\n"
+ "}\n"
+ "\n");
if (!ordinal_is_index) {
printer->Print("private final int index;\n");
@@ -313,30 +310,27 @@
// -----------------------------------------------------------------
- printer->Print(
- "private final int value;\n\n");
+ printer->Print("private final int value;\n\n");
if (ordinal_is_index) {
- printer->Print(
- "private $classname$(int value) {\n",
- "classname", descriptor_->name());
+ printer->Print("private $classname$(int value) {\n", "classname",
+ descriptor_->name());
} else {
- printer->Print(
- "private $classname$(int index, int value) {\n",
- "classname", descriptor_->name());
+ printer->Print("private $classname$(int index, int value) {\n", "classname",
+ descriptor_->name());
}
if (HasDescriptorMethods(descriptor_, context_->EnforceLite()) &&
!ordinal_is_index) {
printer->Print(" this.index = index;\n");
}
printer->Print(
- " this.value = value;\n"
- "}\n");
+ " this.value = value;\n"
+ "}\n");
printer->Print(
- "\n"
- "// @@protoc_insertion_point(enum_scope:$full_name$)\n",
- "full_name", descriptor_->full_name());
+ "\n"
+ "// @@protoc_insertion_point(enum_scope:$full_name$)\n",
+ "full_name", descriptor_->full_name());
printer->Outdent();
printer->Print("}\n\n");
diff --git a/src/google/protobuf/compiler/java/java_enum.h b/src/google/protobuf/compiler/java/java_enum.h
index d650924..0a2c363 100644
--- a/src/google/protobuf/compiler/java/java_enum.h
+++ b/src/google/protobuf/compiler/java/java_enum.h
@@ -42,13 +42,13 @@
namespace google {
namespace protobuf {
namespace compiler {
- namespace java {
- class Context; // context.h
- class ClassNameResolver; // name_resolver.h
- }
-}
+namespace java {
+class Context; // context.h
+class ClassNameResolver; // name_resolver.h
+} // namespace java
+} // namespace compiler
namespace io {
- class Printer; // printer.h
+class Printer; // printer.h
}
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/compiler/java/java_enum_field.cc b/src/google/protobuf/compiler/java/java_enum_field.cc
index c30a823..b602bba 100644
--- a/src/google/protobuf/compiler/java/java_enum_field.cc
+++ b/src/google/protobuf/compiler/java/java_enum_field.cc
@@ -73,8 +73,8 @@
internal::WireFormat::TagSize(descriptor->number(), GetType(descriptor)));
// TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
// by the proto compiler
- (*variables)["deprecation"] = descriptor->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ (*variables)["deprecation"] =
+ descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
(*variables)["on_changed"] = "onChanged();";
// Use deprecated valueOf() method to be compatible with old generated code
// for v2.5.0/v2.6.1.
@@ -102,8 +102,8 @@
(*variables)["clear_has_field_bit_builder"] = "";
(*variables)["is_field_present_message"] =
- (*variables)["name"] + "_ != " +
- (*variables)["default"] + ".getNumber()";
+ (*variables)["name"] + "_ != " + (*variables)["default"] +
+ ".getNumber()";
}
// For repated builders, one bit is used for whether the array is immutable.
@@ -134,17 +134,16 @@
// ===================================================================
-ImmutableEnumFieldGenerator::
-ImmutableEnumFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
- builderBitIndex_(builderBitIndex),
- name_resolver_(context->GetNameResolver()) {
+ImmutableEnumFieldGenerator::ImmutableEnumFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : descriptor_(descriptor),
+ messageBitIndex_(messageBitIndex),
+ builderBitIndex_(builderBitIndex),
+ name_resolver_(context->GetNameResolver()) {
SetEnumVariables(descriptor, messageBitIndex, builderBitIndex,
- context->GetFieldGeneratorInfo(descriptor),
- name_resolver_, &variables_);
+ context->GetFieldGeneratorInfo(descriptor), name_resolver_,
+ &variables_);
}
ImmutableEnumFieldGenerator::~ImmutableEnumFieldGenerator() {}
@@ -157,214 +156,214 @@
return GetNumBitsForMessage();
}
-void ImmutableEnumFieldGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void ImmutableEnumFieldGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$boolean has$capitalized_name$();\n");
+ "$deprecation$boolean has$capitalized_name$();\n");
}
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Value();\n");
+ "$deprecation$int get$capitalized_name$Value();\n");
}
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$();\n");
+ printer->Print(variables_, "$deprecation$$type$ get$capitalized_name$();\n");
}
-void ImmutableEnumFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private int $name$_;\n");
+void ImmutableEnumFieldGenerator::GenerateMembers(io::Printer* printer) const {
+ printer->Print(variables_, "private int $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
- " return $name$_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
+ " return $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " @SuppressWarnings(\"deprecation\")\n"
- " $type$ result = $type$.$for_number$($name$_);\n"
- " return result == null ? $unknown$ : result;\n"
- "}\n");
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " @SuppressWarnings(\"deprecation\")\n"
+ " $type$ result = $type$.$for_number$($name$_);\n"
+ " return result == null ? $unknown$ : result;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutableEnumFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private int $name$_ = $default_number$;\n");
+void ImmutableEnumFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_, "private int $name$_ = $default_number$;\n");
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_builder$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_builder$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
- " return $name$_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
+ " return $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder "
- "${$set$capitalized_name$Value$}$(int value) {\n"
- " $name$_ = value;\n"
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$Value$}$(int value) {\n"
+ " $name$_ = value;\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ }
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " @SuppressWarnings(\"deprecation\")\n"
+ " $type$ result = $type$.$for_number$($name$_);\n"
+ " return result == null ? $unknown$ : result;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$$}$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " $set_has_field_bit_builder$\n"
+ " $name$_ = value.getNumber();\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " $clear_has_field_bit_builder$\n"
+ " $name$_ = $default_number$;\n"
" $on_changed$\n"
" return this;\n"
"}\n");
- printer->Annotate("{", "}", descriptor_);
- }
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " @SuppressWarnings(\"deprecation\")\n"
- " $type$ result = $type$.$for_number$($name$_);\n"
- " return result == null ? $unknown$ : result;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " $set_has_field_bit_builder$\n"
- " $name$_ = value.getNumber();\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " $clear_has_field_bit_builder$\n"
- " $name$_ = $default_number$;\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutableEnumFieldGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+void ImmutableEnumFieldGenerator::GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const {
// noop for enums
}
-void ImmutableEnumFieldGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void ImmutableEnumFieldGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
printer->Print(variables_, "$name$_ = $default_number$;\n");
}
-void ImmutableEnumFieldGenerator::
-GenerateBuilderClearCode(io::Printer* printer) const {
+void ImmutableEnumFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "$name$_ = $default_number$;\n"
- "$clear_has_field_bit_builder$\n");
+ "$name$_ = $default_number$;\n"
+ "$clear_has_field_bit_builder$\n");
}
-void ImmutableEnumFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void ImmutableEnumFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
printer->Print(variables_,
- "if (other.has$capitalized_name$()) {\n"
- " set$capitalized_name$(other.get$capitalized_name$());\n"
- "}\n");
+ "if (other.has$capitalized_name$()) {\n"
+ " set$capitalized_name$(other.get$capitalized_name$());\n"
+ "}\n");
} else if (SupportUnknownEnumValue(descriptor_->file())) {
- printer->Print(variables_,
- "if (other.$name$_ != $default_number$) {\n"
- " set$capitalized_name$Value(other.get$capitalized_name$Value());\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "if (other.$name$_ != $default_number$) {\n"
+ " set$capitalized_name$Value(other.get$capitalized_name$Value());\n"
+ "}\n");
} else {
GOOGLE_LOG(FATAL) << "Can't reach here.";
}
}
-void ImmutableEnumFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
+void ImmutableEnumFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
printer->Print(variables_,
- "if ($get_has_field_bit_from_local$) {\n"
- " $set_has_field_bit_to_local$;\n"
- "}\n");
+ "if ($get_has_field_bit_from_local$) {\n"
+ " $set_has_field_bit_to_local$;\n"
+ "}\n");
}
- printer->Print(variables_,
- "result.$name$_ = $name$_;\n");
+ printer->Print(variables_, "result.$name$_ = $name$_;\n");
}
-void ImmutableEnumFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void ImmutableEnumFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
if (SupportUnknownEnumValue(descriptor_->file())) {
printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "$set_has_field_bit_message$\n"
- "$name$_ = rawValue;\n");
+ "int rawValue = input.readEnum();\n"
+ "$set_has_field_bit_message$\n"
+ "$name$_ = rawValue;\n");
} else {
printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- " @SuppressWarnings(\"deprecation\")\n"
- "$type$ value = $type$.$for_number$(rawValue);\n"
- "if (value == null) {\n"
- " unknownFields.mergeVarintField($number$, rawValue);\n"
- "} else {\n"
- " $set_has_field_bit_message$\n"
- " $name$_ = rawValue;\n"
- "}\n");
+ "int rawValue = input.readEnum();\n"
+ " @SuppressWarnings(\"deprecation\")\n"
+ "$type$ value = $type$.$for_number$(rawValue);\n"
+ "if (value == null) {\n"
+ " unknownFields.mergeVarintField($number$, rawValue);\n"
+ "} else {\n"
+ " $set_has_field_bit_message$\n"
+ " $name$_ = rawValue;\n"
+ "}\n");
}
}
-void ImmutableEnumFieldGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
+void ImmutableEnumFieldGenerator::GenerateParsingDoneCode(
+ io::Printer* printer) const {
// noop for enums
}
-void ImmutableEnumFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
+void ImmutableEnumFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " output.writeEnum($number$, $name$_);\n"
- "}\n");
+ "if ($is_field_present_message$) {\n"
+ " output.writeEnum($number$, $name$_);\n"
+ "}\n");
}
-void ImmutableEnumFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
+void ImmutableEnumFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .computeEnumSize($number$, $name$_);\n"
- "}\n");
+ "if ($is_field_present_message$) {\n"
+ " size += com.google.protobuf.CodedOutputStream\n"
+ " .computeEnumSize($number$, $name$_);\n"
+ "}\n");
}
-void ImmutableEnumFieldGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($name$_ != other.$name$_) return false;\n");
+void ImmutableEnumFieldGenerator::GenerateEqualsCode(
+ io::Printer* printer) const {
+ printer->Print(variables_, "if ($name$_ != other.$name$_) return false;\n");
}
-void ImmutableEnumFieldGenerator::
-GenerateHashCode(io::Printer* printer) const {
+void ImmutableEnumFieldGenerator::GenerateHashCode(io::Printer* printer) const {
printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n"
- "hash = (53 * hash) + $name$_;\n");
+ "hash = (37 * hash) + $constant_name$;\n"
+ "hash = (53 * hash) + $name$_;\n");
}
std::string ImmutableEnumFieldGenerator::GetBoxedType() const {
@@ -373,221 +372,230 @@
// ===================================================================
-ImmutableEnumOneofFieldGenerator::
-ImmutableEnumOneofFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : ImmutableEnumFieldGenerator(
- descriptor, messageBitIndex, builderBitIndex, context) {
+ImmutableEnumOneofFieldGenerator::ImmutableEnumOneofFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : ImmutableEnumFieldGenerator(descriptor, messageBitIndex, builderBitIndex,
+ context) {
const OneofGeneratorInfo* info =
context->GetOneofGeneratorInfo(descriptor->containing_oneof());
SetCommonOneofVariables(descriptor, info, &variables_);
}
-ImmutableEnumOneofFieldGenerator::
-~ImmutableEnumOneofFieldGenerator() {}
+ImmutableEnumOneofFieldGenerator::~ImmutableEnumOneofFieldGenerator() {}
-void ImmutableEnumOneofFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutableEnumOneofFieldGenerator::GenerateMembers(
+ io::Printer* printer) const {
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " return (java.lang.Integer) $oneof_name$_;\n"
- " }\n"
- " return $default_number$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " return (java.lang.Integer) $oneof_name$_;\n"
+ " }\n"
+ " return $default_number$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " @SuppressWarnings(\"deprecation\")\n"
- " $type$ result = $type$.$for_number$(\n"
- " (java.lang.Integer) $oneof_name$_);\n"
- " return result == null ? $unknown$ : result;\n"
- " }\n"
- " return $default$;\n"
- "}\n");
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " @SuppressWarnings(\"deprecation\")\n"
+ " $type$ result = $type$.$for_number$(\n"
+ " (java.lang.Integer) $oneof_name$_);\n"
+ " return result == null ? $unknown$ : result;\n"
+ " }\n"
+ " return $default$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutableEnumOneofFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutableEnumOneofFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " return ((java.lang.Integer) $oneof_name$_).intValue();\n"
- " }\n"
- " return $default_number$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " return ((java.lang.Integer) $oneof_name$_).intValue();\n"
+ " }\n"
+ " return $default_number$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder "
- "${$set$capitalized_name$Value$}$(int value) {\n"
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = value;\n"
- " $on_changed$\n"
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$Value$}$(int value) {\n"
+ " $set_oneof_case_message$;\n"
+ " $oneof_name$_ = value;\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ }
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " @SuppressWarnings(\"deprecation\")\n"
+ " $type$ result = $type$.$for_number$(\n"
+ " (java.lang.Integer) $oneof_name$_);\n"
+ " return result == null ? $unknown$ : result;\n"
+ " }\n"
+ " return $default$;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$$}$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " $set_oneof_case_message$;\n"
+ " $oneof_name$_ = value.getNumber();\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " $clear_oneof_case_message$;\n"
+ " $oneof_name$_ = null;\n"
+ " $on_changed$\n"
+ " }\n"
" return this;\n"
"}\n");
- printer->Annotate("{", "}", descriptor_);
- }
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " @SuppressWarnings(\"deprecation\")\n"
- " $type$ result = $type$.$for_number$(\n"
- " (java.lang.Integer) $oneof_name$_);\n"
- " return result == null ? $unknown$ : result;\n"
- " }\n"
- " return $default$;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = value.getNumber();\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " $clear_oneof_case_message$;\n"
- " $oneof_name$_ = null;\n"
- " $on_changed$\n"
- " }\n"
- " return this;\n"
- "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutableEnumOneofFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
+void ImmutableEnumOneofFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " result.$oneof_name$_ = $oneof_name$_;\n"
- "}\n");
+ "if ($has_oneof_case_message$) {\n"
+ " result.$oneof_name$_ = $oneof_name$_;\n"
+ "}\n");
}
-void ImmutableEnumOneofFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void ImmutableEnumOneofFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
if (SupportUnknownEnumValue(descriptor_->file())) {
- printer->Print(variables_,
- "set$capitalized_name$Value(other.get$capitalized_name$Value());\n");
+ printer->Print(
+ variables_,
+ "set$capitalized_name$Value(other.get$capitalized_name$Value());\n");
} else {
printer->Print(variables_,
- "set$capitalized_name$(other.get$capitalized_name$());\n");
+ "set$capitalized_name$(other.get$capitalized_name$());\n");
}
}
-void ImmutableEnumOneofFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void ImmutableEnumOneofFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
if (SupportUnknownEnumValue(descriptor_->file())) {
printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "$set_oneof_case_message$;\n"
- "$oneof_name$_ = rawValue;\n");
+ "int rawValue = input.readEnum();\n"
+ "$set_oneof_case_message$;\n"
+ "$oneof_name$_ = rawValue;\n");
} else {
printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "@SuppressWarnings(\"deprecation\")\n"
- "$type$ value = $type$.$for_number$(rawValue);\n"
- "if (value == null) {\n"
- " unknownFields.mergeVarintField($number$, rawValue);\n"
- "} else {\n"
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = rawValue;\n"
+ "int rawValue = input.readEnum();\n"
+ "@SuppressWarnings(\"deprecation\")\n"
+ "$type$ value = $type$.$for_number$(rawValue);\n"
+ "if (value == null) {\n"
+ " unknownFields.mergeVarintField($number$, rawValue);\n"
+ "} else {\n"
+ " $set_oneof_case_message$;\n"
+ " $oneof_name$_ = rawValue;\n"
+ "}\n");
+ }
+}
+
+void ImmutableEnumOneofFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if ($has_oneof_case_message$) {\n"
+ " output.writeEnum($number$, ((java.lang.Integer) $oneof_name$_));\n"
"}\n");
+}
+
+void ImmutableEnumOneofFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if ($has_oneof_case_message$) {\n"
+ " size += com.google.protobuf.CodedOutputStream\n"
+ " .computeEnumSize($number$, ((java.lang.Integer) $oneof_name$_));\n"
+ "}\n");
+}
+
+void ImmutableEnumOneofFieldGenerator::GenerateEqualsCode(
+ io::Printer* printer) const {
+ if (SupportUnknownEnumValue(descriptor_->file())) {
+ printer->Print(
+ variables_,
+ "if (get$capitalized_name$Value()\n"
+ " != other.get$capitalized_name$Value()) return false;\n");
+ } else {
+ printer->Print(
+ variables_,
+ "if (!get$capitalized_name$()\n"
+ " .equals(other.get$capitalized_name$())) return false;\n");
}
}
-void ImmutableEnumOneofFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " output.writeEnum($number$, ((java.lang.Integer) $oneof_name$_));\n"
- "}\n");
-}
-
-void ImmutableEnumOneofFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .computeEnumSize($number$, ((java.lang.Integer) $oneof_name$_));\n"
- "}\n");
-}
-
-void ImmutableEnumOneofFieldGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
+void ImmutableEnumOneofFieldGenerator::GenerateHashCode(
+ io::Printer* printer) const {
if (SupportUnknownEnumValue(descriptor_->file())) {
printer->Print(variables_,
- "if (get$capitalized_name$Value()\n"
- " != other.get$capitalized_name$Value()) return false;\n");
+ "hash = (37 * hash) + $constant_name$;\n"
+ "hash = (53 * hash) + get$capitalized_name$Value();\n");
} else {
- printer->Print(variables_,
- "if (!get$capitalized_name$()\n"
- " .equals(other.get$capitalized_name$())) return false;\n");
- }
-}
-
-void ImmutableEnumOneofFieldGenerator::
-GenerateHashCode(io::Printer* printer) const {
- if (SupportUnknownEnumValue(descriptor_->file())) {
- printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n"
- "hash = (53 * hash) + get$capitalized_name$Value();\n");
- } else {
- printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n"
- "hash = (53 * hash) + get$capitalized_name$().getNumber();\n");
+ printer->Print(
+ variables_,
+ "hash = (37 * hash) + $constant_name$;\n"
+ "hash = (53 * hash) + get$capitalized_name$().getNumber();\n");
}
}
// ===================================================================
-RepeatedImmutableEnumFieldGenerator::
-RepeatedImmutableEnumFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
- builderBitIndex_(builderBitIndex), context_(context),
- name_resolver_(context->GetNameResolver()) {
+RepeatedImmutableEnumFieldGenerator::RepeatedImmutableEnumFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : descriptor_(descriptor),
+ messageBitIndex_(messageBitIndex),
+ builderBitIndex_(builderBitIndex),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
SetEnumVariables(descriptor, messageBitIndex, builderBitIndex,
- context->GetFieldGeneratorInfo(descriptor),
- name_resolver_, &variables_);
+ context->GetFieldGeneratorInfo(descriptor), name_resolver_,
+ &variables_);
}
RepeatedImmutableEnumFieldGenerator::~RepeatedImmutableEnumFieldGenerator() {}
@@ -600,398 +608,413 @@
return 1;
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$java.util.List<$type$> get$capitalized_name$List();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.util.List<$type$> get$capitalized_name$List();\n");
+ "$deprecation$int get$capitalized_name$Count();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Count();\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$(int index);\n");
+ "$deprecation$$type$ get$capitalized_name$(int index);\n");
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.util.List<java.lang.Integer>\n"
- "get$capitalized_name$ValueList();\n");
+ "$deprecation$java.util.List<java.lang.Integer>\n"
+ "get$capitalized_name$ValueList();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Value(int index);\n");
+ "$deprecation$int get$capitalized_name$Value(int index);\n");
}
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private java.util.List<java.lang.Integer> $name$_;\n"
- "private static final com.google.protobuf.Internal.ListAdapter.Converter<\n"
- " java.lang.Integer, $type$> $name$_converter_ =\n"
- " new com.google.protobuf.Internal.ListAdapter.Converter<\n"
- " java.lang.Integer, $type$>() {\n"
- " public $type$ convert(java.lang.Integer from) {\n"
- " @SuppressWarnings(\"deprecation\")\n"
- " $type$ result = $type$.$for_number$(from);\n"
- " return result == null ? $unknown$ : result;\n"
- " }\n"
- " };\n");
+void RepeatedImmutableEnumFieldGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "private java.util.List<java.lang.Integer> $name$_;\n"
+ "private static final "
+ "com.google.protobuf.Internal.ListAdapter.Converter<\n"
+ " java.lang.Integer, $type$> $name$_converter_ =\n"
+ " new com.google.protobuf.Internal.ListAdapter.Converter<\n"
+ " java.lang.Integer, $type$>() {\n"
+ " public $type$ convert(java.lang.Integer from) {\n"
+ " @SuppressWarnings(\"deprecation\")\n"
+ " $type$ result = $type$.$for_number$(from);\n"
+ " return result == null ? $unknown$ : result;\n"
+ " }\n"
+ " };\n");
PrintExtraFieldInfo(variables_, printer);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public java.util.List<$type$> "
- "${$get$capitalized_name$List$}$() {\n"
- " return new com.google.protobuf.Internal.ListAdapter<\n"
- " java.lang.Integer, $type$>($name$_, $name$_converter_);\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public java.util.List<$type$> "
+ "${$get$capitalized_name$List$}$() {\n"
+ " return new com.google.protobuf.Internal.ListAdapter<\n"
+ " java.lang.Integer, $type$>($name$_, $name$_converter_);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return $name$_.size();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return $name$_.size();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
- " return $name$_converter_.convert($name$_.get(index));\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
+ " return $name$_converter_.convert($name$_.get(index));\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public java.util.List<java.lang.Integer>\n"
- "${$get$capitalized_name$ValueList$}$() {\n"
- " return $name$_;\n"
- "}\n");
+ "$deprecation$public java.util.List<java.lang.Integer>\n"
+ "${$get$capitalized_name$ValueList$}$() {\n"
+ " return $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Value$}$(int index) {\n"
- " return $name$_.get(index);\n"
- "}\n");
+ "$deprecation$public int "
+ "${$get$capitalized_name$Value$}$(int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
if (descriptor_->is_packed()) {
- printer->Print(variables_,
- "private int $name$MemoizedSerializedSize;\n");
+ printer->Print(variables_, "private int $name$MemoizedSerializedSize;\n");
}
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
- printer->Print(variables_,
- // One field is the list and the other field keeps track of whether the
- // list is immutable. If it's immutable, the invariant is that it must
- // either an instance of Collections.emptyList() or it's an ArrayList
- // wrapped in a Collections.unmodifiableList() wrapper and nobody else has
- // a refererence to the underlying ArrayList. This invariant allows us to
- // share instances of lists between protocol buffers avoiding expensive
- // memory allocations. Note, immutable is a strong guarantee here -- not
- // just that the list cannot be modified via the reference but that the
- // list can never be modified.
- "private java.util.List<java.lang.Integer> $name$_ =\n"
- " java.util.Collections.emptyList();\n"
+void RepeatedImmutableEnumFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ // One field is the list and the other field keeps track of whether the
+ // list is immutable. If it's immutable, the invariant is that it must
+ // either an instance of Collections.emptyList() or it's an ArrayList
+ // wrapped in a Collections.unmodifiableList() wrapper and nobody else has
+ // a refererence to the underlying ArrayList. This invariant allows us to
+ // share instances of lists between protocol buffers avoiding expensive
+ // memory allocations. Note, immutable is a strong guarantee here -- not
+ // just that the list cannot be modified via the reference but that the
+ // list can never be modified.
+ "private java.util.List<java.lang.Integer> $name$_ =\n"
+ " java.util.Collections.emptyList();\n"
- "private void ensure$capitalized_name$IsMutable() {\n"
- " if (!$get_mutable_bit_builder$) {\n"
- " $name$_ = new java.util.ArrayList<java.lang.Integer>($name$_);\n"
- " $set_mutable_bit_builder$;\n"
- " }\n"
- "}\n");
+ "private void ensure$capitalized_name$IsMutable() {\n"
+ " if (!$get_mutable_bit_builder$) {\n"
+ " $name$_ = new java.util.ArrayList<java.lang.Integer>($name$_);\n"
+ " $set_mutable_bit_builder$;\n"
+ " }\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- // Note: We return an unmodifiable list because otherwise the caller
- // could hold on to the returned list and modify it after the message
- // has been built, thus mutating the message which is supposed to be
- // immutable.
- "$deprecation$public java.util.List<$type$> "
- "${$get$capitalized_name$List$}$() {\n"
- " return new com.google.protobuf.Internal.ListAdapter<\n"
- " java.lang.Integer, $type$>($name$_, $name$_converter_);\n"
- "}\n");
+ printer->Print(
+ variables_,
+ // Note: We return an unmodifiable list because otherwise the caller
+ // could hold on to the returned list and modify it after the message
+ // has been built, thus mutating the message which is supposed to be
+ // immutable.
+ "$deprecation$public java.util.List<$type$> "
+ "${$get$capitalized_name$List$}$() {\n"
+ " return new com.google.protobuf.Internal.ListAdapter<\n"
+ " java.lang.Integer, $type$>($name$_, $name$_converter_);\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return $name$_.size();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
+ " return $name$_converter_.convert($name$_.get(index));\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return $name$_.size();\n"
- "}\n");
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " int index, $type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.set(index, value.getNumber());\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
- " return $name$_converter_.convert($name$_.get(index));\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$add$capitalized_name$$}$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.add(value.getNumber());\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " int index, $type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.set(index, value.getNumber());\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
+ " java.lang.Iterable<? extends $type$> values) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " for ($type$ value : values) {\n"
+ " $name$_.add(value.getNumber());\n"
+ " }\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$$}$($type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.add(value.getNumber());\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
- " java.lang.Iterable<? extends $type$> values) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " for ($type$ value : values) {\n"
- " $name$_.add(value.getNumber());\n"
- " }\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " $name$_ = java.util.Collections.emptyList();\n"
- " $clear_mutable_bit_builder$;\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " $name$_ = java.util.Collections.emptyList();\n"
+ " $clear_mutable_bit_builder$;\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public java.util.List<java.lang.Integer>\n"
- "${$get$capitalized_name$ValueList$}$() {\n"
- " return java.util.Collections.unmodifiableList($name$_);\n"
- "}\n");
+ "$deprecation$public java.util.List<java.lang.Integer>\n"
+ "${$get$capitalized_name$ValueList$}$() {\n"
+ " return java.util.Collections.unmodifiableList($name$_);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Value$}$(int index) {\n"
- " return $name$_.get(index);\n"
- "}\n");
+ "$deprecation$public int "
+ "${$get$capitalized_name$Value$}$(int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$set$capitalized_name$Value$}$(\n"
+ " int index, int value) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.set(index, value);\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$Value$}$(\n"
- " int index, int value) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.set(index, value);\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$add$capitalized_name$Value$}$(int value) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.add(value);\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder "
- "${$add$capitalized_name$Value$}$(int value) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.add(value);\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$addAll$capitalized_name$Value$}$(\n"
- " java.lang.Iterable<java.lang.Integer> values) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " for (int value : values) {\n"
- " $name$_.add(value);\n"
- " }\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$addAll$capitalized_name$Value$}$(\n"
+ " java.lang.Iterable<java.lang.Integer> values) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " for (int value : values) {\n"
+ " $name$_.add(value);\n"
+ " }\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
}
void RepeatedImmutableEnumFieldGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+ GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
// noop for enums
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
printer->Print(variables_, "$name$_ = java.util.Collections.emptyList();\n");
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateBuilderClearCode(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "$name$_ = java.util.Collections.emptyList();\n"
- "$clear_mutable_bit_builder$;\n");
+ "$name$_ = java.util.Collections.emptyList();\n"
+ "$clear_mutable_bit_builder$;\n");
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
// The code below does two optimizations:
// 1. If the other list is empty, there's nothing to do. This ensures we
// don't allocate a new array if we already have an immutable one.
// 2. If the other list is non-empty and our current list is empty, we can
// reuse the other list which is guaranteed to be immutable.
printer->Print(variables_,
- "if (!other.$name$_.isEmpty()) {\n"
- " if ($name$_.isEmpty()) {\n"
- " $name$_ = other.$name$_;\n"
- " $clear_mutable_bit_builder$;\n"
- " } else {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.addAll(other.$name$_);\n"
- " }\n"
- " $on_changed$\n"
- "}\n");
+ "if (!other.$name$_.isEmpty()) {\n"
+ " if ($name$_.isEmpty()) {\n"
+ " $name$_ = other.$name$_;\n"
+ " $clear_mutable_bit_builder$;\n"
+ " } else {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.addAll(other.$name$_);\n"
+ " }\n"
+ " $on_changed$\n"
+ "}\n");
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
// The code below ensures that the result has an immutable list. If our
// list is immutable, we can just reuse it. If not, we make it immutable.
- printer->Print(variables_,
- "if ($get_mutable_bit_builder$) {\n"
- " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
- " $clear_mutable_bit_builder$;\n"
- "}\n"
- "result.$name$_ = $name$_;\n");
+ printer->Print(
+ variables_,
+ "if ($get_mutable_bit_builder$) {\n"
+ " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
+ " $clear_mutable_bit_builder$;\n"
+ "}\n"
+ "result.$name$_ = $name$_;\n");
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
// Read and store the enum
if (SupportUnknownEnumValue(descriptor_->file())) {
printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = new java.util.ArrayList<java.lang.Integer>();\n"
- " $set_mutable_bit_parser$;\n"
- "}\n"
- "$name$_.add(rawValue);\n");
+ "int rawValue = input.readEnum();\n"
+ "if (!$get_mutable_bit_parser$) {\n"
+ " $name$_ = new java.util.ArrayList<java.lang.Integer>();\n"
+ " $set_mutable_bit_parser$;\n"
+ "}\n"
+ "$name$_.add(rawValue);\n");
} else {
- printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "@SuppressWarnings(\"deprecation\")\n"
- "$type$ value = $type$.$for_number$(rawValue);\n"
- "if (value == null) {\n"
- " unknownFields.mergeVarintField($number$, rawValue);\n"
- "} else {\n"
- " if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = new java.util.ArrayList<java.lang.Integer>();\n"
- " $set_mutable_bit_parser$;\n"
- " }\n"
- " $name$_.add(rawValue);\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "int rawValue = input.readEnum();\n"
+ "@SuppressWarnings(\"deprecation\")\n"
+ "$type$ value = $type$.$for_number$(rawValue);\n"
+ "if (value == null) {\n"
+ " unknownFields.mergeVarintField($number$, rawValue);\n"
+ "} else {\n"
+ " if (!$get_mutable_bit_parser$) {\n"
+ " $name$_ = new java.util.ArrayList<java.lang.Integer>();\n"
+ " $set_mutable_bit_parser$;\n"
+ " }\n"
+ " $name$_.add(rawValue);\n"
+ "}\n");
}
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateParsingCodeFromPacked(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldGenerator::GenerateParsingCodeFromPacked(
+ io::Printer* printer) const {
// Wrap GenerateParsingCode's contents with a while loop.
printer->Print(variables_,
- "int length = input.readRawVarint32();\n"
- "int oldLimit = input.pushLimit(length);\n"
- "while(input.getBytesUntilLimit() > 0) {\n");
+ "int length = input.readRawVarint32();\n"
+ "int oldLimit = input.pushLimit(length);\n"
+ "while(input.getBytesUntilLimit() > 0) {\n");
printer->Indent();
GenerateParsingCode(printer);
printer->Outdent();
printer->Print(variables_,
- "}\n"
- "input.popLimit(oldLimit);\n");
+ "}\n"
+ "input.popLimit(oldLimit);\n");
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($get_mutable_bit_parser$) {\n"
- " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
- "}\n");
+void RepeatedImmutableEnumFieldGenerator::GenerateParsingDoneCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if ($get_mutable_bit_parser$) {\n"
+ " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
+ "}\n");
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
if (descriptor_->is_packed()) {
printer->Print(variables_,
- "if (get$capitalized_name$List().size() > 0) {\n"
- " output.writeUInt32NoTag($tag$);\n"
- " output.writeUInt32NoTag($name$MemoizedSerializedSize);\n"
- "}\n"
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " output.writeEnumNoTag($name$_.get(i));\n"
- "}\n");
+ "if (get$capitalized_name$List().size() > 0) {\n"
+ " output.writeUInt32NoTag($tag$);\n"
+ " output.writeUInt32NoTag($name$MemoizedSerializedSize);\n"
+ "}\n"
+ "for (int i = 0; i < $name$_.size(); i++) {\n"
+ " output.writeEnumNoTag($name$_.get(i));\n"
+ "}\n");
} else {
printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " output.writeEnum($number$, $name$_.get(i));\n"
- "}\n");
+ "for (int i = 0; i < $name$_.size(); i++) {\n"
+ " output.writeEnum($number$, $name$_.get(i));\n"
+ "}\n");
}
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "{\n"
- " int dataSize = 0;\n");
+ "{\n"
+ " int dataSize = 0;\n");
printer->Indent();
printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " dataSize += com.google.protobuf.CodedOutputStream\n"
- " .computeEnumSizeNoTag($name$_.get(i));\n"
- "}\n");
- printer->Print(
- "size += dataSize;\n");
+ "for (int i = 0; i < $name$_.size(); i++) {\n"
+ " dataSize += com.google.protobuf.CodedOutputStream\n"
+ " .computeEnumSizeNoTag($name$_.get(i));\n"
+ "}\n");
+ printer->Print("size += dataSize;\n");
if (descriptor_->is_packed()) {
printer->Print(variables_,
- "if (!get$capitalized_name$List().isEmpty()) {"
- " size += $tag_size$;\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .computeUInt32SizeNoTag(dataSize);\n"
- "}");
+ "if (!get$capitalized_name$List().isEmpty()) {"
+ " size += $tag_size$;\n"
+ " size += com.google.protobuf.CodedOutputStream\n"
+ " .computeUInt32SizeNoTag(dataSize);\n"
+ "}");
} else {
- printer->Print(variables_,
- "size += $tag_size$ * $name$_.size();\n");
+ printer->Print(variables_, "size += $tag_size$ * $name$_.size();\n");
}
// cache the data size for packed fields.
if (descriptor_->is_packed()) {
- printer->Print(variables_,
- "$name$MemoizedSerializedSize = dataSize;\n");
+ printer->Print(variables_, "$name$MemoizedSerializedSize = dataSize;\n");
}
printer->Outdent();
printer->Print("}\n");
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldGenerator::GenerateEqualsCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if (!$name$_.equals(other.$name$_)) return false;\n");
+ "if (!$name$_.equals(other.$name$_)) return false;\n");
}
-void RepeatedImmutableEnumFieldGenerator::
-GenerateHashCode(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldGenerator::GenerateHashCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if (get$capitalized_name$Count() > 0) {\n"
- " hash = (37 * hash) + $constant_name$;\n"
- " hash = (53 * hash) + $name$_.hashCode();\n"
- "}\n");
+ "if (get$capitalized_name$Count() > 0) {\n"
+ " hash = (37 * hash) + $constant_name$;\n"
+ " hash = (53 * hash) + $name$_.hashCode();\n"
+ "}\n");
}
std::string RepeatedImmutableEnumFieldGenerator::GetBoxedType() const {
diff --git a/src/google/protobuf/compiler/java/java_enum_field_lite.cc b/src/google/protobuf/compiler/java/java_enum_field_lite.cc
index 7259975..e0171ab 100644
--- a/src/google/protobuf/compiler/java/java_enum_field_lite.cc
+++ b/src/google/protobuf/compiler/java/java_enum_field_lite.cc
@@ -80,8 +80,8 @@
internal::WireFormat::TagSize(descriptor->number(), GetType(descriptor)));
// TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
// by the proto compiler
- (*variables)["deprecation"] = descriptor->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ (*variables)["deprecation"] =
+ descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
(*variables)["required"] = descriptor->is_required() ? "true" : "false";
if (SupportFieldPresence(descriptor->file())) {
@@ -100,8 +100,8 @@
(*variables)["clear_has_field_bit_message"] = "";
(*variables)["is_field_present_message"] =
- (*variables)["name"] + "_ != " +
- (*variables)["default"] + ".getNumber()";
+ (*variables)["name"] + "_ != " + (*variables)["default"] +
+ ".getNumber()";
}
// For repeated builders, the underlying list tracks mutability state.
@@ -123,12 +123,12 @@
// ===================================================================
-ImmutableEnumFieldLiteGenerator::
-ImmutableEnumFieldLiteGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- Context* context)
- : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
- context_(context), name_resolver_(context->GetNameResolver()) {
+ImmutableEnumFieldLiteGenerator::ImmutableEnumFieldLiteGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, Context* context)
+ : descriptor_(descriptor),
+ messageBitIndex_(messageBitIndex),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
SetEnumVariables(descriptor, messageBitIndex, 0,
context->GetFieldGeneratorInfo(descriptor), name_resolver_,
&variables_);
@@ -140,221 +140,197 @@
return SupportFieldPresence(descriptor_->file()) ? 1 : 0;
}
-void ImmutableEnumFieldLiteGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void ImmutableEnumFieldLiteGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$boolean has$capitalized_name$();\n");
+ "$deprecation$boolean has$capitalized_name$();\n");
}
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Value();\n");
+ "$deprecation$int get$capitalized_name$Value();\n");
}
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$();\n");
+ printer->Print(variables_, "$deprecation$$type$ get$capitalized_name$();\n");
}
-void ImmutableEnumFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private int $name$_;\n");
+void ImmutableEnumFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_, "private int $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
- " return $name$_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
+ " return $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " $type$ result = $type$.forNumber($name$_);\n"
- " return result == null ? $unknown$ : result;\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " $type$ result = $type$.forNumber($name$_);\n"
+ " return result == null ? $unknown$ : result;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Generate private setters for the builder to proxy into.
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$Value(int value) {\n"
- " $set_has_field_bit_message$"
- " $name$_ = value;\n"
- "}\n");
+ "private void set$capitalized_name$Value(int value) {\n"
+ " $set_has_field_bit_message$"
+ " $name$_ = value;\n"
+ "}\n");
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$($type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " $set_has_field_bit_message$\n"
- " $name$_ = value.getNumber();\n"
- "}\n");
+ "private void set$capitalized_name$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " $set_has_field_bit_message$\n"
+ " $name$_ = value.getNumber();\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void clear$capitalized_name$() {\n"
- " $clear_has_field_bit_message$\n"
- " $name$_ = $default_number$;\n"
- "}\n");
+ "private void clear$capitalized_name$() {\n"
+ " $clear_has_field_bit_message$\n"
+ " $name$_ = $default_number$;\n"
+ "}\n");
}
-void ImmutableEnumFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutableEnumFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return instance.has$capitalized_name$();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return instance.has$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
- " return instance.get$capitalized_name$Value();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
+ " return instance.get$capitalized_name$Value();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder "
- "${$set$capitalized_name$Value$}$(int value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$Value(value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$Value$}$(int value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$Value(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return instance.get$capitalized_name$();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return instance.get$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$$}$($type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " copyOnWrite();\n"
+ " instance.clear$capitalized_name$();\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutableEnumFieldLiteGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
- // noop for enums
-}
-
-void ImmutableEnumFieldLiteGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void ImmutableEnumFieldLiteGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
if (!IsDefaultValueJavaDefault(descriptor_)) {
printer->Print(variables_, "$name$_ = $default_number$;\n");
}
}
-void ImmutableEnumFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
+void ImmutableEnumFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
- printer->Print(variables_,
- "$name$_ = visitor.visitInt(has$capitalized_name$(), $name$_,\n"
- " other.has$capitalized_name$(), other.$name$_);\n");
- } else if (SupportUnknownEnumValue(descriptor_->file())) {
- printer->Print(variables_,
- "$name$_ = visitor.visitInt($name$_ != $default_number$, $name$_,"
- " other.$name$_ != $default_number$, other.$name$_);\n");
+ if (descriptor_->is_required()) {
+ printer->Print(
+ variables_,
+ "fieldInfoForProto2Required(\n"
+ " reflectField($classname$.class, \"$name$_\"),\n"
+ " $number$,\n"
+ " com.google.protobuf.FieldType.$annotation_field_type$,\n"
+ " $bit_field_name$,\n"
+ " $bit_field_mask$,\n"
+ " false,\n"
+ " $type$.internalGetValueMap())");
+ } else {
+ printer->Print(
+ variables_,
+ "fieldInfoForProto2Optional(\n"
+ " reflectField($classname$.class, \"$name$_\"),\n"
+ " $number$,\n"
+ " com.google.protobuf.FieldType.$annotation_field_type$,\n"
+ " $bit_field_name$,\n"
+ " $bit_field_mask$,\n"
+ " false,\n"
+ " $type$.internalGetValueMap())");
+ }
} else {
- GOOGLE_LOG(FATAL) << "Can't reach here.";
+ printer->Print(
+ variables_,
+ "fieldInfoWithEnumMap(\n"
+ " reflectField($classname$.class, \"$name$_\"),\n"
+ " $number$,\n"
+ " com.google.protobuf.FieldType.$annotation_field_type$,\n"
+ " $type$.internalGetValueMap())");
}
}
-
-void ImmutableEnumFieldLiteGenerator::
-GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const {
- // noop for scalars
-}
-
-void ImmutableEnumFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- if (SupportUnknownEnumValue(descriptor_->file())) {
- printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "$set_has_field_bit_message$\n"
- "$name$_ = rawValue;\n");
- } else {
- printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "$type$ value = $type$.forNumber(rawValue);\n"
- "if (value == null) {\n"
- " super.mergeVarintField($number$, rawValue);\n"
- "} else {\n"
- " $set_has_field_bit_message$\n"
- " $name$_ = rawValue;\n"
- "}\n");
+void ImmutableEnumFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
+ if (SupportFieldPresence(descriptor_->file())) {
+ WriteIntToUtf16CharSequence(messageBitIndex_, output);
}
-}
-
-void ImmutableEnumFieldLiteGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- // noop for enums
-}
-
-
-void ImmutableEnumFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " output.writeEnum($number$, $name$_);\n"
- "}\n");
-}
-
-void ImmutableEnumFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .computeEnumSize($number$, $name$_);\n"
- "}\n");
-}
-
-void ImmutableEnumFieldLiteGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(variables_,
- "result = result && $name$_ == other.$name$_;\n");
-}
-
-void ImmutableEnumFieldLiteGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n"
- "hash = (53 * hash) + $name$_;\n");
+ printer->Print(variables_, "\"$name$_\",\n");
+ if (SupportFieldPresence(descriptor_->file())) {
+ PrintEnumVerifierLogic(printer, descriptor_, variables_,
+ /*var_name=*/"$type$",
+ /*terminating_string=*/",\n",
+ /*enforce_lite=*/context_->EnforceLite());
+ }
}
std::string ImmutableEnumFieldLiteGenerator::GetBoxedType() const {
@@ -371,196 +347,154 @@
SetCommonOneofVariables(descriptor, info, &variables_);
}
-ImmutableEnumOneofFieldLiteGenerator::
-~ImmutableEnumOneofFieldLiteGenerator() {}
+ImmutableEnumOneofFieldLiteGenerator::~ImmutableEnumOneofFieldLiteGenerator() {}
-void ImmutableEnumOneofFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutableEnumOneofFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " return (java.lang.Integer) $oneof_name$_;\n"
- " }\n"
- " return $default_number$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " return (java.lang.Integer) $oneof_name$_;\n"
+ " }\n"
+ " return $default_number$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " $type$ result = $type$.forNumber((java.lang.Integer) $oneof_name$_);\n"
- " return result == null ? $unknown$ : result;\n"
- " }\n"
- " return $default$;\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " $type$ result = $type$.forNumber((java.lang.Integer) "
+ "$oneof_name$_);\n"
+ " return result == null ? $unknown$ : result;\n"
+ " }\n"
+ " return $default$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Generate private setters for the builder to proxy into.
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$Value(int value) {\n"
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = value;\n"
- "}\n");
+ "private void set$capitalized_name$Value(int value) {\n"
+ " $set_oneof_case_message$;\n"
+ " $oneof_name$_ = value;\n"
+ "}\n");
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$($type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = value.getNumber();\n"
- "}\n");
+ "private void set$capitalized_name$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " $set_oneof_case_message$;\n"
+ " $oneof_name$_ = value.getNumber();\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void clear$capitalized_name$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " $clear_oneof_case_message$;\n"
- " $oneof_name$_ = null;\n"
- " }\n"
- "}\n");
+ "private void clear$capitalized_name$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " $clear_oneof_case_message$;\n"
+ " $oneof_name$_ = null;\n"
+ " }\n"
+ "}\n");
}
+void ImmutableEnumOneofFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer) const {
+ printer->Print(variables_,
+ "fieldInfoForOneofEnum(\n"
+ " $number$,\n"
+ " $oneof_name$_,\n"
+ " $oneof_stored_type$.class,\n"
+ " $type$.internalGetValueMap())");
+}
+void ImmutableEnumOneofFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
+ WriteIntToUtf16CharSequence(descriptor_->containing_oneof()->index(), output);
+ if (SupportFieldPresence(descriptor_->file())) {
+ PrintEnumVerifierLogic(printer, descriptor_, variables_,
+ /*var_name=*/"$type$",
+ /*terminating_string=*/",\n",
+ /*enforce_lite=*/context_->EnforceLite());
+ }
+}
-void ImmutableEnumOneofFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutableEnumOneofFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return instance.has$capitalized_name$();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return instance.has$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
- " return instance.get$capitalized_name$Value();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Value$}$() {\n"
+ " return instance.get$capitalized_name$Value();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder "
- "${$set$capitalized_name$Value$}$(int value) {\n"
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$Value$}$(int value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$Value(value);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ }
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return instance.get$capitalized_name$();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$$}$($type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
" copyOnWrite();\n"
- " instance.set$capitalized_name$Value(value);\n"
+ " instance.clear$capitalized_name$();\n"
" return this;\n"
"}\n");
- printer->Annotate("{", "}", descriptor_);
- }
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return instance.get$capitalized_name$();\n"
- "}\n");
printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
-}
-
-void ImmutableEnumOneofFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$oneof_name$_ = visitor.visitOneofInt(\n"
- " $has_oneof_case_message$, $oneof_name$_, other.$oneof_name$_);\n");
-}
-
-void ImmutableEnumOneofFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- if (SupportUnknownEnumValue(descriptor_->file())) {
- printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "$set_oneof_case_message$;\n"
- "$oneof_name$_ = rawValue;\n");
- } else {
- printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "$type$ value = $type$.forNumber(rawValue);\n"
- "if (value == null) {\n"
- " super.mergeVarintField($number$, rawValue);\n"
- "} else {\n"
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = rawValue;\n"
- "}\n");
- }
-}
-
-void ImmutableEnumOneofFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " output.writeEnum($number$, ((java.lang.Integer) $oneof_name$_));\n"
- "}\n");
-}
-
-void ImmutableEnumOneofFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .computeEnumSize($number$, ((java.lang.Integer) $oneof_name$_));\n"
- "}\n");
-}
-
-void ImmutableEnumOneofFieldLiteGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- if (SupportUnknownEnumValue(descriptor_->file())) {
- printer->Print(variables_,
- "result = result && get$capitalized_name$Value()\n"
- " == other.get$capitalized_name$Value();\n");
- } else {
- printer->Print(variables_,
- "result = result && get$capitalized_name$()\n"
- " .equals(other.get$capitalized_name$());\n");
- }
-}
-
-void ImmutableEnumOneofFieldLiteGenerator::
-GenerateHashCode(io::Printer* printer) const {
- if (SupportUnknownEnumValue(descriptor_->file())) {
- printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n"
- "hash = (53 * hash) + get$capitalized_name$Value();\n");
- } else {
- printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n"
- "hash = (53 * hash) + get$capitalized_name$().getNumber();\n");
- }
}
// ===================================================================
@@ -579,433 +513,309 @@
}
RepeatedImmutableEnumFieldLiteGenerator::
-~RepeatedImmutableEnumFieldLiteGenerator() {}
+ ~RepeatedImmutableEnumFieldLiteGenerator() {}
int RepeatedImmutableEnumFieldLiteGenerator::GetNumBitsForMessage() const {
return 0;
}
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldLiteGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$java.util.List<$type$> get$capitalized_name$List();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.util.List<$type$> get$capitalized_name$List();\n");
+ "$deprecation$int get$capitalized_name$Count();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Count();\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$(int index);\n");
+ "$deprecation$$type$ get$capitalized_name$(int index);\n");
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.util.List<java.lang.Integer>\n"
- "get$capitalized_name$ValueList();\n");
+ "$deprecation$java.util.List<java.lang.Integer>\n"
+ "get$capitalized_name$ValueList();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Value(int index);\n");
+ "$deprecation$int get$capitalized_name$Value(int index);\n");
}
}
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private com.google.protobuf.Internal.IntList $name$_;\n"
- "private static final com.google.protobuf.Internal.ListAdapter.Converter<\n"
- " java.lang.Integer, $type$> $name$_converter_ =\n"
- " new com.google.protobuf.Internal.ListAdapter.Converter<\n"
- " java.lang.Integer, $type$>() {\n"
- " @java.lang.Override\n"
- " public $type$ convert(java.lang.Integer from) {\n"
- " $type$ result = $type$.forNumber(from);\n"
- " return result == null ? $unknown$ : result;\n"
- " }\n"
- " };\n");
+void RepeatedImmutableEnumFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "private com.google.protobuf.Internal.IntList $name$_;\n"
+ "private static final "
+ "com.google.protobuf.Internal.ListAdapter.Converter<\n"
+ " java.lang.Integer, $type$> $name$_converter_ =\n"
+ " new com.google.protobuf.Internal.ListAdapter.Converter<\n"
+ " java.lang.Integer, $type$>() {\n"
+ " @java.lang.Override\n"
+ " public $type$ convert(java.lang.Integer from) {\n"
+ " $type$ result = $type$.forNumber(from);\n"
+ " return result == null ? $unknown$ : result;\n"
+ " }\n"
+ " };\n");
PrintExtraFieldInfo(variables_, printer);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.util.List<$type$> "
- "${$get$capitalized_name$List$}$() {\n"
- " return new com.google.protobuf.Internal.ListAdapter<\n"
- " java.lang.Integer, $type$>($name$_, $name$_converter_);\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public java.util.List<$type$> "
+ "${$get$capitalized_name$List$}$() {\n"
+ " return new com.google.protobuf.Internal.ListAdapter<\n"
+ " java.lang.Integer, $type$>($name$_, $name$_converter_);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return $name$_.size();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return $name$_.size();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
- " return $name$_converter_.convert($name$_.getInt(index));\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
+ " return $name$_converter_.convert($name$_.getInt(index));\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.util.List<java.lang.Integer>\n"
- "${$get$capitalized_name$ValueList$}$() {\n"
- " return $name$_;\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public java.util.List<java.lang.Integer>\n"
+ "${$get$capitalized_name$ValueList$}$() {\n"
+ " return $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Value$}$(int index) {\n"
- " return $name$_.getInt(index);\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public int "
+ "${$get$capitalized_name$Value$}$(int index) {\n"
+ " return $name$_.getInt(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
if (!EnableExperimentalRuntimeForLite() && descriptor_->is_packed() &&
context_->HasGeneratedMethods(descriptor_->containing_type())) {
- printer->Print(variables_,
- "private int $name$MemoizedSerializedSize;\n");
+ printer->Print(variables_, "private int $name$MemoizedSerializedSize;\n");
}
// Generate private setters for the builder to proxy into.
- printer->Print(variables_,
- "private void ensure$capitalized_name$IsMutable() {\n"
- " if (!$is_mutable$) {\n"
- " $name$_ =\n"
- " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
- " }\n"
- "}\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void set$capitalized_name$(\n"
- " int index, $type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.setInt(index, value.getNumber());\n"
- "}\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void add$capitalized_name$($type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.addInt(value.getNumber());\n"
- "}\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void addAll$capitalized_name$(\n"
- " java.lang.Iterable<? extends $type$> values) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " for ($type$ value : values) {\n"
- " $name$_.addInt(value.getNumber());\n"
- " }\n"
- "}\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void clear$capitalized_name$() {\n"
- " $name$_ = emptyIntList();\n"
- "}\n");
-
- if (SupportUnknownEnumValue(descriptor_->file())) {
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void set$capitalized_name$Value(\n"
- " int index, int value) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.setInt(index, value);\n"
- "}\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void add$capitalized_name$Value(int value) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.addInt(value);\n"
- "}\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void addAll$capitalized_name$Value(\n"
- " java.lang.Iterable<java.lang.Integer> values) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " for (int value : values) {\n"
- " $name$_.addInt(value);\n"
+ printer->Print(
+ variables_,
+ "private void ensure$capitalized_name$IsMutable() {\n"
+ " if (!$is_mutable$) {\n"
+ " $name$_ =\n"
+ " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
" }\n"
"}\n");
- }
-}
-
-
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.util.List<$type$> "
- "${$get$capitalized_name$List$}$() {\n"
- " return instance.get$capitalized_name$List();\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
+ "private void set$capitalized_name$(\n"
+ " int index, $type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.setInt(index, value.getNumber());\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return instance.get$capitalized_name$Count();\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
+ "private void add$capitalized_name$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.addInt(value.getNumber());\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
- " return instance.get$capitalized_name$(index);\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
+ "private void addAll$capitalized_name$(\n"
+ " java.lang.Iterable<? extends $type$> values) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " for ($type$ value : values) {\n"
+ " $name$_.addInt(value.getNumber());\n"
+ " }\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " int index, $type$ value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(index, value);\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$$}$($type$ value) {\n"
- " copyOnWrite();\n"
- " instance.add$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
- " java.lang.Iterable<? extends $type$> values) {\n"
- " copyOnWrite();\n"
- " instance.addAll$capitalized_name$(values);"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
+ "private void clear$capitalized_name$() {\n"
+ " $name$_ = emptyIntList();\n"
+ "}\n");
if (SupportUnknownEnumValue(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.util.List<java.lang.Integer>\n"
- "${$get$capitalized_name$ValueList$}$() {\n"
- " return java.util.Collections.unmodifiableList(\n"
- " instance.get$capitalized_name$ValueList());\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
+ "private void set$capitalized_name$Value(\n"
+ " int index, int value) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.setInt(index, value);\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Value$}$(int index) {\n"
- " return instance.get$capitalized_name$Value(index);\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
+ "private void add$capitalized_name$Value(int value) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.addInt(value);\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$Value$}$(\n"
- " int index, int value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$Value(index, value);\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder "
- "${$add$capitalized_name$Value$}$(int value) {\n"
- " instance.add$capitalized_name$Value(value);\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$addAll$capitalized_name$Value$}$(\n"
- " java.lang.Iterable<java.lang.Integer> values) {\n"
- " copyOnWrite();\n"
- " instance.addAll$capitalized_name$Value(values);\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
+ "private void addAll$capitalized_name$Value(\n"
+ " java.lang.Iterable<java.lang.Integer> values) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " for (int value : values) {\n"
+ " $name$_.addInt(value);\n"
+ " }\n"
+ "}\n");
}
}
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
- // noop for enums
-}
-
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
- printer->Print(variables_, "$name$_ = emptyIntList();\n");
-}
-
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer) const {
printer->Print(variables_,
- "$name$_= visitor.visitIntList($name$_, other.$name$_);\n");
+ "fieldInfoWithEnumMap(\n"
+ " reflectField($classname$.class, \"$name$_\"),\n"
+ " $number$,\n"
+ " com.google.protobuf.FieldType.$annotation_field_type$,\n"
+ " $type$.internalGetValueMap())");
}
-
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$name$_.makeImmutable();\n");
-}
-
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- // Read and store the enum
- printer->Print(variables_,
- "if (!$is_mutable$) {\n"
- " $name$_ =\n"
- " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
- "}\n");
-
- if (SupportUnknownEnumValue(descriptor_->file())) {
- printer->Print(variables_,
- "$name$_.addInt(input.readEnum());\n");
- } else {
- printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "$type$ value = $type$.forNumber(rawValue);\n"
- "if (value == null) {\n"
- // We store the unknown value in unknown fields.
- " super.mergeVarintField($number$, rawValue);\n"
- "} else {\n"
- " $name$_.addInt(rawValue);\n"
- "}\n");
+void RepeatedImmutableEnumFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
+ printer->Print(variables_, "\"$name$_\",\n");
+ if (SupportFieldPresence(descriptor_->file())) {
+ PrintEnumVerifierLogic(printer, descriptor_, variables_,
+ /*var_name=*/"$type$",
+ /*terminating_string=*/",\n",
+ /*enforce_lite=*/context_->EnforceLite());
}
}
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateParsingCodeFromPacked(io::Printer* printer) const {
+void RepeatedImmutableEnumFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
+ WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "if (!$is_mutable$) {\n"
- " $name$_ =\n"
- " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
- "}\n");
-
- printer->Print(variables_,
- "int length = input.readRawVarint32();\n"
- "int oldLimit = input.pushLimit(length);\n"
- "while(input.getBytesUntilLimit() > 0) {\n");
- printer->Indent();
-
- // Read and store the enum
- if (SupportUnknownEnumValue(descriptor_->file())) {
- printer->Print(variables_,
- "$name$_.addInt(input.readEnum());\n");
- } else {
- printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "$type$ value = $type$.forNumber(rawValue);\n"
- "if (value == null) {\n"
- // We store the unknown value in unknown fields.
- " super.mergeVarintField($number$, rawValue);\n"
- "} else {\n"
- " $name$_.addInt(rawValue);\n"
- "}\n");
- }
-
- printer->Outdent();
- printer->Print(variables_,
- "}\n"
- "input.popLimit(oldLimit);\n");
-}
-
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_mutable$) {\n"
- " $name$_.makeImmutable();\n"
- "}\n");
-}
-
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- GOOGLE_CHECK(!EnableExperimentalRuntimeForLite());
-
- if (descriptor_->is_packed()) {
- printer->Print(variables_,
- "if (get$capitalized_name$List().size() > 0) {\n"
- " output.writeUInt32NoTag($tag$);\n"
- " output.writeUInt32NoTag($name$MemoizedSerializedSize);\n"
- "}\n"
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " output.writeEnumNoTag($name$_.getInt(i));\n"
- "}\n");
- } else {
- printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " output.writeEnum($number$, $name$_.getInt(i));\n"
- "}\n");
- }
-}
-
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- GOOGLE_CHECK(!EnableExperimentalRuntimeForLite());
-
- printer->Print(variables_,
- "{\n"
- " int dataSize = 0;\n");
- printer->Indent();
-
- printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " dataSize += com.google.protobuf.CodedOutputStream\n"
- " .computeEnumSizeNoTag($name$_.getInt(i));\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public java.util.List<$type$> "
+ "${$get$capitalized_name$List$}$() {\n"
+ " return instance.get$capitalized_name$List();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
printer->Print(
- "size += dataSize;\n");
- if (descriptor_->is_packed()) {
- printer->Print(variables_,
- "if (!get$capitalized_name$List().isEmpty()) {"
- " size += $tag_size$;\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .computeUInt32SizeNoTag(dataSize);\n"
- "}");
- } else {
- printer->Print(variables_,
- "size += $tag_size$ * $name$_.size();\n");
- }
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return instance.get$capitalized_name$Count();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
+ " return instance.get$capitalized_name$(index);\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " int index, $type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(index, value);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder "
+ "${$add$capitalized_name$$}$($type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.add$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
+ " java.lang.Iterable<? extends $type$> values) {\n"
+ " copyOnWrite();\n"
+ " instance.addAll$capitalized_name$(values);"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " copyOnWrite();\n"
+ " instance.clear$capitalized_name$();\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
- // cache the data size for packed fields.
- if (descriptor_->is_packed()) {
+ if (SupportUnknownEnumValue(descriptor_->file())) {
+ WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$name$MemoizedSerializedSize = dataSize;\n");
+ "@java.lang.Override\n"
+ "$deprecation$public java.util.List<java.lang.Integer>\n"
+ "${$get$capitalized_name$ValueList$}$() {\n"
+ " return java.util.Collections.unmodifiableList(\n"
+ " instance.get$capitalized_name$ValueList());\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int "
+ "${$get$capitalized_name$Value$}$(int index) {\n"
+ " return instance.get$capitalized_name$Value(index);\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$set$capitalized_name$Value$}$(\n"
+ " int index, int value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$Value(index, value);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder "
+ "${$add$capitalized_name$Value$}$(int value) {\n"
+ " instance.add$capitalized_name$Value(value);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$addAll$capitalized_name$Value$}$(\n"
+ " java.lang.Iterable<java.lang.Integer> values) {\n"
+ " copyOnWrite();\n"
+ " instance.addAll$capitalized_name$Value(values);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
}
-
- printer->Outdent();
- printer->Print("}\n");
}
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(variables_,
- "result = result && $name$_.equals(other.$name$_);\n");
-}
-
-void RepeatedImmutableEnumFieldLiteGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (get$capitalized_name$Count() > 0) {\n"
- " hash = (37 * hash) + $constant_name$;\n"
- " hash = (53 * hash) + $name$_.hashCode();\n"
- "}\n");
+void RepeatedImmutableEnumFieldLiteGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
+ printer->Print(variables_, "$name$_ = emptyIntList();\n");
}
std::string RepeatedImmutableEnumFieldLiteGenerator::GetBoxedType() const {
diff --git a/src/google/protobuf/compiler/java/java_enum_field_lite.h b/src/google/protobuf/compiler/java/java_enum_field_lite.h
index bf25ffa..a895587 100644
--- a/src/google/protobuf/compiler/java/java_enum_field_lite.h
+++ b/src/google/protobuf/compiler/java/java_enum_field_lite.h
@@ -69,15 +69,9 @@
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
+ void GenerateFieldInfo(io::Printer* printer) const;
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
std::string GetBoxedType() const;
@@ -101,12 +95,9 @@
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
+ void GenerateFieldInfo(io::Printer* printer) const;
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImmutableEnumOneofFieldLiteGenerator);
@@ -125,16 +116,9 @@
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingCodeFromPacked(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
+ void GenerateFieldInfo(io::Printer* printer) const;
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
std::string GetBoxedType() const;
diff --git a/src/google/protobuf/compiler/java/java_enum_lite.cc b/src/google/protobuf/compiler/java/java_enum_lite.cc
index 8e41429..c4d6f8a 100644
--- a/src/google/protobuf/compiler/java/java_enum_lite.cc
+++ b/src/google/protobuf/compiler/java/java_enum_lite.cc
@@ -60,7 +60,7 @@
for (int i = 0; i < descriptor_->value_count(); i++) {
const EnumValueDescriptor* value = descriptor_->value(i);
const EnumValueDescriptor* canonical_value =
- descriptor_->FindValueByNumber(value->number());
+ descriptor_->FindValueByNumber(value->number());
if (value == canonical_value) {
canonical_values_.push_back(value);
@@ -93,8 +93,7 @@
if (canonical_values_[i]->options().deprecated()) {
printer->Print("@java.lang.Deprecated\n");
}
- printer->Print(vars,
- "$name$($number$),\n");
+ printer->Print(vars, "$name$($number$),\n");
printer->Annotate("name", canonical_values_[i]);
}
@@ -104,8 +103,8 @@
}
printer->Print(
- ";\n"
- "\n");
+ ";\n"
+ "\n");
// -----------------------------------------------------------------
@@ -115,8 +114,8 @@
vars["name"] = aliases_[i].value->name();
vars["canonical_name"] = aliases_[i].canonical_value->name();
WriteEnumValueDocComment(printer, aliases_[i].value);
- printer->Print(vars,
- "public static final $classname$ $name$ = $canonical_name$;\n");
+ printer->Print(
+ vars, "public static final $classname$ $name$ = $canonical_name$;\n");
printer->Annotate("name", aliases_[i].value);
}
@@ -128,7 +127,7 @@
vars["}"] = "";
WriteEnumValueDocComment(printer, descriptor_->value(i));
printer->Print(vars,
- "public static final int ${$$name$_VALUE$}$ = $number$;\n");
+ "public static final int ${$$name$_VALUE$}$ = $number$;\n");
printer->Annotate("{", "}", descriptor_->value(i));
}
printer->Print("\n");
@@ -208,17 +207,17 @@
"classname", descriptor_->name());
printer->Print(
- "private final int value;\n\n"
- "private $classname$(int value) {\n",
- "classname", descriptor_->name());
+ "private final int value;\n\n"
+ "private $classname$(int value) {\n",
+ "classname", descriptor_->name());
printer->Print(
- " this.value = value;\n"
- "}\n");
+ " this.value = value;\n"
+ "}\n");
printer->Print(
- "\n"
- "// @@protoc_insertion_point(enum_scope:$full_name$)\n",
- "full_name", descriptor_->full_name());
+ "\n"
+ "// @@protoc_insertion_point(enum_scope:$full_name$)\n",
+ "full_name", descriptor_->full_name());
printer->Outdent();
printer->Print("}\n\n");
diff --git a/src/google/protobuf/compiler/java/java_enum_lite.h b/src/google/protobuf/compiler/java/java_enum_lite.h
index 9e20e6f..996d44e 100644
--- a/src/google/protobuf/compiler/java/java_enum_lite.h
+++ b/src/google/protobuf/compiler/java/java_enum_lite.h
@@ -42,13 +42,13 @@
namespace google {
namespace protobuf {
namespace compiler {
- namespace java {
- class Context; // context.h
- class ClassNameResolver; // name_resolver.h
- }
-}
+namespace java {
+class Context; // context.h
+class ClassNameResolver; // name_resolver.h
+} // namespace java
+} // namespace compiler
namespace io {
- class Printer; // printer.h
+class Printer; // printer.h
}
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/compiler/java/java_extension.cc b/src/google/protobuf/compiler/java/java_extension.cc
index 5b744aa..f197d41 100644
--- a/src/google/protobuf/compiler/java/java_extension.cc
+++ b/src/google/protobuf/compiler/java/java_extension.cc
@@ -49,11 +49,12 @@
ImmutableExtensionGenerator::ImmutableExtensionGenerator(
const FieldDescriptor* descriptor, Context* context)
- : descriptor_(descriptor), context_(context),
- name_resolver_(context->GetNameResolver()) {
+ : descriptor_(descriptor),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
if (descriptor_->extension_scope() != NULL) {
- scope_ = name_resolver_->GetImmutableClassName(
- descriptor_->extension_scope());
+ scope_ =
+ name_resolver_->GetImmutableClassName(descriptor_->extension_scope());
} else {
scope_ = name_resolver_->GetImmutableClassName(descriptor_->file());
}
@@ -74,8 +75,9 @@
vars["number"] = StrCat(descriptor->number());
vars["constant_name"] = FieldConstantName(descriptor);
vars["index"] = StrCat(descriptor->index());
- vars["default"] = descriptor->is_repeated() ?
- "" : DefaultValue(descriptor, immutable, name_resolver);
+ vars["default"] = descriptor->is_repeated()
+ ? ""
+ : DefaultValue(descriptor, immutable, name_resolver);
vars["type_constant"] = FieldTypeName(GetType(descriptor));
vars["packed"] = descriptor->is_packed() ? "true" : "false";
vars["enum_map"] = "null";
@@ -85,13 +87,13 @@
std::string singular_type;
switch (java_type) {
case JAVATYPE_MESSAGE:
- singular_type = name_resolver->GetClassName(descriptor->message_type(),
- immutable);
+ singular_type =
+ name_resolver->GetClassName(descriptor->message_type(), immutable);
vars["prototype"] = singular_type + ".getDefaultInstance()";
break;
case JAVATYPE_ENUM:
- singular_type = name_resolver->GetClassName(descriptor->enum_type(),
- immutable);
+ singular_type =
+ name_resolver->GetClassName(descriptor->enum_type(), immutable);
vars["enum_map"] = singular_type + ".internalGetValueMap()";
break;
case JAVATYPE_STRING:
@@ -104,8 +106,9 @@
singular_type = BoxedPrimitiveTypeName(java_type);
break;
}
- vars["type"] = descriptor->is_repeated() ?
- "java.util.List<" + singular_type + ">" : singular_type;
+ vars["type"] = descriptor->is_repeated()
+ ? "java.util.List<" + singular_type + ">"
+ : singular_type;
vars["singular_type"] = singular_type;
}
@@ -114,8 +117,7 @@
const bool kUseImmutableNames = true;
InitTemplateVars(descriptor_, scope_, kUseImmutableNames, name_resolver_,
&vars);
- printer->Print(vars,
- "public static final int $constant_name$ = $number$;\n");
+ printer->Print(vars, "public static final int $constant_name$ = $number$;\n");
WriteFieldDocComment(printer, descriptor_);
if (descriptor_->extension_scope() == NULL) {
@@ -162,10 +164,8 @@
int ImmutableExtensionGenerator::GenerateRegistrationCode(
io::Printer* printer) {
- printer->Print(
- "registry.add($scope$.$name$);\n",
- "scope", scope_,
- "name", UnderscoresToCamelCaseCheckReserved(descriptor_));
+ printer->Print("registry.add($scope$.$name$);\n", "scope", scope_, "name",
+ UnderscoresToCamelCaseCheckReserved(descriptor_));
return 7;
}
diff --git a/src/google/protobuf/compiler/java/java_extension_lite.cc b/src/google/protobuf/compiler/java/java_extension_lite.cc
index 9db28a4..27225ac 100644
--- a/src/google/protobuf/compiler/java/java_extension_lite.cc
+++ b/src/google/protobuf/compiler/java/java_extension_lite.cc
@@ -44,11 +44,12 @@
ImmutableExtensionLiteGenerator::ImmutableExtensionLiteGenerator(
const FieldDescriptor* descriptor, Context* context)
- : descriptor_(descriptor), context_(context),
- name_resolver_(context->GetNameResolver()) {
+ : descriptor_(descriptor),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
if (descriptor_->extension_scope() != NULL) {
- scope_ = name_resolver_->GetImmutableClassName(
- descriptor_->extension_scope());
+ scope_ =
+ name_resolver_->GetImmutableClassName(descriptor_->extension_scope());
} else {
scope_ = name_resolver_->GetImmutableClassName(descriptor_->file());
}
@@ -61,8 +62,7 @@
const bool kUseImmutableNames = true;
InitTemplateVars(descriptor_, scope_, kUseImmutableNames, name_resolver_,
&vars);
- printer->Print(vars,
- "public static final int $constant_name$ = $number$;\n");
+ printer->Print(vars, "public static final int $constant_name$ = $number$;\n");
WriteFieldDocComment(printer, descriptor_);
if (descriptor_->is_repeated()) {
@@ -106,10 +106,8 @@
int ImmutableExtensionLiteGenerator::GenerateRegistrationCode(
io::Printer* printer) {
- printer->Print(
- "registry.add($scope$.$name$);\n",
- "scope", scope_,
- "name", UnderscoresToCamelCaseCheckReserved(descriptor_));
+ printer->Print("registry.add($scope$.$name$);\n", "scope", scope_, "name",
+ UnderscoresToCamelCaseCheckReserved(descriptor_));
return 7;
}
diff --git a/src/google/protobuf/compiler/java/java_field.cc b/src/google/protobuf/compiler/java/java_field.cc
index a18f02f..18a86ba 100644
--- a/src/google/protobuf/compiler/java/java_field.cc
+++ b/src/google/protobuf/compiler/java/java_field.cc
@@ -63,15 +63,16 @@
namespace {
-ImmutableFieldGenerator* MakeImmutableGenerator(
- const FieldDescriptor* field, int messageBitIndex, int builderBitIndex,
- Context* context) {
+ImmutableFieldGenerator* MakeImmutableGenerator(const FieldDescriptor* field,
+ int messageBitIndex,
+ int builderBitIndex,
+ Context* context) {
if (field->is_repeated()) {
switch (GetJavaType(field)) {
case JAVATYPE_MESSAGE:
if (IsMapEntry(field->message_type())) {
- return new ImmutableMapFieldGenerator(
- field, messageBitIndex, builderBitIndex, context);
+ return new ImmutableMapFieldGenerator(field, messageBitIndex,
+ builderBitIndex, context);
} else {
return new RepeatedImmutableMessageFieldGenerator(
field, messageBitIndex, builderBitIndex, context);
@@ -93,8 +94,8 @@
return new ImmutableMessageOneofFieldGenerator(
field, messageBitIndex, builderBitIndex, context);
case JAVATYPE_ENUM:
- return new ImmutableEnumOneofFieldGenerator(
- field, messageBitIndex, builderBitIndex, context);
+ return new ImmutableEnumOneofFieldGenerator(field, messageBitIndex,
+ builderBitIndex, context);
case JAVATYPE_STRING:
return new ImmutableStringOneofFieldGenerator(
field, messageBitIndex, builderBitIndex, context);
@@ -105,17 +106,17 @@
} else {
switch (GetJavaType(field)) {
case JAVATYPE_MESSAGE:
- return new ImmutableMessageFieldGenerator(
- field, messageBitIndex, builderBitIndex, context);
+ return new ImmutableMessageFieldGenerator(field, messageBitIndex,
+ builderBitIndex, context);
case JAVATYPE_ENUM:
- return new ImmutableEnumFieldGenerator(
- field, messageBitIndex, builderBitIndex, context);
+ return new ImmutableEnumFieldGenerator(field, messageBitIndex,
+ builderBitIndex, context);
case JAVATYPE_STRING:
- return new ImmutableStringFieldGenerator(
- field, messageBitIndex, builderBitIndex, context);
+ return new ImmutableStringFieldGenerator(field, messageBitIndex,
+ builderBitIndex, context);
default:
- return new ImmutablePrimitiveFieldGenerator(
- field, messageBitIndex, builderBitIndex, context);
+ return new ImmutablePrimitiveFieldGenerator(field, messageBitIndex,
+ builderBitIndex, context);
}
}
}
@@ -193,18 +194,13 @@
ImmutableFieldGenerator::~ImmutableFieldGenerator() {}
-void ImmutableFieldGenerator::
-GenerateParsingCodeFromPacked(io::Printer* printer) const {
+void ImmutableFieldGenerator::GenerateParsingCodeFromPacked(
+ io::Printer* printer) const {
ReportUnexpectedPackedFieldsCall(printer);
}
ImmutableFieldLiteGenerator::~ImmutableFieldLiteGenerator() {}
-void ImmutableFieldLiteGenerator::
-GenerateParsingCodeFromPacked(io::Printer* printer) const {
- ReportUnexpectedPackedFieldsCall(printer);
-}
-
// ===================================================================
template <>
@@ -224,7 +220,7 @@
}
}
-template<>
+template <>
FieldGeneratorMap<ImmutableFieldGenerator>::~FieldGeneratorMap() {}
template <>
@@ -242,7 +238,7 @@
}
}
-template<>
+template <>
FieldGeneratorMap<ImmutableFieldLiteGenerator>::~FieldGeneratorMap() {}
@@ -271,10 +267,10 @@
(*variables)["oneof_capitalized_name"] = info->capitalized_name;
(*variables)["oneof_index"] =
StrCat(descriptor->containing_oneof()->index());
+ (*variables)["oneof_stored_type"] = GetOneofStoredType(descriptor);
(*variables)["set_oneof_case_message"] =
info->name + "Case_ = " + StrCat(descriptor->number());
- (*variables)["clear_oneof_case_message"] = info->name +
- "Case_ = 0";
+ (*variables)["clear_oneof_case_message"] = info->name + "Case_ = 0";
(*variables)["has_oneof_case_message"] =
info->name + "Case_ == " + StrCat(descriptor->number());
}
diff --git a/src/google/protobuf/compiler/java/java_field.h b/src/google/protobuf/compiler/java/java_field.h
index abefc58..8a88d69 100644
--- a/src/google/protobuf/compiler/java/java_field.h
+++ b/src/google/protobuf/compiler/java/java_field.h
@@ -39,9 +39,9 @@
#include <memory>
#include <string>
+#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/descriptor.h>
-#include <google/protobuf/stubs/logging.h>
namespace google {
namespace protobuf {
@@ -103,20 +103,8 @@
virtual void GenerateMembers(io::Printer* printer) const = 0;
virtual void GenerateBuilderMembers(io::Printer* printer) const = 0;
virtual void GenerateInitializationCode(io::Printer* printer) const = 0;
- virtual void GenerateVisitCode(io::Printer* printer) const = 0;
- virtual void GenerateDynamicMethodMakeImmutableCode(io::Printer* printer)
- const = 0;
- virtual void GenerateParsingCode(io::Printer* printer) const = 0;
- virtual void GenerateParsingCodeFromPacked(io::Printer* printer) const;
- virtual void GenerateParsingDoneCode(io::Printer* printer) const = 0;
- virtual void GenerateSerializationCode(io::Printer* printer) const = 0;
- virtual void GenerateSerializedSizeCode(io::Printer* printer) const = 0;
- virtual void GenerateFieldBuilderInitializationCode(io::Printer* printer)
- const = 0;
-
- virtual void GenerateEqualsCode(io::Printer* printer) const = 0;
- virtual void GenerateHashCode(io::Printer* printer) const = 0;
-
+ virtual void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const = 0;
virtual std::string GetBoxedType() const = 0;
@@ -126,11 +114,10 @@
// Convenience class which constructs FieldGenerators for a Descriptor.
-template<typename FieldGeneratorType>
+template <typename FieldGeneratorType>
class FieldGeneratorMap {
public:
- explicit FieldGeneratorMap(const Descriptor* descriptor,
- Context* context);
+ explicit FieldGeneratorMap(const Descriptor* descriptor, Context* context);
~FieldGeneratorMap();
const FieldGeneratorType& get(const FieldDescriptor* field) const;
@@ -144,20 +131,19 @@
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldGeneratorMap);
};
-template<typename FieldGeneratorType>
-inline const FieldGeneratorType&
-FieldGeneratorMap<FieldGeneratorType>::get(const FieldDescriptor* field) const {
+template <typename FieldGeneratorType>
+inline const FieldGeneratorType& FieldGeneratorMap<FieldGeneratorType>::get(
+ const FieldDescriptor* field) const {
GOOGLE_CHECK_EQ(field->containing_type(), descriptor_);
return *field_generators_[field->index()];
}
// Instantiate template for mutable and immutable maps.
-template<>
-FieldGeneratorMap<ImmutableFieldGenerator>::
-FieldGeneratorMap(const Descriptor* descriptor,
- Context* context);
+template <>
+FieldGeneratorMap<ImmutableFieldGenerator>::FieldGeneratorMap(
+ const Descriptor* descriptor, Context* context);
-template<>
+template <>
FieldGeneratorMap<ImmutableFieldGenerator>::~FieldGeneratorMap();
diff --git a/src/google/protobuf/compiler/java/java_file.cc b/src/google/protobuf/compiler/java/java_file.cc
index e963035..e895391 100644
--- a/src/google/protobuf/compiler/java/java_file.cc
+++ b/src/google/protobuf/compiler/java/java_file.cc
@@ -63,26 +63,26 @@
namespace {
struct FieldDescriptorCompare {
- bool operator ()(const FieldDescriptor* f1, const FieldDescriptor* f2) const {
- if(f1 == NULL) {
+ bool operator()(const FieldDescriptor* f1, const FieldDescriptor* f2) const {
+ if (f1 == NULL) {
return false;
}
- if(f2 == NULL) {
+ if (f2 == NULL) {
return true;
}
return f1->full_name() < f2->full_name();
}
};
-typedef std::set<const FieldDescriptor*, FieldDescriptorCompare> FieldDescriptorSet;
+typedef std::set<const FieldDescriptor*, FieldDescriptorCompare>
+ FieldDescriptorSet;
// Recursively searches the given message to collect extensions.
// Returns true if all the extensions can be recognized. The extensions will be
// appended in to the extensions parameter.
// Returns false when there are unknown fields, in which case the data in the
// extensions output parameter is not reliable and should be discarded.
-bool CollectExtensions(const Message& message,
- FieldDescriptorSet* extensions) {
+bool CollectExtensions(const Message& message, FieldDescriptorSet* extensions) {
const Reflection* reflection = message.GetReflection();
// There are unknown fields that could be extensions, thus this call fails.
@@ -99,7 +99,7 @@
int size = reflection->FieldSize(message, fields[i]);
for (int j = 0; j < size; j++) {
const Message& sub_message =
- reflection->GetRepeatedMessage(message, fields[i], j);
+ reflection->GetRepeatedMessage(message, fields[i], j);
if (!CollectExtensions(sub_message, extensions)) return false;
}
} else {
@@ -160,11 +160,9 @@
// extend our methods by simply chaining them to another method
// with a tail call. This inserts the sequence call-next-method,
// end this one, begin-next-method as needed.
-void MaybeRestartJavaMethod(io::Printer* printer,
- int *bytecode_estimate,
- int *method_num,
- const char *chain_statement,
- const char *method_decl) {
+void MaybeRestartJavaMethod(io::Printer* printer, int* bytecode_estimate,
+ int* method_num, const char* chain_statement,
+ const char* method_decl) {
// The goal here is to stay under 64K bytes of jvm bytecode/method,
// since otherwise we hit a hardcoded limit in the jvm and javac will
// then fail with the error "code too large". This limit lets our
@@ -194,8 +192,7 @@
options_(options),
immutable_api_(immutable_api) {
classname_ = name_resolver_->GetFileClassName(file, immutable_api);
- generator_factory_.reset(
- new ImmutableGeneratorFactory(context_.get()));
+ generator_factory_.reset(new ImmutableGeneratorFactory(context_.get()));
for (int i = 0; i < file_->message_type_count(); ++i) {
message_generators_[i].reset(
generator_factory_->NewMessageGenerator(file_->message_type(i)));
@@ -217,12 +214,13 @@
NameEquality::EXACT_EQUAL)) {
error->assign(file_->name());
error->append(
- ": Cannot generate Java output because the file's outer class name, \"");
+ ": Cannot generate Java output because the file's outer class name, "
+ "\"");
error->append(classname_);
error->append(
- "\", matches the name of one of the types declared inside it. "
- "Please either rename the type or use the java_outer_classname "
- "option to specify a different outer class name for the .proto file.");
+ "\", matches the name of one of the types declared inside it. "
+ "Please either rename the type or use the java_outer_classname "
+ "option to specify a different outer class name for the .proto file.");
return false;
}
// Similar to the check above, but ignore the case this time. This is not a
@@ -243,8 +241,7 @@
if (file_->options().optimize_for() == FileOptions::LITE_RUNTIME) {
GOOGLE_LOG(WARNING)
<< "The optimize_for = LITE_RUNTIME option is no longer supported by "
- << "protobuf Java code generator and may generate broken code. It "
- << "will be ignored by protoc in the future and protoc will always "
+ << "protobuf Java code generator and is ignored--protoc will always "
<< "generate full runtime code for Java. To use Java Lite runtime, "
<< "users should use the Java Lite plugin instead. See:\n"
<< " "
@@ -258,33 +255,32 @@
// We don't import anything because we refer to all classes by their
// fully-qualified names in the generated source.
printer->Print(
- "// Generated by the protocol buffer compiler. DO NOT EDIT!\n"
- "// source: $filename$\n"
- "\n",
- "filename", file_->name());
+ "// Generated by the protocol buffer compiler. DO NOT EDIT!\n"
+ "// source: $filename$\n"
+ "\n",
+ "filename", file_->name());
if (!java_package_.empty()) {
printer->Print(
- "package $package$;\n"
- "\n",
- "package", java_package_);
+ "package $package$;\n"
+ "\n",
+ "package", java_package_);
}
PrintGeneratedAnnotation(
printer, '$', options_.annotate_code ? classname_ + ".java.pb.meta" : "");
printer->Print(
"$deprecation$public final class $classname$ {\n"
" private $ctor$() {}\n",
- "deprecation", file_->options().deprecated() ?
- "@java.lang.Deprecated " : "",
- "classname", classname_,
- "ctor", classname_);
+ "deprecation",
+ file_->options().deprecated() ? "@java.lang.Deprecated " : "",
+ "classname", classname_, "ctor", classname_);
printer->Annotate("classname", file_->name());
printer->Indent();
// -----------------------------------------------------------------
printer->Print(
- "public static void registerAllExtensions(\n"
- " com.google.protobuf.ExtensionRegistryLite registry) {\n");
+ "public static void registerAllExtensions(\n"
+ " com.google.protobuf.ExtensionRegistryLite registry) {\n");
printer->Indent();
@@ -297,8 +293,7 @@
}
printer->Outdent();
- printer->Print(
- "}\n");
+ printer->Print("}\n");
if (HasDescriptorMethods(file_, context_->EnforceLite())) {
// Overload registerAllExtensions for the non-lite usage to
// redundantly maintain the original signature (this is
@@ -306,12 +301,12 @@
// ExtensionRegistry in the non-lite usage). Intent is
// to remove this in the future.
printer->Print(
- "\n"
- "public static void registerAllExtensions(\n"
- " com.google.protobuf.ExtensionRegistry registry) {\n"
- " registerAllExtensions(\n"
- " (com.google.protobuf.ExtensionRegistryLite) registry);\n"
- "}\n");
+ "\n"
+ "public static void registerAllExtensions(\n"
+ " com.google.protobuf.ExtensionRegistry registry) {\n"
+ " registerAllExtensions(\n"
+ " (com.google.protobuf.ExtensionRegistryLite) registry);\n"
+ "}\n");
}
// -----------------------------------------------------------------
@@ -363,29 +358,27 @@
GenerateDescriptorInitializationCodeForMutable(printer);
}
} else {
- printer->Print(
- "static {\n");
+ printer->Print("static {\n");
printer->Indent();
int bytecode_estimate = 0;
int method_num = 0;
for (int i = 0; i < file_->message_type_count(); i++) {
- bytecode_estimate += message_generators_[i]->GenerateStaticVariableInitializers(printer);
+ bytecode_estimate +=
+ message_generators_[i]->GenerateStaticVariableInitializers(printer);
MaybeRestartJavaMethod(
- printer,
- &bytecode_estimate, &method_num,
- "_clinit_autosplit_$method_num$();\n",
- "private static void _clinit_autosplit_$method_num$() {\n");
+ printer, &bytecode_estimate, &method_num,
+ "_clinit_autosplit_$method_num$();\n",
+ "private static void _clinit_autosplit_$method_num$() {\n");
}
printer->Outdent();
- printer->Print(
- "}\n");
+ printer->Print("}\n");
}
printer->Print(
- "\n"
- "// @@protoc_insertion_point(outer_class_scope)\n");
+ "\n"
+ "// @@protoc_insertion_point(outer_class_scope)\n");
printer->Outdent();
printer->Print("}\n");
@@ -394,15 +387,15 @@
void FileGenerator::GenerateDescriptorInitializationCodeForImmutable(
io::Printer* printer) {
printer->Print(
- "public static com.google.protobuf.Descriptors.FileDescriptor\n"
- " getDescriptor() {\n"
- " return descriptor;\n"
- "}\n"
- "private static $final$ com.google.protobuf.Descriptors.FileDescriptor\n"
- " descriptor;\n"
- "static {\n",
- // TODO(dweis): Mark this as final.
- "final", "");
+ "public static com.google.protobuf.Descriptors.FileDescriptor\n"
+ " getDescriptor() {\n"
+ " return descriptor;\n"
+ "}\n"
+ "private static $final$ com.google.protobuf.Descriptors.FileDescriptor\n"
+ " descriptor;\n"
+ "static {\n",
+ // TODO(dweis): Mark this as final.
+ "final", "");
printer->Indent();
SharedCodeGenerator shared_code_generator(file_, options_);
@@ -412,20 +405,20 @@
int method_num = 0;
for (int i = 0; i < file_->message_type_count(); i++) {
- bytecode_estimate += message_generators_[i]->GenerateStaticVariableInitializers(printer);
+ bytecode_estimate +=
+ message_generators_[i]->GenerateStaticVariableInitializers(printer);
MaybeRestartJavaMethod(
- printer,
- &bytecode_estimate, &method_num,
- "_clinit_autosplit_dinit_$method_num$();\n",
- "private static void _clinit_autosplit_dinit_$method_num$() {\n");
+ printer, &bytecode_estimate, &method_num,
+ "_clinit_autosplit_dinit_$method_num$();\n",
+ "private static void _clinit_autosplit_dinit_$method_num$() {\n");
}
for (int i = 0; i < file_->extension_count(); i++) {
- bytecode_estimate += extension_generators_[i]->GenerateNonNestedInitializationCode(printer);
+ bytecode_estimate +=
+ extension_generators_[i]->GenerateNonNestedInitializationCode(printer);
MaybeRestartJavaMethod(
- printer,
- &bytecode_estimate, &method_num,
- "_clinit_autosplit_dinit_$method_num$();\n",
- "private static void _clinit_autosplit_dinit_$method_num$() {\n");
+ printer, &bytecode_estimate, &method_num,
+ "_clinit_autosplit_dinit_$method_num$();\n",
+ "private static void _clinit_autosplit_dinit_$method_num$() {\n");
}
// Proto compiler builds a DescriptorPool, which holds all the descriptors to
@@ -454,23 +447,22 @@
// Must construct an ExtensionRegistry containing all existing extensions
// and use it to parse the descriptor data again to recognize extensions.
printer->Print(
- "com.google.protobuf.ExtensionRegistry registry =\n"
- " com.google.protobuf.ExtensionRegistry.newInstance();\n");
+ "com.google.protobuf.ExtensionRegistry registry =\n"
+ " com.google.protobuf.ExtensionRegistry.newInstance();\n");
FieldDescriptorSet::iterator it;
for (it = extensions.begin(); it != extensions.end(); it++) {
std::unique_ptr<ExtensionGenerator> generator(
generator_factory_->NewExtensionGenerator(*it));
bytecode_estimate += generator->GenerateRegistrationCode(printer);
MaybeRestartJavaMethod(
- printer,
- &bytecode_estimate, &method_num,
- "_clinit_autosplit_dinit_$method_num$(registry);\n",
- "private static void _clinit_autosplit_dinit_$method_num$(\n"
- " com.google.protobuf.ExtensionRegistry registry) {\n");
+ printer, &bytecode_estimate, &method_num,
+ "_clinit_autosplit_dinit_$method_num$(registry);\n",
+ "private static void _clinit_autosplit_dinit_$method_num$(\n"
+ " com.google.protobuf.ExtensionRegistry registry) {\n");
}
printer->Print(
- "com.google.protobuf.Descriptors.FileDescriptor\n"
- " .internalUpdateFileDescriptor(descriptor, registry);\n");
+ "com.google.protobuf.Descriptors.FileDescriptor\n"
+ " .internalUpdateFileDescriptor(descriptor, registry);\n");
}
// Force descriptor initialization of all dependencies.
@@ -478,32 +470,31 @@
if (ShouldIncludeDependency(file_->dependency(i), true)) {
std::string dependency =
name_resolver_->GetImmutableClassName(file_->dependency(i));
- printer->Print(
- "$dependency$.getDescriptor();\n",
- "dependency", dependency);
+ printer->Print("$dependency$.getDescriptor();\n", "dependency",
+ dependency);
}
}
printer->Outdent();
- printer->Print(
- "}\n");
+ printer->Print("}\n");
}
-void FileGenerator::GenerateDescriptorInitializationCodeForMutable(io::Printer* printer) {
+void FileGenerator::GenerateDescriptorInitializationCodeForMutable(
+ io::Printer* printer) {
printer->Print(
- "public static com.google.protobuf.Descriptors.FileDescriptor\n"
- " getDescriptor() {\n"
- " return descriptor;\n"
- "}\n"
- "private static final com.google.protobuf.Descriptors.FileDescriptor\n"
- " descriptor;\n"
- "static {\n");
+ "public static com.google.protobuf.Descriptors.FileDescriptor\n"
+ " getDescriptor() {\n"
+ " return descriptor;\n"
+ "}\n"
+ "private static final com.google.protobuf.Descriptors.FileDescriptor\n"
+ " descriptor;\n"
+ "static {\n");
printer->Indent();
printer->Print(
- "descriptor = $immutable_package$.$descriptor_classname$.descriptor;\n",
- "immutable_package", FileJavaPackage(file_, true),
- "descriptor_classname", name_resolver_->GetDescriptorClassName(file_));
+ "descriptor = $immutable_package$.$descriptor_classname$.descriptor;\n",
+ "immutable_package", FileJavaPackage(file_, true), "descriptor_classname",
+ name_resolver_->GetDescriptorClassName(file_));
for (int i = 0; i < file_->message_type_count(); i++) {
message_generators_[i]->GenerateStaticVariableInitializers(printer);
@@ -583,15 +574,13 @@
if (ShouldIncludeDependency(file_->dependency(i), false)) {
std::string dependency =
name_resolver_->GetMutableClassName(file_->dependency(i));
- printer->Print(
- "$dependency$.getDescriptor();\n",
- "dependency", dependency);
+ printer->Print("$dependency$.getDescriptor();\n", "dependency",
+ dependency);
}
}
printer->Outdent();
- printer->Print(
- "}\n");
+ printer->Print("}\n");
}
template <typename GeneratorClass, typename DescriptorClass>
@@ -615,15 +604,15 @@
annotate_code ? &annotation_collector : NULL);
printer.Print(
- "// Generated by the protocol buffer compiler. DO NOT EDIT!\n"
- "// source: $filename$\n"
- "\n",
- "filename", descriptor->file()->name());
+ "// Generated by the protocol buffer compiler. DO NOT EDIT!\n"
+ "// source: $filename$\n"
+ "\n",
+ "filename", descriptor->file()->name());
if (!java_package.empty()) {
printer.Print(
- "package $package$;\n"
- "\n",
- "package", java_package);
+ "package $package$;\n"
+ "\n",
+ "package", java_package);
}
(generator->*pfn)(&printer);
@@ -683,8 +672,8 @@
}
}
-bool FileGenerator::ShouldIncludeDependency(
- const FileDescriptor* descriptor, bool immutable_api) {
+bool FileGenerator::ShouldIncludeDependency(const FileDescriptor* descriptor,
+ bool immutable_api) {
return true;
}
diff --git a/src/google/protobuf/compiler/java/java_file.h b/src/google/protobuf/compiler/java/java_file.h
index 9dca82b..bb3e4a5 100644
--- a/src/google/protobuf/compiler/java/java_file.h
+++ b/src/google/protobuf/compiler/java/java_file.h
@@ -43,20 +43,20 @@
namespace google {
namespace protobuf {
-class FileDescriptor; // descriptor.h
+class FileDescriptor; // descriptor.h
namespace io {
- class Printer; // printer.h
+class Printer; // printer.h
}
namespace compiler {
- class GeneratorContext; // code_generator.h
- namespace java {
- class Context; // context.h
- class MessageGenerator; // message.h
- class GeneratorFactory; // generator_factory.h
- class ExtensionGenerator; // extension.h
- class ClassNameResolver; // name_resolver.h
- }
-}
+class GeneratorContext; // code_generator.h
+namespace java {
+class Context; // context.h
+class MessageGenerator; // message.h
+class GeneratorFactory; // generator_factory.h
+class ExtensionGenerator; // extension.h
+class ClassNameResolver; // name_resolver.h
+} // namespace java
+} // namespace compiler
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/compiler/java/java_generator.cc b/src/google/protobuf/compiler/java/java_generator.cc
index 78bb6dc..5045cfd 100644
--- a/src/google/protobuf/compiler/java/java_generator.cc
+++ b/src/google/protobuf/compiler/java/java_generator.cc
@@ -78,6 +78,10 @@
file_options.generate_mutable_code = true;
} else if (options[i].first == "shared") {
file_options.generate_shared_code = true;
+ } else if (options[i].first == "lite") {
+ // Note: Java Lite does not guarantee API/ABI stability. We may choose to
+ // break existing API in order to boost performance / reduce code size.
+ file_options.enforce_lite = true;
} else if (options[i].first == "annotate_code") {
file_options.annotate_code = true;
} else if (options[i].first == "annotation_list_file") {
@@ -147,9 +151,9 @@
GeneratedCodeInfo annotations;
io::AnnotationProtoCollector<GeneratedCodeInfo> annotation_collector(
&annotations);
- io::Printer printer(output.get(), '$', file_options.annotate_code
- ? &annotation_collector
- : NULL);
+ io::Printer printer(
+ output.get(), '$',
+ file_options.annotate_code ? &annotation_collector : NULL);
file_generator->Generate(&printer);
diff --git a/src/google/protobuf/compiler/java/java_generator_factory.cc b/src/google/protobuf/compiler/java/java_generator_factory.cc
index 3218b41..3a62adb 100644
--- a/src/google/protobuf/compiler/java/java_generator_factory.cc
+++ b/src/google/protobuf/compiler/java/java_generator_factory.cc
@@ -52,9 +52,8 @@
// ===================================================================
-ImmutableGeneratorFactory::ImmutableGeneratorFactory(
- Context* context) : context_(context) {
-}
+ImmutableGeneratorFactory::ImmutableGeneratorFactory(Context* context)
+ : context_(context) {}
ImmutableGeneratorFactory::~ImmutableGeneratorFactory() {}
MessageGenerator* ImmutableGeneratorFactory::NewMessageGenerator(
diff --git a/src/google/protobuf/compiler/java/java_generator_factory.h b/src/google/protobuf/compiler/java/java_generator_factory.h
index 505cd3a..16688a5 100644
--- a/src/google/protobuf/compiler/java/java_generator_factory.h
+++ b/src/google/protobuf/compiler/java/java_generator_factory.h
@@ -37,17 +37,17 @@
namespace google {
namespace protobuf {
-class FieldDescriptor; // descriptor.h
-class Descriptor; // descriptor.h
-class ServiceDescriptor; // descriptor.h
+class FieldDescriptor; // descriptor.h
+class Descriptor; // descriptor.h
+class ServiceDescriptor; // descriptor.h
namespace compiler {
- namespace java {
- class MessageGenerator; // message.h
- class ExtensionGenerator; // extension.h
- class ServiceGenerator; // service.h
- class Context; // context.h
- }
-}
+namespace java {
+class MessageGenerator; // message.h
+class ExtensionGenerator; // extension.h
+class ServiceGenerator; // service.h
+class Context; // context.h
+} // namespace java
+} // namespace compiler
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/compiler/java/java_helpers.cc b/src/google/protobuf/compiler/java/java_helpers.cc
index 93b9294..6e52b1d 100644
--- a/src/google/protobuf/compiler/java/java_helpers.cc
+++ b/src/google/protobuf/compiler/java/java_helpers.cc
@@ -58,9 +58,9 @@
using internal::WireFormatLite;
const char kThickSeparator[] =
- "// ===================================================================\n";
+ "// ===================================================================\n";
const char kThinSeparator[] =
- "// -------------------------------------------------------------------\n";
+ "// -------------------------------------------------------------------\n";
namespace {
@@ -70,21 +70,26 @@
// Using them will cause the compiler to generate accessors whose names are
// colliding with methods defined in base classes.
const char* kForbiddenWordList[] = {
- // message base class:
- "cached_size", "serialized_size",
- // java.lang.Object:
- "class",
+ // message base class:
+ "cached_size",
+ "serialized_size",
+ // java.lang.Object:
+ "class",
};
-const std::unordered_set<string> kReservedNames = {
- "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char",
- "class", "const", "continue", "default", "do", "double", "else", "enum",
- "extends", "final", "finally", "float", "for", "goto", "if", "implements",
- "import", "instanceof", "int", "interface", "long", "native", "new", "package",
- "private", "protected", "public", "return", "short", "static", "strictfp", "super",
- "switch", "synchronized", "this", "throw", "throws", "transient", "try", "void",
- "volatile", "while",
-};
+const std::unordered_set<string>* kReservedNames =
+ new std::unordered_set<string>({
+ "abstract", "assert", "boolean", "break", "byte",
+ "case", "catch", "char", "class", "const",
+ "continue", "default", "do", "double", "else",
+ "enum", "extends", "final", "finally", "float",
+ "for", "goto", "if", "implements", "import",
+ "instanceof", "int", "interface", "long", "native",
+ "new", "package", "private", "protected", "public",
+ "return", "short", "static", "strictfp", "super",
+ "switch", "synchronized", "this", "throw", "throws",
+ "transient", "try", "void", "volatile", "while",
+ });
const int kDefaultLookUpStartFieldNumber = 40;
@@ -138,17 +143,16 @@
const char* var_name,
const char* terminating_string, bool enforce_lite) {
std::string enum_verifier_string =
- (descriptor->enum_type()->file()->options().optimize_for() ==
- FileOptions::LITE_RUNTIME) || enforce_lite
- ? StrCat(var_name, ".internalGetVerifier()")
- : StrCat(
- "new com.google.protobuf.Internal.EnumVerifier() {\n"
- " @java.lang.Override\n"
- " public boolean isInRange(int number) {\n"
- " return ", var_name, ".forNumber(number) != null;\n"
- " }\n"
- " }"
- );
+ enforce_lite ? StrCat(var_name, ".internalGetVerifier()")
+ : StrCat(
+ "new com.google.protobuf.Internal.EnumVerifier() {\n"
+ " @java.lang.Override\n"
+ " public boolean isInRange(int number) {\n"
+ " return ",
+ var_name,
+ ".forNumber(number) != null;\n"
+ " }\n"
+ " }");
printer->Print(
variables,
StrCat(enum_verifier_string, terminating_string).c_str());
@@ -208,7 +212,7 @@
std::string UnderscoresToCamelCaseCheckReserved(const FieldDescriptor* field) {
std::string name = UnderscoresToCamelCase(field);
- if (kReservedNames.find(name) != kReservedNames.end()) {
+ if (kReservedNames->find(name) != kReservedNames->end()) {
return name + "_";
}
return name;
@@ -376,8 +380,8 @@
case FieldDescriptor::TYPE_MESSAGE:
return JAVATYPE_MESSAGE;
- // No default because we want the compiler to complain if any new
- // types are added.
+ // No default because we want the compiler to complain if any new
+ // types are added.
}
GOOGLE_LOG(FATAL) << "Can't get here.";
@@ -386,18 +390,27 @@
const char* PrimitiveTypeName(JavaType type) {
switch (type) {
- case JAVATYPE_INT : return "int";
- case JAVATYPE_LONG : return "long";
- case JAVATYPE_FLOAT : return "float";
- case JAVATYPE_DOUBLE : return "double";
- case JAVATYPE_BOOLEAN: return "boolean";
- case JAVATYPE_STRING : return "java.lang.String";
- case JAVATYPE_BYTES : return "com.google.protobuf.ByteString";
- case JAVATYPE_ENUM : return NULL;
- case JAVATYPE_MESSAGE: return NULL;
+ case JAVATYPE_INT:
+ return "int";
+ case JAVATYPE_LONG:
+ return "long";
+ case JAVATYPE_FLOAT:
+ return "float";
+ case JAVATYPE_DOUBLE:
+ return "double";
+ case JAVATYPE_BOOLEAN:
+ return "boolean";
+ case JAVATYPE_STRING:
+ return "java.lang.String";
+ case JAVATYPE_BYTES:
+ return "com.google.protobuf.ByteString";
+ case JAVATYPE_ENUM:
+ return NULL;
+ case JAVATYPE_MESSAGE:
+ return NULL;
- // No default because we want the compiler to complain if any new
- // JavaTypes are added.
+ // No default because we want the compiler to complain if any new
+ // JavaTypes are added.
}
GOOGLE_LOG(FATAL) << "Can't get here.";
@@ -410,18 +423,27 @@
const char* BoxedPrimitiveTypeName(JavaType type) {
switch (type) {
- case JAVATYPE_INT : return "java.lang.Integer";
- case JAVATYPE_LONG : return "java.lang.Long";
- case JAVATYPE_FLOAT : return "java.lang.Float";
- case JAVATYPE_DOUBLE : return "java.lang.Double";
- case JAVATYPE_BOOLEAN: return "java.lang.Boolean";
- case JAVATYPE_STRING : return "java.lang.String";
- case JAVATYPE_BYTES : return "com.google.protobuf.ByteString";
- case JAVATYPE_ENUM : return NULL;
- case JAVATYPE_MESSAGE: return NULL;
+ case JAVATYPE_INT:
+ return "java.lang.Integer";
+ case JAVATYPE_LONG:
+ return "java.lang.Long";
+ case JAVATYPE_FLOAT:
+ return "java.lang.Float";
+ case JAVATYPE_DOUBLE:
+ return "java.lang.Double";
+ case JAVATYPE_BOOLEAN:
+ return "java.lang.Boolean";
+ case JAVATYPE_STRING:
+ return "java.lang.String";
+ case JAVATYPE_BYTES:
+ return "com.google.protobuf.ByteString";
+ case JAVATYPE_ENUM:
+ return NULL;
+ case JAVATYPE_MESSAGE:
+ return NULL;
- // No default because we want the compiler to complain if any new
- // JavaTypes are added.
+ // No default because we want the compiler to complain if any new
+ // JavaTypes are added.
}
GOOGLE_LOG(FATAL) << "Can't get here.";
@@ -432,30 +454,59 @@
return BoxedPrimitiveTypeName(GetJavaType(descriptor));
}
+std::string GetOneofStoredType(const FieldDescriptor* field) {
+ const JavaType javaType = GetJavaType(field);
+ switch (javaType) {
+ case JAVATYPE_ENUM:
+ return "java.lang.Integer";
+ case JAVATYPE_MESSAGE:
+ return ClassName(field->message_type());
+ default:
+ return BoxedPrimitiveTypeName(javaType);
+ }
+}
const char* FieldTypeName(FieldDescriptor::Type field_type) {
switch (field_type) {
- case FieldDescriptor::TYPE_INT32 : return "INT32";
- case FieldDescriptor::TYPE_UINT32 : return "UINT32";
- case FieldDescriptor::TYPE_SINT32 : return "SINT32";
- case FieldDescriptor::TYPE_FIXED32 : return "FIXED32";
- case FieldDescriptor::TYPE_SFIXED32: return "SFIXED32";
- case FieldDescriptor::TYPE_INT64 : return "INT64";
- case FieldDescriptor::TYPE_UINT64 : return "UINT64";
- case FieldDescriptor::TYPE_SINT64 : return "SINT64";
- case FieldDescriptor::TYPE_FIXED64 : return "FIXED64";
- case FieldDescriptor::TYPE_SFIXED64: return "SFIXED64";
- case FieldDescriptor::TYPE_FLOAT : return "FLOAT";
- case FieldDescriptor::TYPE_DOUBLE : return "DOUBLE";
- case FieldDescriptor::TYPE_BOOL : return "BOOL";
- case FieldDescriptor::TYPE_STRING : return "STRING";
- case FieldDescriptor::TYPE_BYTES : return "BYTES";
- case FieldDescriptor::TYPE_ENUM : return "ENUM";
- case FieldDescriptor::TYPE_GROUP : return "GROUP";
- case FieldDescriptor::TYPE_MESSAGE : return "MESSAGE";
+ case FieldDescriptor::TYPE_INT32:
+ return "INT32";
+ case FieldDescriptor::TYPE_UINT32:
+ return "UINT32";
+ case FieldDescriptor::TYPE_SINT32:
+ return "SINT32";
+ case FieldDescriptor::TYPE_FIXED32:
+ return "FIXED32";
+ case FieldDescriptor::TYPE_SFIXED32:
+ return "SFIXED32";
+ case FieldDescriptor::TYPE_INT64:
+ return "INT64";
+ case FieldDescriptor::TYPE_UINT64:
+ return "UINT64";
+ case FieldDescriptor::TYPE_SINT64:
+ return "SINT64";
+ case FieldDescriptor::TYPE_FIXED64:
+ return "FIXED64";
+ case FieldDescriptor::TYPE_SFIXED64:
+ return "SFIXED64";
+ case FieldDescriptor::TYPE_FLOAT:
+ return "FLOAT";
+ case FieldDescriptor::TYPE_DOUBLE:
+ return "DOUBLE";
+ case FieldDescriptor::TYPE_BOOL:
+ return "BOOL";
+ case FieldDescriptor::TYPE_STRING:
+ return "STRING";
+ case FieldDescriptor::TYPE_BYTES:
+ return "BYTES";
+ case FieldDescriptor::TYPE_ENUM:
+ return "ENUM";
+ case FieldDescriptor::TYPE_GROUP:
+ return "GROUP";
+ case FieldDescriptor::TYPE_MESSAGE:
+ return "MESSAGE";
- // No default because we want the compiler to complain if any new
- // types are added.
+ // No default because we want the compiler to complain if any new
+ // types are added.
}
GOOGLE_LOG(FATAL) << "Can't get here.";
@@ -517,8 +568,8 @@
if (field->has_default_value()) {
// See comments in Internal.java for gory details.
return strings::Substitute(
- "com.google.protobuf.Internal.bytesDefaultValue(\"$0\")",
- CEscape(field->default_value_string()));
+ "com.google.protobuf.Internal.bytesDefaultValue(\"$0\")",
+ CEscape(field->default_value_string()));
} else {
return "com.google.protobuf.ByteString.EMPTY";
}
@@ -536,14 +587,14 @@
case FieldDescriptor::CPPTYPE_ENUM:
return name_resolver->GetClassName(field->enum_type(), immutable) + "." +
- field->default_value_enum()->name();
+ field->default_value_enum()->name();
case FieldDescriptor::CPPTYPE_MESSAGE:
return name_resolver->GetClassName(field->message_type(), immutable) +
- ".getDefaultInstance()";
+ ".getDefaultInstance()";
- // No default because we want the compiler to complain if any new
- // types are added.
+ // No default because we want the compiler to complain if any new
+ // types are added.
}
GOOGLE_LOG(FATAL) << "Can't get here.";
@@ -574,8 +625,8 @@
case FieldDescriptor::CPPTYPE_MESSAGE:
return false;
- // No default because we want the compiler to complain if any new
- // types are added.
+ // No default because we want the compiler to complain if any new
+ // types are added.
}
GOOGLE_LOG(FATAL) << "Can't get here.";
@@ -588,41 +639,17 @@
}
const char* bit_masks[] = {
- "0x00000001",
- "0x00000002",
- "0x00000004",
- "0x00000008",
- "0x00000010",
- "0x00000020",
- "0x00000040",
- "0x00000080",
+ "0x00000001", "0x00000002", "0x00000004", "0x00000008",
+ "0x00000010", "0x00000020", "0x00000040", "0x00000080",
- "0x00000100",
- "0x00000200",
- "0x00000400",
- "0x00000800",
- "0x00001000",
- "0x00002000",
- "0x00004000",
- "0x00008000",
+ "0x00000100", "0x00000200", "0x00000400", "0x00000800",
+ "0x00001000", "0x00002000", "0x00004000", "0x00008000",
- "0x00010000",
- "0x00020000",
- "0x00040000",
- "0x00080000",
- "0x00100000",
- "0x00200000",
- "0x00400000",
- "0x00800000",
+ "0x00010000", "0x00020000", "0x00040000", "0x00080000",
+ "0x00100000", "0x00200000", "0x00400000", "0x00800000",
- "0x01000000",
- "0x02000000",
- "0x04000000",
- "0x08000000",
- "0x10000000",
- "0x20000000",
- "0x40000000",
- "0x80000000",
+ "0x01000000", "0x02000000", "0x04000000", "0x08000000",
+ "0x10000000", "0x20000000", "0x40000000", "0x80000000",
};
std::string GetBitFieldName(int index) {
@@ -693,18 +720,27 @@
bool IsReferenceType(JavaType type) {
switch (type) {
- case JAVATYPE_INT : return false;
- case JAVATYPE_LONG : return false;
- case JAVATYPE_FLOAT : return false;
- case JAVATYPE_DOUBLE : return false;
- case JAVATYPE_BOOLEAN: return false;
- case JAVATYPE_STRING : return true;
- case JAVATYPE_BYTES : return true;
- case JAVATYPE_ENUM : return true;
- case JAVATYPE_MESSAGE: return true;
+ case JAVATYPE_INT:
+ return false;
+ case JAVATYPE_LONG:
+ return false;
+ case JAVATYPE_FLOAT:
+ return false;
+ case JAVATYPE_DOUBLE:
+ return false;
+ case JAVATYPE_BOOLEAN:
+ return false;
+ case JAVATYPE_STRING:
+ return true;
+ case JAVATYPE_BYTES:
+ return true;
+ case JAVATYPE_ENUM:
+ return true;
+ case JAVATYPE_MESSAGE:
+ return true;
- // No default because we want the compiler to complain if any new
- // JavaTypes are added.
+ // No default because we want the compiler to complain if any new
+ // JavaTypes are added.
}
GOOGLE_LOG(FATAL) << "Can't get here.";
@@ -713,29 +749,46 @@
const char* GetCapitalizedType(const FieldDescriptor* field, bool immutable) {
switch (GetType(field)) {
- case FieldDescriptor::TYPE_INT32 : return "Int32";
- case FieldDescriptor::TYPE_UINT32 : return "UInt32";
- case FieldDescriptor::TYPE_SINT32 : return "SInt32";
- case FieldDescriptor::TYPE_FIXED32 : return "Fixed32";
- case FieldDescriptor::TYPE_SFIXED32: return "SFixed32";
- case FieldDescriptor::TYPE_INT64 : return "Int64";
- case FieldDescriptor::TYPE_UINT64 : return "UInt64";
- case FieldDescriptor::TYPE_SINT64 : return "SInt64";
- case FieldDescriptor::TYPE_FIXED64 : return "Fixed64";
- case FieldDescriptor::TYPE_SFIXED64: return "SFixed64";
- case FieldDescriptor::TYPE_FLOAT : return "Float";
- case FieldDescriptor::TYPE_DOUBLE : return "Double";
- case FieldDescriptor::TYPE_BOOL : return "Bool";
- case FieldDescriptor::TYPE_STRING : return "String";
- case FieldDescriptor::TYPE_BYTES : {
+ case FieldDescriptor::TYPE_INT32:
+ return "Int32";
+ case FieldDescriptor::TYPE_UINT32:
+ return "UInt32";
+ case FieldDescriptor::TYPE_SINT32:
+ return "SInt32";
+ case FieldDescriptor::TYPE_FIXED32:
+ return "Fixed32";
+ case FieldDescriptor::TYPE_SFIXED32:
+ return "SFixed32";
+ case FieldDescriptor::TYPE_INT64:
+ return "Int64";
+ case FieldDescriptor::TYPE_UINT64:
+ return "UInt64";
+ case FieldDescriptor::TYPE_SINT64:
+ return "SInt64";
+ case FieldDescriptor::TYPE_FIXED64:
+ return "Fixed64";
+ case FieldDescriptor::TYPE_SFIXED64:
+ return "SFixed64";
+ case FieldDescriptor::TYPE_FLOAT:
+ return "Float";
+ case FieldDescriptor::TYPE_DOUBLE:
+ return "Double";
+ case FieldDescriptor::TYPE_BOOL:
+ return "Bool";
+ case FieldDescriptor::TYPE_STRING:
+ return "String";
+ case FieldDescriptor::TYPE_BYTES: {
return "Bytes";
}
- case FieldDescriptor::TYPE_ENUM : return "Enum";
- case FieldDescriptor::TYPE_GROUP : return "Group";
- case FieldDescriptor::TYPE_MESSAGE : return "Message";
+ case FieldDescriptor::TYPE_ENUM:
+ return "Enum";
+ case FieldDescriptor::TYPE_GROUP:
+ return "Group";
+ case FieldDescriptor::TYPE_MESSAGE:
+ return "Message";
- // No default because we want the compiler to complain if any new
- // types are added.
+ // No default because we want the compiler to complain if any new
+ // types are added.
}
GOOGLE_LOG(FATAL) << "Can't get here.";
@@ -746,29 +799,47 @@
// returns -1.
int FixedSize(FieldDescriptor::Type type) {
switch (type) {
- case FieldDescriptor::TYPE_INT32 : return -1;
- case FieldDescriptor::TYPE_INT64 : return -1;
- case FieldDescriptor::TYPE_UINT32 : return -1;
- case FieldDescriptor::TYPE_UINT64 : return -1;
- case FieldDescriptor::TYPE_SINT32 : return -1;
- case FieldDescriptor::TYPE_SINT64 : return -1;
- case FieldDescriptor::TYPE_FIXED32 : return WireFormatLite::kFixed32Size;
- case FieldDescriptor::TYPE_FIXED64 : return WireFormatLite::kFixed64Size;
- case FieldDescriptor::TYPE_SFIXED32: return WireFormatLite::kSFixed32Size;
- case FieldDescriptor::TYPE_SFIXED64: return WireFormatLite::kSFixed64Size;
- case FieldDescriptor::TYPE_FLOAT : return WireFormatLite::kFloatSize;
- case FieldDescriptor::TYPE_DOUBLE : return WireFormatLite::kDoubleSize;
+ case FieldDescriptor::TYPE_INT32:
+ return -1;
+ case FieldDescriptor::TYPE_INT64:
+ return -1;
+ case FieldDescriptor::TYPE_UINT32:
+ return -1;
+ case FieldDescriptor::TYPE_UINT64:
+ return -1;
+ case FieldDescriptor::TYPE_SINT32:
+ return -1;
+ case FieldDescriptor::TYPE_SINT64:
+ return -1;
+ case FieldDescriptor::TYPE_FIXED32:
+ return WireFormatLite::kFixed32Size;
+ case FieldDescriptor::TYPE_FIXED64:
+ return WireFormatLite::kFixed64Size;
+ case FieldDescriptor::TYPE_SFIXED32:
+ return WireFormatLite::kSFixed32Size;
+ case FieldDescriptor::TYPE_SFIXED64:
+ return WireFormatLite::kSFixed64Size;
+ case FieldDescriptor::TYPE_FLOAT:
+ return WireFormatLite::kFloatSize;
+ case FieldDescriptor::TYPE_DOUBLE:
+ return WireFormatLite::kDoubleSize;
- case FieldDescriptor::TYPE_BOOL : return WireFormatLite::kBoolSize;
- case FieldDescriptor::TYPE_ENUM : return -1;
+ case FieldDescriptor::TYPE_BOOL:
+ return WireFormatLite::kBoolSize;
+ case FieldDescriptor::TYPE_ENUM:
+ return -1;
- case FieldDescriptor::TYPE_STRING : return -1;
- case FieldDescriptor::TYPE_BYTES : return -1;
- case FieldDescriptor::TYPE_GROUP : return -1;
- case FieldDescriptor::TYPE_MESSAGE : return -1;
+ case FieldDescriptor::TYPE_STRING:
+ return -1;
+ case FieldDescriptor::TYPE_BYTES:
+ return -1;
+ case FieldDescriptor::TYPE_GROUP:
+ return -1;
+ case FieldDescriptor::TYPE_MESSAGE:
+ return -1;
- // No default because we want the compiler to complain if any new
- // types are added.
+ // No default because we want the compiler to complain if any new
+ // types are added.
}
GOOGLE_LOG(FATAL) << "Can't get here.";
return -1;
@@ -778,7 +849,7 @@
// and return it. The caller should delete the returned array.
const FieldDescriptor** SortFieldsByNumber(const Descriptor* descriptor) {
const FieldDescriptor** fields =
- new const FieldDescriptor*[descriptor->field_count()];
+ new const FieldDescriptor*[descriptor->field_count()];
for (int i = 0; i < descriptor->field_count(); i++) {
fields[i] = descriptor->field(i);
}
diff --git a/src/google/protobuf/compiler/java/java_helpers.h b/src/google/protobuf/compiler/java/java_helpers.h
index 7bdd09f..3d36ec4 100644
--- a/src/google/protobuf/compiler/java/java_helpers.h
+++ b/src/google/protobuf/compiler/java/java_helpers.h
@@ -157,10 +157,14 @@
descriptor->file()->name() == "google/protobuf/descriptor.proto";
}
+// Returns the stored type string used by the experimental runtime for oneof
+// fields.
+std::string GetOneofStoredType(const FieldDescriptor* field);
+
// Whether we should generate multiple java files for messages.
-inline bool MultipleJavaFiles(
- const FileDescriptor* descriptor, bool immutable) {
+inline bool MultipleJavaFiles(const FileDescriptor* descriptor,
+ bool immutable) {
return descriptor->options().java_multiple_files();
}
@@ -245,24 +249,19 @@
// Does this message class have descriptor and reflection methods?
inline bool HasDescriptorMethods(const Descriptor* descriptor,
bool enforce_lite) {
- return !enforce_lite &&
- descriptor->file()->options().optimize_for() !=
- FileOptions::LITE_RUNTIME;
+ return !enforce_lite;
}
inline bool HasDescriptorMethods(const EnumDescriptor* descriptor,
bool enforce_lite) {
- return !enforce_lite &&
- descriptor->file()->options().optimize_for() !=
- FileOptions::LITE_RUNTIME;
+ return !enforce_lite;
}
inline bool HasDescriptorMethods(const FileDescriptor* descriptor,
bool enforce_lite) {
- return !enforce_lite &&
- descriptor->options().optimize_for() != FileOptions::LITE_RUNTIME;
+ return !enforce_lite;
}
// Should we generate generic services for this file?
-inline bool HasGenericServices(const FileDescriptor *file, bool enforce_lite) {
+inline bool HasGenericServices(const FileDescriptor* file, bool enforce_lite) {
return file->service_count() > 0 &&
HasDescriptorMethods(file, enforce_lite) &&
file->options().java_generic_services();
@@ -399,7 +398,7 @@
inline bool CheckUtf8(const FieldDescriptor* descriptor) {
return descriptor->file()->syntax() == FileDescriptor::SYNTAX_PROTO3 ||
- descriptor->file()->options().java_string_check_utf8();
+ descriptor->file()->options().java_string_check_utf8();
}
inline std::string GeneratedCodeVersionSuffix() {
diff --git a/src/google/protobuf/compiler/java/java_map_field.cc b/src/google/protobuf/compiler/java/java_map_field.cc
index a8b1074..5353745 100644
--- a/src/google/protobuf/compiler/java/java_map_field.cc
+++ b/src/google/protobuf/compiler/java/java_map_field.cc
@@ -96,10 +96,14 @@
boxed_key_type.substr(boxed_key_type.rfind('.') + 1);
(*variables)["key_wire_type"] = WireType(key);
(*variables)["key_default_value"] = DefaultValue(key, true, name_resolver);
- (*variables)["key_null_check"] = IsReferenceType(keyJavaType) ?
- "if (key == null) { throw new java.lang.NullPointerException(); }" : "";
- (*variables)["value_null_check"] = IsReferenceType(valueJavaType) ?
- "if (value == null) { throw new java.lang.NullPointerException(); }" : "";
+ (*variables)["key_null_check"] =
+ IsReferenceType(keyJavaType)
+ ? "if (key == null) { throw new java.lang.NullPointerException(); }"
+ : "";
+ (*variables)["value_null_check"] =
+ IsReferenceType(valueJavaType)
+ ? "if (value == null) { throw new java.lang.NullPointerException(); }"
+ : "";
if (valueJavaType == JAVATYPE_ENUM) {
// We store enums as Integers internally.
(*variables)["value_type"] = "int";
@@ -130,8 +134,8 @@
(*variables)["boxed_key_type"] + ", " + (*variables)["boxed_value_type"];
// TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
// by the proto compiler
- (*variables)["deprecation"] = descriptor->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ (*variables)["deprecation"] =
+ descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
(*variables)["on_changed"] = "onChanged();";
// For repeated fields, one bit is used for whether the array is immutable
@@ -141,62 +145,51 @@
(*variables)["set_mutable_bit_parser"] =
GenerateSetBitMutableLocal(builderBitIndex);
- (*variables)["default_entry"] = (*variables)["capitalized_name"] +
- "DefaultEntryHolder.defaultEntry";
+ (*variables)["default_entry"] =
+ (*variables)["capitalized_name"] + "DefaultEntryHolder.defaultEntry";
(*variables)["map_field_parameter"] = (*variables)["default_entry"];
(*variables)["descriptor"] =
- name_resolver->GetImmutableClassName(descriptor->file()) +
- ".internal_" + UniqueFileScopeIdentifier(descriptor->message_type()) +
- "_descriptor, ";
+ name_resolver->GetImmutableClassName(descriptor->file()) + ".internal_" +
+ UniqueFileScopeIdentifier(descriptor->message_type()) + "_descriptor, ";
(*variables)["ver"] = GeneratedCodeVersionSuffix();
}
} // namespace
-ImmutableMapFieldGenerator::
-ImmutableMapFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : descriptor_(descriptor), name_resolver_(context->GetNameResolver()) {
+ImmutableMapFieldGenerator::ImmutableMapFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : descriptor_(descriptor), name_resolver_(context->GetNameResolver()) {
SetMessageVariables(descriptor, messageBitIndex, builderBitIndex,
- context->GetFieldGeneratorInfo(descriptor),
- context, &variables_);
+ context->GetFieldGeneratorInfo(descriptor), context,
+ &variables_);
}
-ImmutableMapFieldGenerator::
-~ImmutableMapFieldGenerator() {}
+ImmutableMapFieldGenerator::~ImmutableMapFieldGenerator() {}
-int ImmutableMapFieldGenerator::GetNumBitsForMessage() const {
- return 0;
-}
+int ImmutableMapFieldGenerator::GetNumBitsForMessage() const { return 0; }
-int ImmutableMapFieldGenerator::GetNumBitsForBuilder() const {
- return 1;
-}
+int ImmutableMapFieldGenerator::GetNumBitsForBuilder() const { return 1; }
-void ImmutableMapFieldGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void ImmutableMapFieldGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$int ${$get$capitalized_name$Count$}$();\n");
+ printer->Print(variables_,
+ "$deprecation$int ${$get$capitalized_name$Count$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$boolean ${$contains$capitalized_name$$}$(\n"
- " $key_type$ key);\n");
+ printer->Print(variables_,
+ "$deprecation$boolean ${$contains$capitalized_name$$}$(\n"
+ " $key_type$ key);\n");
printer->Annotate("{", "}", descriptor_);
if (GetJavaType(ValueField(descriptor_)) == JAVATYPE_ENUM) {
- printer->Print(
- variables_,
- "/**\n"
- " * Use {@link #get$capitalized_name$Map()} instead.\n"
- " */\n"
- "@java.lang.Deprecated\n"
- "java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
- "${$get$capitalized_name$$}$();\n");
+ printer->Print(variables_,
+ "/**\n"
+ " * Use {@link #get$capitalized_name$Map()} instead.\n"
+ " */\n"
+ "@java.lang.Deprecated\n"
+ "java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
+ "${$get$capitalized_name$$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(
@@ -228,63 +221,55 @@
"${$get$capitalized_name$Value$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$java.util.Map<$type_parameters$>\n"
- "${$get$capitalized_name$ValueMap$}$();\n");
+ printer->Print(variables_,
+ "$deprecation$java.util.Map<$type_parameters$>\n"
+ "${$get$capitalized_name$ValueMap$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "$value_type$ ${$get$capitalized_name$ValueOrDefault$}$(\n"
- " $key_type$ key,\n"
- " $value_type$ defaultValue);\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "$value_type$ ${$get$capitalized_name$ValueOrDefault$}$(\n"
+ " $key_type$ key,\n"
+ " $value_type$ defaultValue);\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "$value_type$ ${$get$capitalized_name$ValueOrThrow$}$(\n"
- " $key_type$ key);\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "$value_type$ ${$get$capitalized_name$ValueOrThrow$}$(\n"
+ " $key_type$ key);\n");
printer->Annotate("{", "}", descriptor_);
}
} else {
- printer->Print(
- variables_,
- "/**\n"
- " * Use {@link #get$capitalized_name$Map()} instead.\n"
- " */\n"
- "@java.lang.Deprecated\n"
- "java.util.Map<$type_parameters$>\n"
- "${$get$capitalized_name$$}$();\n");
+ printer->Print(variables_,
+ "/**\n"
+ " * Use {@link #get$capitalized_name$Map()} instead.\n"
+ " */\n"
+ "@java.lang.Deprecated\n"
+ "java.util.Map<$type_parameters$>\n"
+ "${$get$capitalized_name$$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$java.util.Map<$type_parameters$>\n"
- "${$get$capitalized_name$Map$}$();\n");
+ printer->Print(variables_,
+ "$deprecation$java.util.Map<$type_parameters$>\n"
+ "${$get$capitalized_name$Map$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "$value_type$ ${$get$capitalized_name$OrDefault$}$(\n"
- " $key_type$ key,\n"
- " $value_type$ defaultValue);\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "$value_type$ ${$get$capitalized_name$OrDefault$}$(\n"
+ " $key_type$ key,\n"
+ " $value_type$ defaultValue);\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "$value_type$ ${$get$capitalized_name$OrThrow$}$(\n"
- " $key_type$ key);\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "$value_type$ ${$get$capitalized_name$OrThrow$}$(\n"
+ " $key_type$ key);\n");
printer->Annotate("{", "}", descriptor_);
}
}
-void ImmutableMapFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutableMapFieldGenerator::GenerateMembers(io::Printer* printer) const {
printer->Print(
variables_,
"private static final class $capitalized_name$DefaultEntryHolder {\n"
@@ -298,18 +283,17 @@
" $value_wire_type$,\n"
" $value_default_value$);\n"
"}\n");
- printer->Print(
- variables_,
- "private com.google.protobuf.MapField<\n"
- " $type_parameters$> $name$_;\n"
- "private com.google.protobuf.MapField<$type_parameters$>\n"
- "internalGet$capitalized_name$() {\n"
- " if ($name$_ == null) {\n"
- " return com.google.protobuf.MapField.emptyMapField(\n"
- " $map_field_parameter$);\n"
- " }\n"
- " return $name$_;\n"
- "}\n");
+ printer->Print(variables_,
+ "private com.google.protobuf.MapField<\n"
+ " $type_parameters$> $name$_;\n"
+ "private com.google.protobuf.MapField<$type_parameters$>\n"
+ "internalGet$capitalized_name$() {\n"
+ " if ($name$_ == null) {\n"
+ " return com.google.protobuf.MapField.emptyMapField(\n"
+ " $map_field_parameter$);\n"
+ " }\n"
+ " return $name$_;\n"
+ "}\n");
if (GetJavaType(ValueField(descriptor_)) == JAVATYPE_ENUM) {
printer->Print(
variables_,
@@ -333,53 +317,50 @@
GenerateMapGetters(printer);
}
-void ImmutableMapFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
- printer->Print(
- variables_,
- "private com.google.protobuf.MapField<\n"
- " $type_parameters$> $name$_;\n"
- "private com.google.protobuf.MapField<$type_parameters$>\n"
- "internalGet$capitalized_name$() {\n"
- " if ($name$_ == null) {\n"
- " return com.google.protobuf.MapField.emptyMapField(\n"
- " $map_field_parameter$);\n"
- " }\n"
- " return $name$_;\n"
- "}\n"
- "private com.google.protobuf.MapField<$type_parameters$>\n"
- "internalGetMutable$capitalized_name$() {\n"
- " $on_changed$;\n"
- " if ($name$_ == null) {\n"
- " $name$_ = com.google.protobuf.MapField.newMapField(\n"
- " $map_field_parameter$);\n"
- " }\n"
- " if (!$name$_.isMutable()) {\n"
- " $name$_ = $name$_.copy();\n"
- " }\n"
- " return $name$_;\n"
- "}\n");
+void ImmutableMapFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_,
+ "private com.google.protobuf.MapField<\n"
+ " $type_parameters$> $name$_;\n"
+ "private com.google.protobuf.MapField<$type_parameters$>\n"
+ "internalGet$capitalized_name$() {\n"
+ " if ($name$_ == null) {\n"
+ " return com.google.protobuf.MapField.emptyMapField(\n"
+ " $map_field_parameter$);\n"
+ " }\n"
+ " return $name$_;\n"
+ "}\n"
+ "private com.google.protobuf.MapField<$type_parameters$>\n"
+ "internalGetMutable$capitalized_name$() {\n"
+ " $on_changed$;\n"
+ " if ($name$_ == null) {\n"
+ " $name$_ = com.google.protobuf.MapField.newMapField(\n"
+ " $map_field_parameter$);\n"
+ " }\n"
+ " if (!$name$_.isMutable()) {\n"
+ " $name$_ = $name$_.copy();\n"
+ " }\n"
+ " return $name$_;\n"
+ "}\n");
GenerateMapGetters(printer);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "public Builder ${$clear$capitalized_name$$}$() {\n"
- " internalGetMutable$capitalized_name$().getMutableMap()\n"
- " .clear();\n"
- " return this;\n"
- "}\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "public Builder ${$clear$capitalized_name$$}$() {\n"
+ " internalGetMutable$capitalized_name$().getMutableMap()\n"
+ " .clear();\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "public Builder ${$remove$capitalized_name$$}$(\n"
- " $key_type$ key) {\n"
- " $key_null_check$\n"
- " internalGetMutable$capitalized_name$().getMutableMap()\n"
- " .remove(key);\n"
- " return this;\n"
- "}\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "public Builder ${$remove$capitalized_name$$}$(\n"
+ " $key_type$ key) {\n"
+ " $key_null_check$\n"
+ " internalGetMutable$capitalized_name$().getMutableMap()\n"
+ " .remove(key);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
if (GetJavaType(ValueField(descriptor_)) == JAVATYPE_ENUM) {
printer->Print(
@@ -465,41 +446,38 @@
"}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$"
- "public Builder ${$put$capitalized_name$$}$(\n"
- " $key_type$ key,\n"
- " $value_type$ value) {\n"
- " $key_null_check$\n"
- " $value_null_check$\n"
- " internalGetMutable$capitalized_name$().getMutableMap()\n"
- " .put(key, value);\n"
- " return this;\n"
- "}\n");
+ printer->Print(variables_,
+ "$deprecation$"
+ "public Builder ${$put$capitalized_name$$}$(\n"
+ " $key_type$ key,\n"
+ " $value_type$ value) {\n"
+ " $key_null_check$\n"
+ " $value_null_check$\n"
+ " internalGetMutable$capitalized_name$().getMutableMap()\n"
+ " .put(key, value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "public Builder ${$putAll$capitalized_name$$}$(\n"
- " java.util.Map<$type_parameters$> values) {\n"
- " internalGetMutable$capitalized_name$().getMutableMap()\n"
- " .putAll(values);\n"
- " return this;\n"
- "}\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "public Builder ${$putAll$capitalized_name$$}$(\n"
+ " java.util.Map<$type_parameters$> values) {\n"
+ " internalGetMutable$capitalized_name$().getMutableMap()\n"
+ " .putAll(values);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
}
-void ImmutableMapFieldGenerator::
-GenerateMapGetters(io::Printer* printer) const {
- printer->Print(
- variables_,
- "$deprecation$\n"
- "public int ${$get$capitalized_name$Count$}$() {\n"
- " return internalGet$capitalized_name$().getMap().size();\n"
- "}\n");
+void ImmutableMapFieldGenerator::GenerateMapGetters(
+ io::Printer* printer) const {
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "public int ${$get$capitalized_name$Count$}$() {\n"
+ " return internalGet$capitalized_name$().getMap().size();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(
@@ -512,26 +490,24 @@
"}\n");
printer->Annotate("{", "}", descriptor_);
if (GetJavaType(ValueField(descriptor_)) == JAVATYPE_ENUM) {
- printer->Print(
- variables_,
- "/**\n"
- " * Use {@link #get$capitalized_name$Map()} instead.\n"
- " */\n"
- "@java.lang.Deprecated\n"
- "public java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
- "${$get$capitalized_name$$}$() {\n"
- " return get$capitalized_name$Map();\n"
- "}\n");
+ printer->Print(variables_,
+ "/**\n"
+ " * Use {@link #get$capitalized_name$Map()} instead.\n"
+ " */\n"
+ "@java.lang.Deprecated\n"
+ "public java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
+ "${$get$capitalized_name$$}$() {\n"
+ " return get$capitalized_name$Map();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "public java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
- "${$get$capitalized_name$Map$}$() {\n"
- " return internalGetAdapted$capitalized_name$Map(\n"
- " internalGet$capitalized_name$().getMap());"
- "}\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "public java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
+ "${$get$capitalized_name$Map$}$() {\n"
+ " return internalGetAdapted$capitalized_name$Map(\n"
+ " internalGet$capitalized_name$().getMap());"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(
@@ -614,25 +590,23 @@
printer->Annotate("{", "}", descriptor_);
}
} else {
- printer->Print(
- variables_,
- "/**\n"
- " * Use {@link #get$capitalized_name$Map()} instead.\n"
- " */\n"
- "@java.lang.Deprecated\n"
- "public java.util.Map<$type_parameters$> "
- "${$get$capitalized_name$$}$() {\n"
- " return get$capitalized_name$Map();\n"
- "}\n");
+ printer->Print(variables_,
+ "/**\n"
+ " * Use {@link #get$capitalized_name$Map()} instead.\n"
+ " */\n"
+ "@java.lang.Deprecated\n"
+ "public java.util.Map<$type_parameters$> "
+ "${$get$capitalized_name$$}$() {\n"
+ " return get$capitalized_name$Map();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "public java.util.Map<$type_parameters$> "
- "${$get$capitalized_name$Map$}$() {\n"
- " return internalGet$capitalized_name$().getMap();\n"
- "}\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "public java.util.Map<$type_parameters$> "
+ "${$get$capitalized_name$Map$}$() {\n"
+ " return internalGet$capitalized_name$().getMap();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(
@@ -648,65 +622,60 @@
"}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "public $value_type$ ${$get$capitalized_name$OrThrow$}$(\n"
- " $key_type$ key) {\n"
- " $key_null_check$\n"
- " java.util.Map<$type_parameters$> map =\n"
- " internalGet$capitalized_name$().getMap();\n"
- " if (!map.containsKey(key)) {\n"
- " throw new java.lang.IllegalArgumentException();\n"
- " }\n"
- " return map.get(key);\n"
- "}\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "public $value_type$ ${$get$capitalized_name$OrThrow$}$(\n"
+ " $key_type$ key) {\n"
+ " $key_null_check$\n"
+ " java.util.Map<$type_parameters$> map =\n"
+ " internalGet$capitalized_name$().getMap();\n"
+ " if (!map.containsKey(key)) {\n"
+ " throw new java.lang.IllegalArgumentException();\n"
+ " }\n"
+ " return map.get(key);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
}
-void ImmutableMapFieldGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+void ImmutableMapFieldGenerator::GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const {
// Nothing to initialize.
}
-void ImmutableMapFieldGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void ImmutableMapFieldGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
// Nothing to initialize.
}
-void ImmutableMapFieldGenerator::
-GenerateBuilderClearCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "internalGetMutable$capitalized_name$().clear();\n");
+void ImmutableMapFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
+ printer->Print(variables_,
+ "internalGetMutable$capitalized_name$().clear();\n");
}
-void ImmutableMapFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "internalGetMutable$capitalized_name$().mergeFrom(\n"
- " other.internalGet$capitalized_name$());\n");
+void ImmutableMapFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
+ printer->Print(variables_,
+ "internalGetMutable$capitalized_name$().mergeFrom(\n"
+ " other.internalGet$capitalized_name$());\n");
}
-void ImmutableMapFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "result.$name$_ = internalGet$capitalized_name$();\n"
- "result.$name$_.makeImmutable();\n");
+void ImmutableMapFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
+ printer->Print(variables_,
+ "result.$name$_ = internalGet$capitalized_name$();\n"
+ "result.$name$_.makeImmutable();\n");
}
-void ImmutableMapFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = com.google.protobuf.MapField.newMapField(\n"
- " $map_field_parameter$);\n"
- " $set_mutable_bit_parser$;\n"
- "}\n");
+void ImmutableMapFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
+ printer->Print(variables_,
+ "if (!$get_mutable_bit_parser$) {\n"
+ " $name$_ = com.google.protobuf.MapField.newMapField(\n"
+ " $map_field_parameter$);\n"
+ " $set_mutable_bit_parser$;\n"
+ "}\n");
if (!SupportUnknownEnumValue(descriptor_->file()) &&
GetJavaType(ValueField(descriptor_)) == JAVATYPE_ENUM) {
printer->Print(
@@ -733,25 +702,24 @@
}
}
-void ImmutableMapFieldGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
+void ImmutableMapFieldGenerator::GenerateParsingDoneCode(
+ io::Printer* printer) const {
// Nothing to do here.
}
-void ImmutableMapFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "com.google.protobuf.GeneratedMessage$ver$\n"
- " .serialize$short_key_type$MapTo(\n"
- " output,\n"
- " internalGet$capitalized_name$(),\n"
- " $default_entry$,\n"
- " $number$);\n");
+void ImmutableMapFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
+ printer->Print(variables_,
+ "com.google.protobuf.GeneratedMessage$ver$\n"
+ " .serialize$short_key_type$MapTo(\n"
+ " output,\n"
+ " internalGet$capitalized_name$(),\n"
+ " $default_entry$,\n"
+ " $number$);\n");
}
-void ImmutableMapFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
+void ImmutableMapFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
printer->Print(
variables_,
"for (java.util.Map.Entry<$type_parameters$> entry\n"
@@ -766,16 +734,14 @@
"}\n");
}
-void ImmutableMapFieldGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "if (!internalGet$capitalized_name$().equals(\n"
- " other.internalGet$capitalized_name$())) return false;\n");
+void ImmutableMapFieldGenerator::GenerateEqualsCode(
+ io::Printer* printer) const {
+ printer->Print(variables_,
+ "if (!internalGet$capitalized_name$().equals(\n"
+ " other.internalGet$capitalized_name$())) return false;\n");
}
-void ImmutableMapFieldGenerator::
-GenerateHashCode(io::Printer* printer) const {
+void ImmutableMapFieldGenerator::GenerateHashCode(io::Printer* printer) const {
printer->Print(
variables_,
"if (!internalGet$capitalized_name$().getMap().isEmpty()) {\n"
diff --git a/src/google/protobuf/compiler/java/java_map_field.h b/src/google/protobuf/compiler/java/java_map_field.h
index b123b04..2ff1f76 100644
--- a/src/google/protobuf/compiler/java/java_map_field.h
+++ b/src/google/protobuf/compiler/java/java_map_field.h
@@ -40,9 +40,9 @@
class ImmutableMapFieldGenerator : public ImmutableFieldGenerator {
public:
- explicit ImmutableMapFieldGenerator(
- const FieldDescriptor* descriptor, int messageBitIndex,
- int builderBitIndex, Context* context);
+ explicit ImmutableMapFieldGenerator(const FieldDescriptor* descriptor,
+ int messageBitIndex, int builderBitIndex,
+ Context* context);
~ImmutableMapFieldGenerator();
// implements ImmutableFieldGenerator ---------------------------------------
diff --git a/src/google/protobuf/compiler/java/java_map_field_lite.cc b/src/google/protobuf/compiler/java/java_map_field_lite.cc
index c6ffa5b..9055774 100644
--- a/src/google/protobuf/compiler/java/java_map_field_lite.cc
+++ b/src/google/protobuf/compiler/java/java_map_field_lite.cc
@@ -92,10 +92,14 @@
(*variables)["boxed_key_type"] = TypeName(key, name_resolver, true);
(*variables)["key_wire_type"] = WireType(key);
(*variables)["key_default_value"] = DefaultValue(key, true, name_resolver);
- (*variables)["key_null_check"] = IsReferenceType(keyJavaType) ?
- "if (key == null) { throw new java.lang.NullPointerException(); }" : "";
- (*variables)["value_null_check"] = IsReferenceType(valueJavaType) ?
- "if (value == null) { throw new java.lang.NullPointerException(); }" : "";
+ (*variables)["key_null_check"] =
+ IsReferenceType(keyJavaType)
+ ? "if (key == null) { throw new java.lang.NullPointerException(); }"
+ : "";
+ (*variables)["value_null_check"] =
+ IsReferenceType(valueJavaType)
+ ? "if (value == null) { throw new java.lang.NullPointerException(); }"
+ : "";
if (GetJavaType(value) == JAVATYPE_ENUM) {
// We store enums as Integers internally.
@@ -127,55 +131,48 @@
(*variables)["boxed_key_type"] + ", " + (*variables)["boxed_value_type"];
// TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
// by the proto compiler
- (*variables)["deprecation"] = descriptor->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ (*variables)["deprecation"] =
+ descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
- (*variables)["default_entry"] = (*variables)["capitalized_name"] +
- "DefaultEntryHolder.defaultEntry";
+ (*variables)["default_entry"] =
+ (*variables)["capitalized_name"] + "DefaultEntryHolder.defaultEntry";
}
} // namespace
-ImmutableMapFieldLiteGenerator::
-ImmutableMapFieldLiteGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- Context* context)
- : descriptor_(descriptor), context_(context),
- name_resolver_(context->GetNameResolver()){
+ImmutableMapFieldLiteGenerator::ImmutableMapFieldLiteGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, Context* context)
+ : descriptor_(descriptor),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
SetMessageVariables(descriptor, messageBitIndex, 0,
context->GetFieldGeneratorInfo(descriptor), context,
&variables_);
}
-ImmutableMapFieldLiteGenerator::
-~ImmutableMapFieldLiteGenerator() {}
+ImmutableMapFieldLiteGenerator::~ImmutableMapFieldLiteGenerator() {}
-int ImmutableMapFieldLiteGenerator::GetNumBitsForMessage() const {
- return 0;
-}
+int ImmutableMapFieldLiteGenerator::GetNumBitsForMessage() const { return 0; }
-void ImmutableMapFieldLiteGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void ImmutableMapFieldLiteGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$int ${$get$capitalized_name$Count$}$();\n");
+ printer->Print(variables_,
+ "$deprecation$int ${$get$capitalized_name$Count$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$boolean ${$contains$capitalized_name$$}$(\n"
- " $key_type$ key);\n");
+ printer->Print(variables_,
+ "$deprecation$boolean ${$contains$capitalized_name$$}$(\n"
+ " $key_type$ key);\n");
printer->Annotate("{", "}", descriptor_);
if (GetJavaType(ValueField(descriptor_)) == JAVATYPE_ENUM) {
- printer->Print(
- variables_,
- "/**\n"
- " * Use {@link #get$capitalized_name$Map()} instead.\n"
- " */\n"
- "@java.lang.Deprecated\n"
- "java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
- "${$get$capitalized_name$$}$();\n");
+ printer->Print(variables_,
+ "/**\n"
+ " * Use {@link #get$capitalized_name$Map()} instead.\n"
+ " */\n"
+ "@java.lang.Deprecated\n"
+ "java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
+ "${$get$capitalized_name$$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(
@@ -207,63 +204,56 @@
"${$get$capitalized_name$Value$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$java.util.Map<$type_parameters$>\n"
- "${$get$capitalized_name$ValueMap$}$();\n");
+ printer->Print(variables_,
+ "$deprecation$java.util.Map<$type_parameters$>\n"
+ "${$get$capitalized_name$ValueMap$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "$value_type$ ${$get$capitalized_name$ValueOrDefault$}$(\n"
- " $key_type$ key,\n"
- " $value_type$ defaultValue);\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "$value_type$ ${$get$capitalized_name$ValueOrDefault$}$(\n"
+ " $key_type$ key,\n"
+ " $value_type$ defaultValue);\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "$value_type$ ${$get$capitalized_name$ValueOrThrow$}$(\n"
- " $key_type$ key);\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "$value_type$ ${$get$capitalized_name$ValueOrThrow$}$(\n"
+ " $key_type$ key);\n");
printer->Annotate("{", "}", descriptor_);
}
} else {
- printer->Print(
- variables_,
- "/**\n"
- " * Use {@link #get$capitalized_name$Map()} instead.\n"
- " */\n"
- "@java.lang.Deprecated\n"
- "java.util.Map<$type_parameters$>\n"
- "${$get$capitalized_name$$}$();\n");
+ printer->Print(variables_,
+ "/**\n"
+ " * Use {@link #get$capitalized_name$Map()} instead.\n"
+ " */\n"
+ "@java.lang.Deprecated\n"
+ "java.util.Map<$type_parameters$>\n"
+ "${$get$capitalized_name$$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$java.util.Map<$type_parameters$>\n"
- "${$get$capitalized_name$Map$}$();\n");
+ printer->Print(variables_,
+ "$deprecation$java.util.Map<$type_parameters$>\n"
+ "${$get$capitalized_name$Map$}$();\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "$value_type$ ${$get$capitalized_name$OrDefault$}$(\n"
- " $key_type$ key,\n"
- " $value_type$ defaultValue);\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "$value_type$ ${$get$capitalized_name$OrDefault$}$(\n"
+ " $key_type$ key,\n"
+ " $value_type$ defaultValue);\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "$value_type$ ${$get$capitalized_name$OrThrow$}$(\n"
- " $key_type$ key);\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "$value_type$ ${$get$capitalized_name$OrThrow$}$(\n"
+ " $key_type$ key);\n");
printer->Annotate("{", "}", descriptor_);
}
}
-void ImmutableMapFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutableMapFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
printer->Print(
variables_,
"private static final class $capitalized_name$DefaultEntryHolder {\n"
@@ -276,40 +266,37 @@
" $value_wire_type$,\n"
" $value_default_value$);\n"
"}\n");
- printer->Print(
- variables_,
- "private com.google.protobuf.MapFieldLite<\n"
- " $type_parameters$> $name$_ =\n"
- " com.google.protobuf.MapFieldLite.emptyMapField();\n"
- "private com.google.protobuf.MapFieldLite<$type_parameters$>\n"
- "internalGet$capitalized_name$() {\n"
- " return $name$_;\n"
- "}\n"
- "private com.google.protobuf.MapFieldLite<$type_parameters$>\n"
- "internalGetMutable$capitalized_name$() {\n"
- " if (!$name$_.isMutable()) {\n"
- " $name$_ = $name$_.mutableCopy();\n"
- " }\n"
- " return $name$_;\n"
- "}\n");
- printer->Print(
- variables_,
- "@java.lang.Override\n"
- "$deprecation$\n"
- "public int ${$get$capitalized_name$Count$}$() {\n"
- " return internalGet$capitalized_name$().size();\n"
- "}\n");
+ printer->Print(variables_,
+ "private com.google.protobuf.MapFieldLite<\n"
+ " $type_parameters$> $name$_ =\n"
+ " com.google.protobuf.MapFieldLite.emptyMapField();\n"
+ "private com.google.protobuf.MapFieldLite<$type_parameters$>\n"
+ "internalGet$capitalized_name$() {\n"
+ " return $name$_;\n"
+ "}\n"
+ "private com.google.protobuf.MapFieldLite<$type_parameters$>\n"
+ "internalGetMutable$capitalized_name$() {\n"
+ " if (!$name$_.isMutable()) {\n"
+ " $name$_ = $name$_.mutableCopy();\n"
+ " }\n"
+ " return $name$_;\n"
+ "}\n");
+ printer->Print(variables_,
+ "@java.lang.Override\n"
+ "$deprecation$\n"
+ "public int ${$get$capitalized_name$Count$}$() {\n"
+ " return internalGet$capitalized_name$().size();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "@java.lang.Override\n"
- "$deprecation$\n"
- "public boolean ${$contains$capitalized_name$$}$(\n"
- " $key_type$ key) {\n"
- " $key_null_check$\n"
- " return internalGet$capitalized_name$().containsKey(key);\n"
- "}\n");
+ printer->Print(variables_,
+ "@java.lang.Override\n"
+ "$deprecation$\n"
+ "public boolean ${$contains$capitalized_name$$}$(\n"
+ " $key_type$ key) {\n"
+ " $key_null_check$\n"
+ " return internalGet$capitalized_name$().containsKey(key);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
if (GetJavaType(ValueField(descriptor_)) == JAVATYPE_ENUM) {
printer->Print(
@@ -320,16 +307,15 @@
" com.google.protobuf.Internal.MapAdapter.newEnumConverter(\n"
" $value_enum_type$.internalGetValueMap(),\n"
" $unrecognized_value$);\n");
- printer->Print(
- variables_,
- "/**\n"
- " * Use {@link #get$capitalized_name$Map()} instead.\n"
- " */\n"
- "@java.lang.Deprecated\n"
- "public java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
- "${$get$capitalized_name$$}$() {\n"
- " return get$capitalized_name$Map();\n"
- "}\n");
+ printer->Print(variables_,
+ "/**\n"
+ " * Use {@link #get$capitalized_name$Map()} instead.\n"
+ " */\n"
+ "@java.lang.Deprecated\n"
+ "public java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
+ "${$get$capitalized_name$$}$() {\n"
+ " return get$capitalized_name$Map();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(
@@ -433,28 +419,26 @@
printer->Annotate("{", "}", descriptor_);
}
} else {
- printer->Print(
- variables_,
- "/**\n"
- " * Use {@link #get$capitalized_name$Map()} instead.\n"
- " */\n"
- "@java.lang.Override\n"
- "@java.lang.Deprecated\n"
- "public java.util.Map<$type_parameters$> "
- "${$get$capitalized_name$$}$() {\n"
- " return get$capitalized_name$Map();\n"
- "}\n");
+ printer->Print(variables_,
+ "/**\n"
+ " * Use {@link #get$capitalized_name$Map()} instead.\n"
+ " */\n"
+ "@java.lang.Override\n"
+ "@java.lang.Deprecated\n"
+ "public java.util.Map<$type_parameters$> "
+ "${$get$capitalized_name$$}$() {\n"
+ " return get$capitalized_name$Map();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "@java.lang.Override\n"
- "$deprecation$\n"
- "public java.util.Map<$type_parameters$> "
- "${$get$capitalized_name$Map$}$() {\n"
- " return java.util.Collections.unmodifiableMap(\n"
- " internalGet$capitalized_name$());\n"
- "}\n");
+ printer->Print(variables_,
+ "@java.lang.Override\n"
+ "$deprecation$\n"
+ "public java.util.Map<$type_parameters$> "
+ "${$get$capitalized_name$Map$}$() {\n"
+ " return java.util.Collections.unmodifiableMap(\n"
+ " internalGet$capitalized_name$());\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(
@@ -471,20 +455,19 @@
"}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "@java.lang.Override\n"
- "$deprecation$\n"
- "public $value_type$ ${$get$capitalized_name$OrThrow$}$(\n"
- " $key_type$ key) {\n"
- " $key_null_check$\n"
- " java.util.Map<$type_parameters$> map =\n"
- " internalGet$capitalized_name$();\n"
- " if (!map.containsKey(key)) {\n"
- " throw new java.lang.IllegalArgumentException();\n"
- " }\n"
- " return map.get(key);\n"
- "}\n");
+ printer->Print(variables_,
+ "@java.lang.Override\n"
+ "$deprecation$\n"
+ "public $value_type$ ${$get$capitalized_name$OrThrow$}$(\n"
+ " $key_type$ key) {\n"
+ " $key_null_check$\n"
+ " java.util.Map<$type_parameters$> map =\n"
+ " internalGet$capitalized_name$();\n"
+ " if (!map.containsKey(key)) {\n"
+ " throw new java.lang.IllegalArgumentException();\n"
+ " }\n"
+ " return map.get(key);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
@@ -511,25 +494,39 @@
}
} else {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "private java.util.Map<$type_parameters$>\n"
- "getMutable$capitalized_name$Map() {\n"
- " return internalGetMutable$capitalized_name$();\n"
- "}\n");
+ printer->Print(variables_,
+ "private java.util.Map<$type_parameters$>\n"
+ "getMutable$capitalized_name$Map() {\n"
+ " return internalGetMutable$capitalized_name$();\n"
+ "}\n");
}
}
+void ImmutableMapFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
+ printer->Print(variables_,
+ "\"$name$_\",\n"
+ "$default_entry$,\n");
+ if (SupportFieldPresence(descriptor_->file()) &&
+ GetJavaType(ValueField(descriptor_)) == JAVATYPE_ENUM) {
+ PrintEnumVerifierLogic(printer, ValueField(descriptor_), variables_,
+ /*var_name=*/"$value_enum_type$",
+ /*terminating_string=*/",\n",
+ /*enforce_lite=*/context_->EnforceLite());
+ }
+}
-void ImmutableMapFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
- printer->Print(
- variables_,
- "@java.lang.Override\n"
- "$deprecation$\n"
- "public int ${$get$capitalized_name$Count$}$() {\n"
- " return instance.get$capitalized_name$Map().size();\n"
- "}\n");
+void ImmutableMapFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_,
+ "@java.lang.Override\n"
+ "$deprecation$\n"
+ "public int ${$get$capitalized_name$Count$}$() {\n"
+ " return instance.get$capitalized_name$Map().size();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(
@@ -542,49 +539,45 @@
" return instance.get$capitalized_name$Map().containsKey(key);\n"
"}\n");
printer->Annotate("{", "}", descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.getMutable$capitalized_name$Map().clear();\n"
- " return this;\n"
- "}\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "public Builder ${$clear$capitalized_name$$}$() {\n"
+ " copyOnWrite();\n"
+ " instance.getMutable$capitalized_name$Map().clear();\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "$deprecation$\n"
- "public Builder ${$remove$capitalized_name$$}$(\n"
- " $key_type$ key) {\n"
- " $key_null_check$\n"
- " copyOnWrite();\n"
- " instance.getMutable$capitalized_name$Map().remove(key);\n"
- " return this;\n"
- "}\n");
+ printer->Print(variables_,
+ "$deprecation$\n"
+ "public Builder ${$remove$capitalized_name$$}$(\n"
+ " $key_type$ key) {\n"
+ " $key_null_check$\n"
+ " copyOnWrite();\n"
+ " instance.getMutable$capitalized_name$Map().remove(key);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
if (GetJavaType(ValueField(descriptor_)) == JAVATYPE_ENUM) {
- printer->Print(
- variables_,
- "/**\n"
- " * Use {@link #get$capitalized_name$Map()} instead.\n"
- " */\n"
- "@java.lang.Deprecated\n"
- "public java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
- "${$get$capitalized_name$$}$() {\n"
- " return get$capitalized_name$Map();\n"
- "}\n");
+ printer->Print(variables_,
+ "/**\n"
+ " * Use {@link #get$capitalized_name$Map()} instead.\n"
+ " */\n"
+ "@java.lang.Deprecated\n"
+ "public java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
+ "${$get$capitalized_name$$}$() {\n"
+ " return get$capitalized_name$Map();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "@java.lang.Override\n"
- "$deprecation$\n"
- "public java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
- "${$get$capitalized_name$Map$}$() {\n"
- " return java.util.Collections.unmodifiableMap(\n"
- " instance.get$capitalized_name$Map());\n"
- "}\n");
+ printer->Print(variables_,
+ "@java.lang.Override\n"
+ "$deprecation$\n"
+ "public java.util.Map<$boxed_key_type$, $value_enum_type$>\n"
+ "${$get$capitalized_name$Map$}$() {\n"
+ " return java.util.Collections.unmodifiableMap(\n"
+ " instance.get$capitalized_name$Map());\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(
@@ -719,28 +712,26 @@
printer->Annotate("{", "}", descriptor_);
}
} else {
- printer->Print(
- variables_,
- "/**\n"
- " * Use {@link #get$capitalized_name$Map()} instead.\n"
- " */\n"
- "@java.lang.Override\n"
- "@java.lang.Deprecated\n"
- "public java.util.Map<$type_parameters$> "
- "${$get$capitalized_name$$}$() {\n"
- " return get$capitalized_name$Map();\n"
- "}\n");
+ printer->Print(variables_,
+ "/**\n"
+ " * Use {@link #get$capitalized_name$Map()} instead.\n"
+ " */\n"
+ "@java.lang.Override\n"
+ "@java.lang.Deprecated\n"
+ "public java.util.Map<$type_parameters$> "
+ "${$get$capitalized_name$$}$() {\n"
+ " return get$capitalized_name$Map();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "@java.lang.Override\n"
- "$deprecation$"
- "public java.util.Map<$type_parameters$> "
- "${$get$capitalized_name$Map$}$() {\n"
- " return java.util.Collections.unmodifiableMap(\n"
- " instance.get$capitalized_name$Map());\n"
- "}\n");
+ printer->Print(variables_,
+ "@java.lang.Override\n"
+ "$deprecation$"
+ "public java.util.Map<$type_parameters$> "
+ "${$get$capitalized_name$Map$}$() {\n"
+ " return java.util.Collections.unmodifiableMap(\n"
+ " instance.get$capitalized_name$Map());\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(
@@ -757,20 +748,19 @@
"}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(
- variables_,
- "@java.lang.Override\n"
- "$deprecation$\n"
- "public $value_type$ ${$get$capitalized_name$OrThrow$}$(\n"
- " $key_type$ key) {\n"
- " $key_null_check$\n"
- " java.util.Map<$type_parameters$> map =\n"
- " instance.get$capitalized_name$Map();\n"
- " if (!map.containsKey(key)) {\n"
- " throw new java.lang.IllegalArgumentException();\n"
- " }\n"
- " return map.get(key);\n"
- "}\n");
+ printer->Print(variables_,
+ "@java.lang.Override\n"
+ "$deprecation$\n"
+ "public $value_type$ ${$get$capitalized_name$OrThrow$}$(\n"
+ " $key_type$ key) {\n"
+ " $key_null_check$\n"
+ " java.util.Map<$type_parameters$> map =\n"
+ " instance.get$capitalized_name$Map();\n"
+ " if (!map.containsKey(key)) {\n"
+ " throw new java.lang.IllegalArgumentException();\n"
+ " }\n"
+ " return map.get(key);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(
@@ -800,103 +790,11 @@
}
}
-void ImmutableMapFieldLiteGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+void ImmutableMapFieldLiteGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
// Nothing to initialize.
}
-void ImmutableMapFieldLiteGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
- // Nothing to initialize.
-}
-
-void ImmutableMapFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "$name$_ = visitor.visitMap(\n"
- " $name$_, other.internalGet$capitalized_name$());\n");
-}
-
-void ImmutableMapFieldLiteGenerator::
-GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$name$_.makeImmutable();\n");
-}
-
-void ImmutableMapFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "if (!$name$_.isMutable()) {\n"
- " $name$_ = $name$_.mutableCopy();\n"
- "}\n");
- if (!SupportUnknownEnumValue(descriptor_->file()) &&
- GetJavaType(ValueField(descriptor_)) == JAVATYPE_ENUM) {
- printer->Print(
- variables_,
- "com.google.protobuf.ByteString bytes = input.readBytes();\n"
- "java.util.Map.Entry<$type_parameters$> $name$__ =\n"
- " $default_entry$.parseEntry(bytes, extensionRegistry);\n");
- printer->Print(
- variables_,
- "if ($value_enum_type$.forNumber($name$__.getValue()) == null) {\n"
- " super.mergeLengthDelimitedField($number$, bytes);\n"
- "} else {\n"
- " $name$_.put($name$__);\n"
- "}\n");
- } else {
- printer->Print(
- variables_,
- "$default_entry$.parseInto($name$_, input, extensionRegistry);");
- }
-}
-
-void ImmutableMapFieldLiteGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- // Nothing to do here.
-}
-
-void ImmutableMapFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "for (java.util.Map.Entry<$type_parameters$> entry\n"
- " : internalGet$capitalized_name$().entrySet()) {\n"
- " $default_entry$.serializeTo(\n"
- " output, $number$, entry.getKey(), entry.getValue());\n"
- "}\n");
-}
-
-void ImmutableMapFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "for (java.util.Map.Entry<$type_parameters$> entry\n"
- " : internalGet$capitalized_name$().entrySet()) {\n"
- " size += $default_entry$.computeMessageSize(\n"
- " $number$, entry.getKey(), entry.getValue());\n"
- "}\n");
-}
-
-void ImmutableMapFieldLiteGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "result = result && internalGet$capitalized_name$().equals(\n"
- " other.internalGet$capitalized_name$());\n");
-}
-
-void ImmutableMapFieldLiteGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(
- variables_,
- "if (!internalGet$capitalized_name$().isEmpty()) {\n"
- " hash = (37 * hash) + $constant_name$;\n"
- " hash = (53 * hash) + internalGet$capitalized_name$().hashCode();\n"
- "}\n");
-}
-
std::string ImmutableMapFieldLiteGenerator::GetBoxedType() const {
return name_resolver_->GetImmutableClassName(descriptor_->message_type());
}
diff --git a/src/google/protobuf/compiler/java/java_map_field_lite.h b/src/google/protobuf/compiler/java/java_map_field_lite.h
index df5fe64..49cbf6c 100644
--- a/src/google/protobuf/compiler/java/java_map_field_lite.h
+++ b/src/google/protobuf/compiler/java/java_map_field_lite.h
@@ -51,16 +51,8 @@
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
std::string GetBoxedType() const;
diff --git a/src/google/protobuf/compiler/java/java_message.cc b/src/google/protobuf/compiler/java/java_message.cc
index 39b5d7c..5bbdcce 100644
--- a/src/google/protobuf/compiler/java/java_message.cc
+++ b/src/google/protobuf/compiler/java/java_message.cc
@@ -77,16 +77,17 @@
// ===================================================================
MessageGenerator::MessageGenerator(const Descriptor* descriptor)
- : descriptor_(descriptor) {}
+ : descriptor_(descriptor) {}
MessageGenerator::~MessageGenerator() {}
// ===================================================================
ImmutableMessageGenerator::ImmutableMessageGenerator(
const Descriptor* descriptor, Context* context)
- : MessageGenerator(descriptor), context_(context),
- name_resolver_(context->GetNameResolver()),
- field_generators_(descriptor, context_) {
+ : MessageGenerator(descriptor),
+ context_(context),
+ name_resolver_(context->GetNameResolver()),
+ field_generators_(descriptor, context_) {
GOOGLE_CHECK(HasDescriptorMethods(descriptor->file(), context->EnforceLite()))
<< "Generator factory error: A non-lite message generator is used to "
"generate lite messages.";
@@ -108,8 +109,7 @@
vars["index"] = StrCat(descriptor_->index());
vars["classname"] = name_resolver_->GetImmutableClassName(descriptor_);
if (descriptor_->containing_type() != NULL) {
- vars["parent"] = UniqueFileScopeIdentifier(
- descriptor_->containing_type());
+ vars["parent"] = UniqueFileScopeIdentifier(descriptor_->containing_type());
}
if (MultipleJavaFiles(descriptor_->file(), /* immutable = */ true)) {
// We can only make these package-private since the classes that use them
@@ -125,12 +125,13 @@
}
// The descriptor for this type.
- printer->Print(vars,
- // TODO(teboring): final needs to be added back. The way to fix it is to
- // generate methods that can construct the types, and then still declare the
- // types, and then init them in clinit with the new method calls.
- "$private$static $final$com.google.protobuf.Descriptors.Descriptor\n"
- " internal_$identifier$_descriptor;\n");
+ printer->Print(
+ vars,
+ // TODO(teboring): final needs to be added back. The way to fix it is to
+ // generate methods that can construct the types, and then still declare
+ // the types, and then init them in clinit with the new method calls.
+ "$private$static $final$com.google.protobuf.Descriptors.Descriptor\n"
+ " internal_$identifier$_descriptor;\n");
*bytecode_estimate += 30;
// And the FieldAccessorTable.
@@ -152,20 +153,20 @@
vars["index"] = StrCat(descriptor_->index());
vars["classname"] = name_resolver_->GetImmutableClassName(descriptor_);
if (descriptor_->containing_type() != NULL) {
- vars["parent"] = UniqueFileScopeIdentifier(
- descriptor_->containing_type());
+ vars["parent"] = UniqueFileScopeIdentifier(descriptor_->containing_type());
}
// The descriptor for this type.
if (descriptor_->containing_type() == NULL) {
printer->Print(vars,
- "internal_$identifier$_descriptor =\n"
- " getDescriptor().getMessageTypes().get($index$);\n");
+ "internal_$identifier$_descriptor =\n"
+ " getDescriptor().getMessageTypes().get($index$);\n");
bytecode_estimate += 30;
} else {
- printer->Print(vars,
- "internal_$identifier$_descriptor =\n"
- " internal_$parent$_descriptor.getNestedTypes().get($index$);\n");
+ printer->Print(
+ vars,
+ "internal_$identifier$_descriptor =\n"
+ " internal_$parent$_descriptor.getNestedTypes().get($index$);\n");
bytecode_estimate += 30;
}
@@ -182,8 +183,8 @@
return bytecode_estimate;
}
-void ImmutableMessageGenerator::
-GenerateFieldAccessorTable(io::Printer* printer, int* bytecode_estimate) {
+void ImmutableMessageGenerator::GenerateFieldAccessorTable(
+ io::Printer* printer, int* bytecode_estimate) {
std::map<std::string, std::string> vars;
vars["identifier"] = UniqueFileScopeIdentifier(descriptor_);
if (MultipleJavaFiles(descriptor_->file(), /* immutable = */ true)) {
@@ -199,41 +200,38 @@
vars["final"] = "";
}
vars["ver"] = GeneratedCodeVersionSuffix();
- printer->Print(vars,
- "$private$static $final$\n"
- " com.google.protobuf.GeneratedMessage$ver$.FieldAccessorTable\n"
- " internal_$identifier$_fieldAccessorTable;\n");
+ printer->Print(
+ vars,
+ "$private$static $final$\n"
+ " com.google.protobuf.GeneratedMessage$ver$.FieldAccessorTable\n"
+ " internal_$identifier$_fieldAccessorTable;\n");
// 6 bytes per field and oneof
- *bytecode_estimate += 10 + 6 * descriptor_->field_count()
- + 6 * descriptor_->oneof_decl_count();
+ *bytecode_estimate +=
+ 10 + 6 * descriptor_->field_count() + 6 * descriptor_->oneof_decl_count();
}
-int ImmutableMessageGenerator::
-GenerateFieldAccessorTableInitializer(io::Printer* printer) {
+int ImmutableMessageGenerator::GenerateFieldAccessorTableInitializer(
+ io::Printer* printer) {
int bytecode_estimate = 10;
printer->Print(
- "internal_$identifier$_fieldAccessorTable = new\n"
- " com.google.protobuf.GeneratedMessage$ver$.FieldAccessorTable(\n"
- " internal_$identifier$_descriptor,\n"
- " new java.lang.String[] { ",
- "identifier", UniqueFileScopeIdentifier(descriptor_),
- "ver", GeneratedCodeVersionSuffix());
+ "internal_$identifier$_fieldAccessorTable = new\n"
+ " com.google.protobuf.GeneratedMessage$ver$.FieldAccessorTable(\n"
+ " internal_$identifier$_descriptor,\n"
+ " new java.lang.String[] { ",
+ "identifier", UniqueFileScopeIdentifier(descriptor_), "ver",
+ GeneratedCodeVersionSuffix());
for (int i = 0; i < descriptor_->field_count(); i++) {
const FieldDescriptor* field = descriptor_->field(i);
const FieldGeneratorInfo* info = context_->GetFieldGeneratorInfo(field);
bytecode_estimate += 6;
- printer->Print(
- "\"$field_name$\", ",
- "field_name", info->capitalized_name);
+ printer->Print("\"$field_name$\", ", "field_name", info->capitalized_name);
}
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
const OneofDescriptor* oneof = descriptor_->oneof_decl(i);
const OneofGeneratorInfo* info = context_->GetOneofGeneratorInfo(oneof);
bytecode_estimate += 6;
- printer->Print(
- "\"$oneof_name$\", ",
- "oneof_name", info->capitalized_name);
+ printer->Print("\"$oneof_name$\", ", "oneof_name", info->capitalized_name);
}
printer->Print("});\n");
return bytecode_estimate;
@@ -250,42 +248,40 @@
" $extra_interfaces$\n"
" com.google.protobuf.GeneratedMessage$ver$.\n"
" ExtendableMessageOrBuilder<$classname$> {\n",
- "deprecation", descriptor_->options().deprecated() ?
- "@java.lang.Deprecated " : "",
+ "deprecation",
+ descriptor_->options().deprecated() ? "@java.lang.Deprecated " : "",
"extra_interfaces", ExtraMessageOrBuilderInterfaces(descriptor_),
- "classname", descriptor_->name(),
- "{", "", "}", "", "ver", GeneratedCodeVersionSuffix());
+ "classname", descriptor_->name(), "{", "", "}", "", "ver",
+ GeneratedCodeVersionSuffix());
} else {
printer->Print(
"$deprecation$public interface ${$$classname$OrBuilder$}$ extends\n"
" $extra_interfaces$\n"
" com.google.protobuf.MessageOrBuilder {\n",
- "deprecation", descriptor_->options().deprecated() ?
- "@java.lang.Deprecated " : "",
+ "deprecation",
+ descriptor_->options().deprecated() ? "@java.lang.Deprecated " : "",
"extra_interfaces", ExtraMessageOrBuilderInterfaces(descriptor_),
- "classname", descriptor_->name(),
- "{", "", "}", "");
+ "classname", descriptor_->name(), "{", "", "}", "");
}
printer->Annotate("{", "}", descriptor_);
printer->Indent();
- for (int i = 0; i < descriptor_->field_count(); i++) {
- printer->Print("\n");
- field_generators_.get(descriptor_->field(i))
- .GenerateInterfaceMembers(printer);
- }
- for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
- printer->Print(
- "\n"
- "public $classname$.$oneof_capitalized_name$Case "
- "get$oneof_capitalized_name$Case();\n",
- "oneof_capitalized_name",
- context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->capitalized_name,
- "classname",
- context_->GetNameResolver()->GetImmutableClassName(
- descriptor_));
- }
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ printer->Print("\n");
+ field_generators_.get(descriptor_->field(i))
+ .GenerateInterfaceMembers(printer);
+ }
+ for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
+ printer->Print(
+ "\n"
+ "public $classname$.$oneof_capitalized_name$Case "
+ "get$oneof_capitalized_name$Case();\n",
+ "oneof_capitalized_name",
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))
+ ->capitalized_name,
+ "classname",
+ context_->GetNameResolver()->GetImmutableClassName(descriptor_));
+ }
printer->Outdent();
printer->Print("}\n");
@@ -301,8 +297,8 @@
variables["classname"] = descriptor_->name();
variables["extra_interfaces"] = ExtraMessageInterfaces(descriptor_);
variables["ver"] = GeneratedCodeVersionSuffix();
- variables["deprecation"] = descriptor_->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ variables["deprecation"] =
+ descriptor_->options().deprecated() ? "@java.lang.Deprecated " : "";
WriteMessageDocComment(printer, descriptor_);
MaybePrintGeneratedAnnotation(context_, printer, descriptor_,
@@ -331,15 +327,14 @@
"$deprecation$public $static$final class $classname$ extends\n");
printer->Annotate("classname", descriptor_);
printer->Print(variables,
- " com.google.protobuf.GeneratedMessage$ver$ implements\n"
- " $extra_interfaces$\n"
- " $classname$OrBuilder {\n");
- builder_type = strings::Substitute(
- "com.google.protobuf.GeneratedMessage$0.Builder<?>",
- GeneratedCodeVersionSuffix());
+ " com.google.protobuf.GeneratedMessage$ver$ implements\n"
+ " $extra_interfaces$\n"
+ " $classname$OrBuilder {\n");
+ builder_type =
+ strings::Substitute("com.google.protobuf.GeneratedMessage$0.Builder<?>",
+ GeneratedCodeVersionSuffix());
}
- printer->Print(
- "private static final long serialVersionUID = 0L;\n");
+ printer->Print("private static final long serialVersionUID = 0L;\n");
printer->Indent();
// Using builder_type, instead of Builder, prevents the Builder class from
@@ -347,29 +342,34 @@
// This optimizes the PermGen space usage for clients that do not modify
// messages.
printer->Print(
- "// Use $classname$.newBuilder() to construct.\n"
- "private $classname$($buildertype$ builder) {\n"
- " super(builder);\n"
- "}\n",
- "classname", descriptor_->name(),
- "buildertype", builder_type);
- printer->Print(
- "private $classname$() {\n",
- "classname", descriptor_->name());
+ "// Use $classname$.newBuilder() to construct.\n"
+ "private $classname$($buildertype$ builder) {\n"
+ " super(builder);\n"
+ "}\n",
+ "classname", descriptor_->name(), "buildertype", builder_type);
+ printer->Print("private $classname$() {\n", "classname", descriptor_->name());
printer->Indent();
GenerateInitializers(printer);
printer->Outdent();
printer->Print(
- "}\n"
- "\n");
+ "}\n"
+ "\n");
+ printer->Print(variables,
+ "@java.lang.Override\n"
+ "@SuppressWarnings({\"unused\"})\n"
+ "protected java.lang.Object newInstance(\n"
+ " UnusedPrivateParameter unused) {\n"
+ " return new $classname$();\n"
+ "}\n"
+ "\n");
printer->Print(
- "@java.lang.Override\n"
- "public final com.google.protobuf.UnknownFieldSet\n"
- "getUnknownFields() {\n"
- " return this.unknownFields;\n"
- "}\n");
+ "@java.lang.Override\n"
+ "public final com.google.protobuf.UnknownFieldSet\n"
+ "getUnknownFields() {\n"
+ " return this.unknownFields;\n"
+ "}\n");
if (context_->HasGeneratedMethods(descriptor_)) {
GenerateParsingConstructor(printer);
@@ -379,15 +379,14 @@
// Nested types
for (int i = 0; i < descriptor_->enum_type_count(); i++) {
- EnumGenerator(descriptor_->enum_type(i), true, context_)
- .Generate(printer);
+ EnumGenerator(descriptor_->enum_type(i), true, context_).Generate(printer);
}
for (int i = 0; i < descriptor_->nested_type_count(); i++) {
// Don't generate Java classes for map entry messages.
if (IsMapEntry(descriptor_->nested_type(i))) continue;
- ImmutableMessageGenerator messageGenerator(
- descriptor_->nested_type(i), context_);
+ ImmutableMessageGenerator messageGenerator(descriptor_->nested_type(i),
+ context_);
messageGenerator.GenerateInterface(printer);
messageGenerator.Generate(printer);
}
@@ -407,19 +406,20 @@
// oneof
std::map<std::string, std::string> vars;
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
- vars["oneof_name"] = context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->name;
- vars["oneof_capitalized_name"] = context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->capitalized_name;
+ vars["oneof_name"] =
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))->name;
+ vars["oneof_capitalized_name"] =
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))
+ ->capitalized_name;
vars["oneof_index"] = StrCat(descriptor_->oneof_decl(i)->index());
// oneofCase_ and oneof_
printer->Print(vars,
- "private int $oneof_name$Case_ = 0;\n"
- "private java.lang.Object $oneof_name$_;\n");
+ "private int $oneof_name$Case_ = 0;\n"
+ "private java.lang.Object $oneof_name$_;\n");
// OneofCase enum
printer->Print(vars,
- "public enum $oneof_capitalized_name$Case\n"
- " implements com.google.protobuf.Internal.EnumLite {\n");
+ "public enum $oneof_capitalized_name$Case\n"
+ " implements com.google.protobuf.Internal.EnumLite {\n");
printer->Indent();
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
@@ -429,26 +429,25 @@
"field_name", ToUpper(field->name()), "field_number",
StrCat(field->number()));
}
+ printer->Print("$cap_oneof_name$_NOT_SET(0);\n", "cap_oneof_name",
+ ToUpper(vars["oneof_name"]));
+ printer->Print(vars,
+ "private final int value;\n"
+ "private $oneof_capitalized_name$Case(int value) {\n"
+ " this.value = value;\n"
+ "}\n");
printer->Print(
- "$cap_oneof_name$_NOT_SET(0);\n",
- "cap_oneof_name",
- ToUpper(vars["oneof_name"]));
- printer->Print(vars,
- "private final int value;\n"
- "private $oneof_capitalized_name$Case(int value) {\n"
- " this.value = value;\n"
- "}\n");
- printer->Print(vars,
- "/**\n"
- " * @deprecated Use {@link #forNumber(int)} instead.\n"
- " */\n"
- "@java.lang.Deprecated\n"
- "public static $oneof_capitalized_name$Case valueOf(int value) {\n"
- " return forNumber(value);\n"
- "}\n"
- "\n"
- "public static $oneof_capitalized_name$Case forNumber(int value) {\n"
- " switch (value) {\n");
+ vars,
+ "/**\n"
+ " * @deprecated Use {@link #forNumber(int)} instead.\n"
+ " */\n"
+ "@java.lang.Deprecated\n"
+ "public static $oneof_capitalized_name$Case valueOf(int value) {\n"
+ " return forNumber(value);\n"
+ "}\n"
+ "\n"
+ "public static $oneof_capitalized_name$Case forNumber(int value) {\n"
+ " switch (value) {\n");
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
printer->Print(" case $field_number$: return $field_name$;\n",
@@ -456,24 +455,24 @@
"field_name", ToUpper(field->name()));
}
printer->Print(
- " case 0: return $cap_oneof_name$_NOT_SET;\n"
- " default: return null;\n"
- " }\n"
- "}\n"
- "public int getNumber() {\n"
- " return this.value;\n"
- "}\n",
- "cap_oneof_name", ToUpper(vars["oneof_name"]));
+ " case 0: return $cap_oneof_name$_NOT_SET;\n"
+ " default: return null;\n"
+ " }\n"
+ "}\n"
+ "public int getNumber() {\n"
+ " return this.value;\n"
+ "}\n",
+ "cap_oneof_name", ToUpper(vars["oneof_name"]));
printer->Outdent();
printer->Print("};\n\n");
// oneofCase()
printer->Print(vars,
- "public $oneof_capitalized_name$Case\n"
- "get$oneof_capitalized_name$Case() {\n"
- " return $oneof_capitalized_name$Case.forNumber(\n"
- " $oneof_name$Case_);\n"
- "}\n"
- "\n");
+ "public $oneof_capitalized_name$Case\n"
+ "get$oneof_capitalized_name$Case() {\n"
+ " return $oneof_capitalized_name$Case.forNumber(\n"
+ " $oneof_name$Case_);\n"
+ "}\n"
+ "\n");
}
if (IsAnyMessage(descriptor_)) {
@@ -500,22 +499,21 @@
GenerateBuilder(printer);
printer->Print(
- "\n"
- "// @@protoc_insertion_point(class_scope:$full_name$)\n",
- "full_name", descriptor_->full_name());
-
+ "\n"
+ "// @@protoc_insertion_point(class_scope:$full_name$)\n",
+ "full_name", descriptor_->full_name());
// Carefully initialize the default instance in such a way that it doesn't
// conflict with other initialization.
+ printer->Print("private static final $classname$ DEFAULT_INSTANCE;\n",
+ "classname",
+ name_resolver_->GetImmutableClassName(descriptor_));
printer->Print(
- "private static final $classname$ DEFAULT_INSTANCE;\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
- printer->Print(
- "static {\n"
- " DEFAULT_INSTANCE = new $classname$();\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "static {\n"
+ " DEFAULT_INSTANCE = new $classname$();\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
printer->Print(
"public static $classname$ getDefaultInstance() {\n"
@@ -538,12 +536,12 @@
GenerateParser(printer);
printer->Print(
- "@java.lang.Override\n"
- "public $classname$ getDefaultInstanceForType() {\n"
- " return DEFAULT_INSTANCE;\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "@java.lang.Override\n"
+ "public $classname$ getDefaultInstanceForType() {\n"
+ " return DEFAULT_INSTANCE;\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
// Extensions must be declared after the DEFAULT_INSTANCE is initialized
// because the DEFAULT_INSTANCE is used by the extension to lazily retrieve
@@ -557,12 +555,11 @@
printer->Print("}\n\n");
}
-
// ===================================================================
-void ImmutableMessageGenerator::
-GenerateMessageSerializationMethods(io::Printer* printer) {
- std::unique_ptr<const FieldDescriptor * []> sorted_fields(
+void ImmutableMessageGenerator::GenerateMessageSerializationMethods(
+ io::Printer* printer) {
+ std::unique_ptr<const FieldDescriptor*[]> sorted_fields(
SortFieldsByNumber(descriptor_));
std::vector<const Descriptor::ExtensionRange*> sorted_extensions;
@@ -572,9 +569,9 @@
std::sort(sorted_extensions.begin(), sorted_extensions.end(),
ExtensionRangeOrdering());
printer->Print(
- "@java.lang.Override\n"
- "public void writeTo(com.google.protobuf.CodedOutputStream output)\n"
- " throws java.io.IOException {\n");
+ "@java.lang.Override\n"
+ "public void writeTo(com.google.protobuf.CodedOutputStream output)\n"
+ " throws java.io.IOException {\n");
printer->Indent();
if (HasPackedFields(descriptor_)) {
@@ -639,8 +636,7 @@
printer->Print("size = 0;\n");
for (int i = 0; i < descriptor_->field_count(); i++) {
- field_generators_.get(sorted_fields[i])
- .GenerateSerializedSizeCode(printer);
+ field_generators_.get(sorted_fields[i]).GenerateSerializedSizeCode(printer);
}
if (descriptor_->extension_range_count() > 0) {
@@ -652,8 +648,7 @@
}
if (descriptor_->options().message_set_wire_format()) {
- printer->Print(
- "size += unknownFields.getSerializedSizeAsMessageSet();\n");
+ printer->Print("size += unknownFields.getSerializedSizeAsMessageSet();\n");
} else {
printer->Print("size += unknownFields.getSerializedSize();\n");
}
@@ -664,88 +659,89 @@
printer->Outdent();
printer->Print(
- "}\n"
- "\n");
+ "}\n"
+ "\n");
}
-void ImmutableMessageGenerator::
-GenerateParseFromMethods(io::Printer* printer) {
+void ImmutableMessageGenerator::GenerateParseFromMethods(io::Printer* printer) {
// Note: These are separate from GenerateMessageSerializationMethods()
// because they need to be generated even for messages that are optimized
// for code size.
printer->Print(
- "public static $classname$ parseFrom(\n"
- " java.nio.ByteBuffer data)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return PARSER.parseFrom(data);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " java.nio.ByteBuffer data,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return PARSER.parseFrom(data, extensionRegistry);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " com.google.protobuf.ByteString data)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return PARSER.parseFrom(data);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " com.google.protobuf.ByteString data,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return PARSER.parseFrom(data, extensionRegistry);\n"
- "}\n"
- "public static $classname$ parseFrom(byte[] data)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return PARSER.parseFrom(data);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " byte[] data,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return PARSER.parseFrom(data, extensionRegistry);\n"
- "}\n"
- "public static $classname$ parseFrom(java.io.InputStream input)\n"
- " throws java.io.IOException {\n"
- " return com.google.protobuf.GeneratedMessage$ver$\n"
- " .parseWithIOException(PARSER, input);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " java.io.InputStream input,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws java.io.IOException {\n"
- " return com.google.protobuf.GeneratedMessage$ver$\n"
- " .parseWithIOException(PARSER, input, extensionRegistry);\n"
- "}\n"
- "public static $classname$ parseDelimitedFrom(java.io.InputStream input)\n"
- " throws java.io.IOException {\n"
- " return com.google.protobuf.GeneratedMessage$ver$\n"
- " .parseDelimitedWithIOException(PARSER, input);\n"
- "}\n"
- "public static $classname$ parseDelimitedFrom(\n"
- " java.io.InputStream input,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws java.io.IOException {\n"
- " return com.google.protobuf.GeneratedMessage$ver$\n"
- " .parseDelimitedWithIOException(PARSER, input, extensionRegistry);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " com.google.protobuf.CodedInputStream input)\n"
- " throws java.io.IOException {\n"
- " return com.google.protobuf.GeneratedMessage$ver$\n"
- " .parseWithIOException(PARSER, input);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " com.google.protobuf.CodedInputStream input,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws java.io.IOException {\n"
- " return com.google.protobuf.GeneratedMessage$ver$\n"
- " .parseWithIOException(PARSER, input, extensionRegistry);\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_),
- "ver", GeneratedCodeVersionSuffix());
+ "public static $classname$ parseFrom(\n"
+ " java.nio.ByteBuffer data)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return PARSER.parseFrom(data);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " java.nio.ByteBuffer data,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return PARSER.parseFrom(data, extensionRegistry);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " com.google.protobuf.ByteString data)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return PARSER.parseFrom(data);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " com.google.protobuf.ByteString data,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return PARSER.parseFrom(data, extensionRegistry);\n"
+ "}\n"
+ "public static $classname$ parseFrom(byte[] data)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return PARSER.parseFrom(data);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " byte[] data,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return PARSER.parseFrom(data, extensionRegistry);\n"
+ "}\n"
+ "public static $classname$ parseFrom(java.io.InputStream input)\n"
+ " throws java.io.IOException {\n"
+ " return com.google.protobuf.GeneratedMessage$ver$\n"
+ " .parseWithIOException(PARSER, input);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " java.io.InputStream input,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws java.io.IOException {\n"
+ " return com.google.protobuf.GeneratedMessage$ver$\n"
+ " .parseWithIOException(PARSER, input, extensionRegistry);\n"
+ "}\n"
+ "public static $classname$ parseDelimitedFrom(java.io.InputStream "
+ "input)\n"
+ " throws java.io.IOException {\n"
+ " return com.google.protobuf.GeneratedMessage$ver$\n"
+ " .parseDelimitedWithIOException(PARSER, input);\n"
+ "}\n"
+ "public static $classname$ parseDelimitedFrom(\n"
+ " java.io.InputStream input,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws java.io.IOException {\n"
+ " return com.google.protobuf.GeneratedMessage$ver$\n"
+ " .parseDelimitedWithIOException(PARSER, input, "
+ "extensionRegistry);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " com.google.protobuf.CodedInputStream input)\n"
+ " throws java.io.IOException {\n"
+ " return com.google.protobuf.GeneratedMessage$ver$\n"
+ " .parseWithIOException(PARSER, input);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " com.google.protobuf.CodedInputStream input,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws java.io.IOException {\n"
+ " return com.google.protobuf.GeneratedMessage$ver$\n"
+ " .parseWithIOException(PARSER, input, extensionRegistry);\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_), "ver",
+ GeneratedCodeVersionSuffix());
}
void ImmutableMessageGenerator::GenerateSerializeOneField(
@@ -764,48 +760,48 @@
void ImmutableMessageGenerator::GenerateBuilder(io::Printer* printer) {
// LITE_RUNTIME implements this at the GeneratedMessageLite level.
printer->Print(
- "@java.lang.Override\n"
- "public Builder newBuilderForType() { return newBuilder(); }\n");
+ "@java.lang.Override\n"
+ "public Builder newBuilderForType() { return newBuilder(); }\n");
printer->Print(
- "public static Builder newBuilder() {\n"
- " return DEFAULT_INSTANCE.toBuilder();\n"
- "}\n"
- "public static Builder newBuilder($classname$ prototype) {\n"
- " return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);\n"
- "}\n"
- "@java.lang.Override\n"
- "public Builder toBuilder() {\n"
- " return this == DEFAULT_INSTANCE\n"
- " ? new Builder() : new Builder().mergeFrom(this);\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "public static Builder newBuilder() {\n"
+ " return DEFAULT_INSTANCE.toBuilder();\n"
+ "}\n"
+ "public static Builder newBuilder($classname$ prototype) {\n"
+ " return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);\n"
+ "}\n"
+ "@java.lang.Override\n"
+ "public Builder toBuilder() {\n"
+ " return this == DEFAULT_INSTANCE\n"
+ " ? new Builder() : new Builder().mergeFrom(this);\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
printer->Print(
- "@java.lang.Override\n"
- "protected Builder newBuilderForType(\n"
- " com.google.protobuf.GeneratedMessage$ver$.BuilderParent parent) {\n"
- " Builder builder = new Builder(parent);\n"
- " return builder;\n"
- "}\n",
- "ver", GeneratedCodeVersionSuffix());
+ "@java.lang.Override\n"
+ "protected Builder newBuilderForType(\n"
+ " com.google.protobuf.GeneratedMessage$ver$.BuilderParent parent) {\n"
+ " Builder builder = new Builder(parent);\n"
+ " return builder;\n"
+ "}\n",
+ "ver", GeneratedCodeVersionSuffix());
MessageBuilderGenerator builderGenerator(descriptor_, context_);
builderGenerator.Generate(printer);
}
-void ImmutableMessageGenerator::
-GenerateDescriptorMethods(io::Printer* printer) {
+void ImmutableMessageGenerator::GenerateDescriptorMethods(
+ io::Printer* printer) {
if (!descriptor_->options().no_standard_descriptor_accessor()) {
printer->Print(
- "public static final com.google.protobuf.Descriptors.Descriptor\n"
- " getDescriptor() {\n"
- " return $fileclass$.internal_$identifier$_descriptor;\n"
- "}\n"
- "\n",
- "fileclass", name_resolver_->GetImmutableClassName(descriptor_->file()),
- "identifier", UniqueFileScopeIdentifier(descriptor_));
+ "public static final com.google.protobuf.Descriptors.Descriptor\n"
+ " getDescriptor() {\n"
+ " return $fileclass$.internal_$identifier$_descriptor;\n"
+ "}\n"
+ "\n",
+ "fileclass", name_resolver_->GetImmutableClassName(descriptor_->file()),
+ "identifier", UniqueFileScopeIdentifier(descriptor_));
}
std::vector<const FieldDescriptor*> map_fields;
for (int i = 0; i < descriptor_->field_count(); i++) {
@@ -817,11 +813,11 @@
}
if (!map_fields.empty()) {
printer->Print(
- "@SuppressWarnings({\"rawtypes\"})\n"
- "@java.lang.Override\n"
- "protected com.google.protobuf.MapField internalGetMapField(\n"
- " int number) {\n"
- " switch (number) {\n");
+ "@SuppressWarnings({\"rawtypes\"})\n"
+ "@java.lang.Override\n"
+ "protected com.google.protobuf.MapField internalGetMapField(\n"
+ " int number) {\n"
+ " switch (number) {\n");
printer->Indent();
printer->Indent();
for (int i = 0; i < map_fields.size(); ++i) {
@@ -844,40 +840,38 @@
"}\n");
}
printer->Print(
- "@java.lang.Override\n"
- "protected com.google.protobuf.GeneratedMessage$ver$.FieldAccessorTable\n"
- " internalGetFieldAccessorTable() {\n"
- " return $fileclass$.internal_$identifier$_fieldAccessorTable\n"
- " .ensureFieldAccessorsInitialized(\n"
- " $classname$.class, $classname$.Builder.class);\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_),
- "fileclass", name_resolver_->GetImmutableClassName(descriptor_->file()),
- "identifier", UniqueFileScopeIdentifier(descriptor_),
- "ver", GeneratedCodeVersionSuffix());
+ "@java.lang.Override\n"
+ "protected com.google.protobuf.GeneratedMessage$ver$.FieldAccessorTable\n"
+ " internalGetFieldAccessorTable() {\n"
+ " return $fileclass$.internal_$identifier$_fieldAccessorTable\n"
+ " .ensureFieldAccessorsInitialized(\n"
+ " $classname$.class, $classname$.Builder.class);\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_),
+ "fileclass", name_resolver_->GetImmutableClassName(descriptor_->file()),
+ "identifier", UniqueFileScopeIdentifier(descriptor_), "ver",
+ GeneratedCodeVersionSuffix());
}
// ===================================================================
-void ImmutableMessageGenerator::GenerateIsInitialized(
- io::Printer* printer) {
+void ImmutableMessageGenerator::GenerateIsInitialized(io::Printer* printer) {
// Memoizes whether the protocol buffer is fully initialized (has all
// required fields). -1 means not yet computed. 0 means false and 1 means
// true.
+ printer->Print("private byte memoizedIsInitialized = -1;\n");
printer->Print(
- "private byte memoizedIsInitialized = -1;\n");
- printer->Print(
- "@java.lang.Override\n"
- "public final boolean isInitialized() {\n");
+ "@java.lang.Override\n"
+ "public final boolean isInitialized() {\n");
printer->Indent();
// Don't directly compare to -1 to avoid an Android x86 JIT bug.
printer->Print(
- "byte isInitialized = memoizedIsInitialized;\n"
- "if (isInitialized == 1) return true;\n"
- "if (isInitialized == 0) return false;\n"
- "\n");
+ "byte isInitialized = memoizedIsInitialized;\n"
+ "if (isInitialized == 1) return true;\n"
+ "if (isInitialized == 0) return false;\n"
+ "\n");
// Check that all required fields in this message are set.
// TODO(kenton): We can optimize this when we switch to putting all the
@@ -888,11 +882,11 @@
if (field->is_required()) {
printer->Print(
- "if (!has$name$()) {\n"
- " memoizedIsInitialized = 0;\n"
- " return false;\n"
- "}\n",
- "name", info->capitalized_name);
+ "if (!has$name$()) {\n"
+ " memoizedIsInitialized = 0;\n"
+ " return false;\n"
+ "}\n",
+ "name", info->capitalized_name);
}
}
@@ -905,13 +899,13 @@
switch (field->label()) {
case FieldDescriptor::LABEL_REQUIRED:
printer->Print(
- "if (!get$name$().isInitialized()) {\n"
- " memoizedIsInitialized = 0;\n"
- " return false;\n"
- "}\n",
- "type", name_resolver_->GetImmutableClassName(
- field->message_type()),
- "name", info->capitalized_name);
+ "if (!get$name$().isInitialized()) {\n"
+ " memoizedIsInitialized = 0;\n"
+ " return false;\n"
+ "}\n",
+ "type",
+ name_resolver_->GetImmutableClassName(field->message_type()),
+ "name", info->capitalized_name);
break;
case FieldDescriptor::LABEL_OPTIONAL:
if (!SupportFieldPresence(descriptor_->file()) &&
@@ -923,41 +917,41 @@
"oneof_name", oneof_info->name, "field_number",
StrCat(field->number()));
} else {
- printer->Print(
- "if (has$name$()) {\n",
- "name", info->capitalized_name);
+ printer->Print("if (has$name$()) {\n", "name",
+ info->capitalized_name);
}
printer->Print(
- " if (!get$name$().isInitialized()) {\n"
- " memoizedIsInitialized = 0;\n"
- " return false;\n"
- " }\n"
- "}\n",
- "name", info->capitalized_name);
+ " if (!get$name$().isInitialized()) {\n"
+ " memoizedIsInitialized = 0;\n"
+ " return false;\n"
+ " }\n"
+ "}\n",
+ "name", info->capitalized_name);
break;
case FieldDescriptor::LABEL_REPEATED:
if (IsMapEntry(field->message_type())) {
printer->Print(
- "for ($type$ item : get$name$Map().values()) {\n"
- " if (!item.isInitialized()) {\n"
- " memoizedIsInitialized = 0;\n"
- " return false;\n"
- " }\n"
- "}\n",
- "type", MapValueImmutableClassdName(field->message_type(),
- name_resolver_),
- "name", info->capitalized_name);
+ "for ($type$ item : get$name$Map().values()) {\n"
+ " if (!item.isInitialized()) {\n"
+ " memoizedIsInitialized = 0;\n"
+ " return false;\n"
+ " }\n"
+ "}\n",
+ "type",
+ MapValueImmutableClassdName(field->message_type(),
+ name_resolver_),
+ "name", info->capitalized_name);
} else {
printer->Print(
- "for (int i = 0; i < get$name$Count(); i++) {\n"
- " if (!get$name$(i).isInitialized()) {\n"
- " memoizedIsInitialized = 0;\n"
- " return false;\n"
- " }\n"
- "}\n",
- "type", name_resolver_->GetImmutableClassName(
- field->message_type()),
- "name", info->capitalized_name);
+ "for (int i = 0; i < get$name$Count(); i++) {\n"
+ " if (!get$name$(i).isInitialized()) {\n"
+ " memoizedIsInitialized = 0;\n"
+ " return false;\n"
+ " }\n"
+ "}\n",
+ "type",
+ name_resolver_->GetImmutableClassName(field->message_type()),
+ "name", info->capitalized_name);
}
break;
}
@@ -966,21 +960,20 @@
if (descriptor_->extension_range_count() > 0) {
printer->Print(
- "if (!extensionsAreInitialized()) {\n"
- " memoizedIsInitialized = 0;\n"
- " return false;\n"
- "}\n");
+ "if (!extensionsAreInitialized()) {\n"
+ " memoizedIsInitialized = 0;\n"
+ " return false;\n"
+ "}\n");
}
printer->Outdent();
- printer->Print(
- " memoizedIsInitialized = 1;\n");
+ printer->Print(" memoizedIsInitialized = 1;\n");
printer->Print(
- " return true;\n"
- "}\n"
- "\n");
+ " return true;\n"
+ "}\n"
+ "\n");
}
// ===================================================================
@@ -994,26 +987,26 @@
return true;
}
return GetJavaType(field) == JAVATYPE_MESSAGE &&
- field->containing_oneof() == NULL;
+ field->containing_oneof() == NULL;
}
} // namespace
-void ImmutableMessageGenerator::
-GenerateEqualsAndHashCode(io::Printer* printer) {
+void ImmutableMessageGenerator::GenerateEqualsAndHashCode(
+ io::Printer* printer) {
printer->Print(
- "@java.lang.Override\n"
- "public boolean equals(final java.lang.Object obj) {\n");
+ "@java.lang.Override\n"
+ "public boolean equals(final java.lang.Object obj) {\n");
printer->Indent();
printer->Print(
- "if (obj == this) {\n"
- " return true;\n"
- "}\n"
- "if (!(obj instanceof $classname$)) {\n"
- " return super.equals(obj);\n"
- "}\n"
- "$classname$ other = ($classname$) obj;\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "if (obj == this) {\n"
+ " return true;\n"
+ "}\n"
+ "if (!(obj instanceof $classname$)) {\n"
+ " return super.equals(obj);\n"
+ "}\n"
+ "$classname$ other = ($classname$) obj;\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
for (int i = 0; i < descriptor_->field_count(); i++) {
const FieldDescriptor* field = descriptor_->field(i);
@@ -1022,16 +1015,15 @@
bool check_has_bits = CheckHasBitsForEqualsAndHashCode(field);
if (check_has_bits) {
printer->Print(
- "if (has$name$() != other.has$name$()) return false;\n"
- "if (has$name$()) {\n",
- "name", info->capitalized_name);
+ "if (has$name$() != other.has$name$()) return false;\n"
+ "if (has$name$()) {\n",
+ "name", info->capitalized_name);
printer->Indent();
}
field_generators_.get(field).GenerateEqualsCode(printer);
if (check_has_bits) {
printer->Outdent();
- printer->Print(
- "}\n");
+ printer->Print("}\n");
}
}
}
@@ -1039,16 +1031,14 @@
// Compare oneofs.
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
printer->Print(
- "if (!get$oneof_capitalized_name$Case().equals("
- "other.get$oneof_capitalized_name$Case())) return false;\n",
- "oneof_capitalized_name",
- context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->capitalized_name);
+ "if (!get$oneof_capitalized_name$Case().equals("
+ "other.get$oneof_capitalized_name$Case())) return false;\n",
+ "oneof_capitalized_name",
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))
+ ->capitalized_name);
printer->Print(
- "switch ($oneof_name$Case_) {\n",
- "oneof_name",
- context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->name);
+ "switch ($oneof_name$Case_) {\n", "oneof_name",
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))->name);
printer->Indent();
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
@@ -1060,8 +1050,8 @@
printer->Outdent();
}
printer->Print(
- "case 0:\n"
- "default:\n");
+ "case 0:\n"
+ "default:\n");
printer->Outdent();
printer->Print("}\n");
}
@@ -1073,29 +1063,26 @@
"if (!unknownFields.equals(other.unknownFields)) return false;\n");
if (descriptor_->extension_range_count() > 0) {
printer->Print(
- "if (!getExtensionFields().equals(other.getExtensionFields()))\n"
- " return false;\n");
+ "if (!getExtensionFields().equals(other.getExtensionFields()))\n"
+ " return false;\n");
}
- printer->Print(
- "return true;\n");
+ printer->Print("return true;\n");
printer->Outdent();
printer->Print(
- "}\n"
- "\n");
+ "}\n"
+ "\n");
printer->Print(
- "@java.lang.Override\n"
- "public int hashCode() {\n");
+ "@java.lang.Override\n"
+ "public int hashCode() {\n");
printer->Indent();
- printer->Print(
- "if (memoizedHashCode != 0) {\n");
+ printer->Print("if (memoizedHashCode != 0) {\n");
printer->Indent();
- printer->Print(
- "return memoizedHashCode;\n");
+ printer->Print("return memoizedHashCode;\n");
printer->Outdent();
printer->Print(
- "}\n"
- "int hash = 41;\n");
+ "}\n"
+ "int hash = 41;\n");
// If we output a getDescriptor() method, use that as it is more efficient.
if (descriptor_->options().no_standard_descriptor_accessor()) {
@@ -1111,9 +1098,7 @@
const FieldGeneratorInfo* info = context_->GetFieldGeneratorInfo(field);
bool check_has_bits = CheckHasBitsForEqualsAndHashCode(field);
if (check_has_bits) {
- printer->Print(
- "if (has$name$()) {\n",
- "name", info->capitalized_name);
+ printer->Print("if (has$name$()) {\n", "name", info->capitalized_name);
printer->Indent();
}
field_generators_.get(field).GenerateHashCode(printer);
@@ -1127,10 +1112,8 @@
// hashCode oneofs.
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
printer->Print(
- "switch ($oneof_name$Case_) {\n",
- "oneof_name",
- context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->name);
+ "switch ($oneof_name$Case_) {\n", "oneof_name",
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))->name);
printer->Indent();
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
@@ -1142,47 +1125,45 @@
printer->Outdent();
}
printer->Print(
- "case 0:\n"
- "default:\n");
+ "case 0:\n"
+ "default:\n");
printer->Outdent();
printer->Print("}\n");
}
if (descriptor_->extension_range_count() > 0) {
- printer->Print(
- "hash = hashFields(hash, getExtensionFields());\n");
+ printer->Print("hash = hashFields(hash, getExtensionFields());\n");
}
+ printer->Print("hash = (29 * hash) + unknownFields.hashCode();\n");
printer->Print(
- "hash = (29 * hash) + unknownFields.hashCode();\n");
- printer->Print(
- "memoizedHashCode = hash;\n"
- "return hash;\n");
+ "memoizedHashCode = hash;\n"
+ "return hash;\n");
printer->Outdent();
printer->Print(
- "}\n"
- "\n");
+ "}\n"
+ "\n");
}
// ===================================================================
-void ImmutableMessageGenerator::
-GenerateExtensionRegistrationCode(io::Printer* printer) {
+void ImmutableMessageGenerator::GenerateExtensionRegistrationCode(
+ io::Printer* printer) {
for (int i = 0; i < descriptor_->extension_count(); i++) {
ImmutableExtensionGenerator(descriptor_->extension(i), context_)
- .GenerateRegistrationCode(printer);
+ .GenerateRegistrationCode(printer);
}
for (int i = 0; i < descriptor_->nested_type_count(); i++) {
ImmutableMessageGenerator(descriptor_->nested_type(i), context_)
- .GenerateExtensionRegistrationCode(printer);
+ .GenerateExtensionRegistrationCode(printer);
}
}
// ===================================================================
-void ImmutableMessageGenerator::
-GenerateParsingConstructor(io::Printer* printer) {
- std::unique_ptr<const FieldDescriptor * []> sorted_fields(
+void ImmutableMessageGenerator::GenerateParsingConstructor(
+ io::Printer* printer) {
+ std::unique_ptr<const FieldDescriptor*[]> sorted_fields(
SortFieldsByNumber(descriptor_));
printer->Print(
@@ -1209,26 +1190,25 @@
}
int totalBuilderInts = (totalBuilderBits + 31) / 32;
for (int i = 0; i < totalBuilderInts; i++) {
- printer->Print("int mutable_$bit_field_name$ = 0;\n",
- "bit_field_name", GetBitFieldName(i));
+ printer->Print("int mutable_$bit_field_name$ = 0;\n", "bit_field_name",
+ GetBitFieldName(i));
}
printer->Print(
"com.google.protobuf.UnknownFieldSet.Builder unknownFields =\n"
" com.google.protobuf.UnknownFieldSet.newBuilder();\n");
- printer->Print(
- "try {\n");
+ printer->Print("try {\n");
printer->Indent();
printer->Print(
- "boolean done = false;\n"
- "while (!done) {\n");
+ "boolean done = false;\n"
+ "while (!done) {\n");
printer->Indent();
printer->Print(
- "int tag = input.readTag();\n"
- "switch (tag) {\n");
+ "int tag = input.readTag();\n"
+ "switch (tag) {\n");
printer->Indent();
printer->Print(
@@ -1238,8 +1218,8 @@
for (int i = 0; i < descriptor_->field_count(); i++) {
const FieldDescriptor* field = sorted_fields[i];
- uint32 tag = WireFormatLite::MakeTag(field->number(),
- WireFormat::WireTypeForFieldType(field->type()));
+ uint32 tag = WireFormatLite::MakeTag(
+ field->number(), WireFormat::WireTypeForFieldType(field->type()));
printer->Print("case $tag$: {\n", "tag",
StrCat(static_cast<int32>(tag)));
@@ -1249,14 +1229,14 @@
printer->Outdent();
printer->Print(
- " break;\n"
- "}\n");
+ " break;\n"
+ "}\n");
if (field->is_packable()) {
// To make packed = true wire compatible, we generate parsing code from a
// packed version of this field regardless of field->options().packed().
- uint32 packed_tag = WireFormatLite::MakeTag(field->number(),
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
+ uint32 packed_tag = WireFormatLite::MakeTag(
+ field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
printer->Print("case $tag$: {\n", "tag",
StrCat(static_cast<int32>(packed_tag)));
printer->Indent();
@@ -1265,8 +1245,8 @@
printer->Outdent();
printer->Print(
- " break;\n"
- "}\n");
+ " break;\n"
+ "}\n");
}
}
@@ -1282,8 +1262,8 @@
printer->Outdent();
printer->Outdent();
printer->Print(
- " }\n" // switch (tag)
- "}\n"); // while (!done)
+ " }\n" // switch (tag)
+ "}\n"); // while (!done)
printer->Outdent();
printer->Print(
@@ -1305,13 +1285,12 @@
printer->Print("this.unknownFields = unknownFields.build();\n");
// Make extensions immutable.
- printer->Print(
- "makeExtensionsImmutable();\n");
+ printer->Print("makeExtensionsImmutable();\n");
printer->Outdent();
printer->Outdent();
printer->Print(
- " }\n" // finally
+ " }\n" // finally
"}\n");
}
@@ -1354,8 +1333,7 @@
"return builder.buildPartial();\n");
printer->Outdent();
}
- printer->Print(
- "}\n");
+ printer->Print("}\n");
printer->Outdent();
printer->Print(
"};\n"
@@ -1387,76 +1365,76 @@
void ImmutableMessageGenerator::GenerateAnyMethods(io::Printer* printer) {
printer->Print(
- "private static String getTypeUrl(\n"
- " java.lang.String typeUrlPrefix,\n"
- " com.google.protobuf.Descriptors.Descriptor descriptor) {\n"
- " return typeUrlPrefix.endsWith(\"/\")\n"
- " ? typeUrlPrefix + descriptor.getFullName()\n"
- " : typeUrlPrefix + \"/\" + descriptor.getFullName();\n"
- "}\n"
- "\n"
- "private static String getTypeNameFromTypeUrl(\n"
- " java.lang.String typeUrl) {\n"
- " int pos = typeUrl.lastIndexOf('/');\n"
- " return pos == -1 ? \"\" : typeUrl.substring(pos + 1);\n"
- "}\n"
- "\n"
- "public static <T extends com.google.protobuf.Message> Any pack(\n"
- " T message) {\n"
- " return Any.newBuilder()\n"
- " .setTypeUrl(getTypeUrl(\"type.googleapis.com\",\n"
- " message.getDescriptorForType()))\n"
- " .setValue(message.toByteString())\n"
- " .build();\n"
- "}\n"
- "\n"
- "/**\n"
- " * Packs a message using the given type URL prefix. The type URL will\n"
- " * be constructed by concatenating the message type's full name to the\n"
- " * prefix with an optional \"/\" separator if the prefix doesn't end\n"
- " * with \"/\" already.\n"
- " */\n"
- "public static <T extends com.google.protobuf.Message> Any pack(\n"
- " T message, java.lang.String typeUrlPrefix) {\n"
- " return Any.newBuilder()\n"
- " .setTypeUrl(getTypeUrl(typeUrlPrefix,\n"
- " message.getDescriptorForType()))\n"
- " .setValue(message.toByteString())\n"
- " .build();\n"
- "}\n"
- "\n"
- "public <T extends com.google.protobuf.Message> boolean is(\n"
- " java.lang.Class<T> clazz) {\n"
- " T defaultInstance =\n"
- " com.google.protobuf.Internal.getDefaultInstance(clazz);\n"
- " return getTypeNameFromTypeUrl(getTypeUrl()).equals(\n"
- " defaultInstance.getDescriptorForType().getFullName());\n"
- "}\n"
- "\n"
- "private volatile com.google.protobuf.Message cachedUnpackValue;\n"
- "\n"
- "@java.lang.SuppressWarnings(\"unchecked\")\n"
- "public <T extends com.google.protobuf.Message> T unpack(\n"
- " java.lang.Class<T> clazz)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " boolean invalidClazz = false;\n"
- " if (cachedUnpackValue != null) {\n"
- " if (cachedUnpackValue.getClass() == clazz) {\n"
- " return (T) cachedUnpackValue;\n"
- " }\n"
- " invalidClazz = true;\n"
- " }\n"
- " if (invalidClazz || !is(clazz)) {\n"
- " throw new com.google.protobuf.InvalidProtocolBufferException(\n"
- " \"Type of the Any message does not match the given class.\");\n"
- " }\n"
- " T defaultInstance =\n"
- " com.google.protobuf.Internal.getDefaultInstance(clazz);\n"
- " T result = (T) defaultInstance.getParserForType()\n"
- " .parseFrom(getValue());\n"
- " cachedUnpackValue = result;\n"
- " return result;\n"
- "}\n");
+ "private static String getTypeUrl(\n"
+ " java.lang.String typeUrlPrefix,\n"
+ " com.google.protobuf.Descriptors.Descriptor descriptor) {\n"
+ " return typeUrlPrefix.endsWith(\"/\")\n"
+ " ? typeUrlPrefix + descriptor.getFullName()\n"
+ " : typeUrlPrefix + \"/\" + descriptor.getFullName();\n"
+ "}\n"
+ "\n"
+ "private static String getTypeNameFromTypeUrl(\n"
+ " java.lang.String typeUrl) {\n"
+ " int pos = typeUrl.lastIndexOf('/');\n"
+ " return pos == -1 ? \"\" : typeUrl.substring(pos + 1);\n"
+ "}\n"
+ "\n"
+ "public static <T extends com.google.protobuf.Message> Any pack(\n"
+ " T message) {\n"
+ " return Any.newBuilder()\n"
+ " .setTypeUrl(getTypeUrl(\"type.googleapis.com\",\n"
+ " message.getDescriptorForType()))\n"
+ " .setValue(message.toByteString())\n"
+ " .build();\n"
+ "}\n"
+ "\n"
+ "/**\n"
+ " * Packs a message using the given type URL prefix. The type URL will\n"
+ " * be constructed by concatenating the message type's full name to the\n"
+ " * prefix with an optional \"/\" separator if the prefix doesn't end\n"
+ " * with \"/\" already.\n"
+ " */\n"
+ "public static <T extends com.google.protobuf.Message> Any pack(\n"
+ " T message, java.lang.String typeUrlPrefix) {\n"
+ " return Any.newBuilder()\n"
+ " .setTypeUrl(getTypeUrl(typeUrlPrefix,\n"
+ " message.getDescriptorForType()))\n"
+ " .setValue(message.toByteString())\n"
+ " .build();\n"
+ "}\n"
+ "\n"
+ "public <T extends com.google.protobuf.Message> boolean is(\n"
+ " java.lang.Class<T> clazz) {\n"
+ " T defaultInstance =\n"
+ " com.google.protobuf.Internal.getDefaultInstance(clazz);\n"
+ " return getTypeNameFromTypeUrl(getTypeUrl()).equals(\n"
+ " defaultInstance.getDescriptorForType().getFullName());\n"
+ "}\n"
+ "\n"
+ "private volatile com.google.protobuf.Message cachedUnpackValue;\n"
+ "\n"
+ "@java.lang.SuppressWarnings(\"unchecked\")\n"
+ "public <T extends com.google.protobuf.Message> T unpack(\n"
+ " java.lang.Class<T> clazz)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " boolean invalidClazz = false;\n"
+ " if (cachedUnpackValue != null) {\n"
+ " if (cachedUnpackValue.getClass() == clazz) {\n"
+ " return (T) cachedUnpackValue;\n"
+ " }\n"
+ " invalidClazz = true;\n"
+ " }\n"
+ " if (invalidClazz || !is(clazz)) {\n"
+ " throw new com.google.protobuf.InvalidProtocolBufferException(\n"
+ " \"Type of the Any message does not match the given class.\");\n"
+ " }\n"
+ " T defaultInstance =\n"
+ " com.google.protobuf.Internal.getDefaultInstance(clazz);\n"
+ " T result = (T) defaultInstance.getParserForType()\n"
+ " .parseFrom(getValue());\n"
+ " cachedUnpackValue = result;\n"
+ " return result;\n"
+ "}\n");
}
} // namespace java
diff --git a/src/google/protobuf/compiler/java/java_message.h b/src/google/protobuf/compiler/java/java_message.h
index ac0c765..de2f359 100644
--- a/src/google/protobuf/compiler/java/java_message.h
+++ b/src/google/protobuf/compiler/java/java_message.h
@@ -35,8 +35,8 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_H__
#define GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_H__
-#include <string>
#include <map>
+#include <string>
#include <google/protobuf/compiler/java/java_field.h>
namespace google {
@@ -101,14 +101,13 @@
virtual void Generate(io::Printer* printer);
virtual void GenerateInterface(io::Printer* printer);
virtual void GenerateExtensionRegistrationCode(io::Printer* printer);
- virtual void GenerateStaticVariables(
- io::Printer* printer, int* bytecode_estimate);
+ virtual void GenerateStaticVariables(io::Printer* printer,
+ int* bytecode_estimate);
// Returns an estimate of the number of bytes the printed code will compile to
virtual int GenerateStaticVariableInitializers(io::Printer* printer);
private:
-
void GenerateFieldAccessorTable(io::Printer* printer, int* bytecode_estimate);
// Returns an estimate of the number of bytes the printed code will compile to
diff --git a/src/google/protobuf/compiler/java/java_message_builder.cc b/src/google/protobuf/compiler/java/java_message_builder.cc
index 2ba77a2..aa00a66 100644
--- a/src/google/protobuf/compiler/java/java_message_builder.cc
+++ b/src/google/protobuf/compiler/java/java_message_builder.cc
@@ -69,11 +69,12 @@
}
} // namespace
-MessageBuilderGenerator::MessageBuilderGenerator(
- const Descriptor* descriptor, Context* context)
- : descriptor_(descriptor), context_(context),
- name_resolver_(context->GetNameResolver()),
- field_generators_(descriptor, context_) {
+MessageBuilderGenerator::MessageBuilderGenerator(const Descriptor* descriptor,
+ Context* context)
+ : descriptor_(descriptor),
+ context_(context),
+ name_resolver_(context->GetNameResolver()),
+ field_generators_(descriptor, context_) {
GOOGLE_CHECK(HasDescriptorMethods(descriptor->file(), context->EnforceLite()))
<< "Generator factory error: A non-lite message generator is used to "
"generate lite messages.";
@@ -81,28 +82,28 @@
MessageBuilderGenerator::~MessageBuilderGenerator() {}
-void MessageBuilderGenerator::
-Generate(io::Printer* printer) {
+void MessageBuilderGenerator::Generate(io::Printer* printer) {
WriteMessageDocComment(printer, descriptor_);
if (descriptor_->extension_range_count() > 0) {
printer->Print(
- "public static final class Builder extends\n"
- " com.google.protobuf.GeneratedMessage$ver$.ExtendableBuilder<\n"
- " $classname$, Builder> implements\n"
- " $extra_interfaces$\n"
- " $classname$OrBuilder {\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_),
- "extra_interfaces", ExtraBuilderInterfaces(descriptor_),
- "ver", GeneratedCodeVersionSuffix());
+ "public static final class Builder extends\n"
+ " com.google.protobuf.GeneratedMessage$ver$.ExtendableBuilder<\n"
+ " $classname$, Builder> implements\n"
+ " $extra_interfaces$\n"
+ " $classname$OrBuilder {\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_),
+ "extra_interfaces", ExtraBuilderInterfaces(descriptor_), "ver",
+ GeneratedCodeVersionSuffix());
} else {
printer->Print(
- "public static final class Builder extends\n"
- " com.google.protobuf.GeneratedMessage$ver$.Builder<Builder> implements\n"
- " $extra_interfaces$\n"
- " $classname$OrBuilder {\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_),
- "extra_interfaces", ExtraBuilderInterfaces(descriptor_),
- "ver", GeneratedCodeVersionSuffix());
+ "public static final class Builder extends\n"
+ " com.google.protobuf.GeneratedMessage$ver$.Builder<Builder> "
+ "implements\n"
+ " $extra_interfaces$\n"
+ " $classname$OrBuilder {\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_),
+ "extra_interfaces", ExtraBuilderInterfaces(descriptor_), "ver",
+ GeneratedCodeVersionSuffix());
}
printer->Indent();
@@ -117,31 +118,32 @@
// oneof
std::map<std::string, std::string> vars;
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
- vars["oneof_name"] = context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->name;
- vars["oneof_capitalized_name"] = context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->capitalized_name;
+ vars["oneof_name"] =
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))->name;
+ vars["oneof_capitalized_name"] =
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))
+ ->capitalized_name;
vars["oneof_index"] = StrCat(descriptor_->oneof_decl(i)->index());
// oneofCase_ and oneof_
printer->Print(vars,
- "private int $oneof_name$Case_ = 0;\n"
- "private java.lang.Object $oneof_name$_;\n");
+ "private int $oneof_name$Case_ = 0;\n"
+ "private java.lang.Object $oneof_name$_;\n");
// oneofCase() and clearOneof()
printer->Print(vars,
- "public $oneof_capitalized_name$Case\n"
- " get$oneof_capitalized_name$Case() {\n"
- " return $oneof_capitalized_name$Case.forNumber(\n"
- " $oneof_name$Case_);\n"
- "}\n"
- "\n"
- "public Builder clear$oneof_capitalized_name$() {\n"
- " $oneof_name$Case_ = 0;\n"
- " $oneof_name$_ = null;\n");
+ "public $oneof_capitalized_name$Case\n"
+ " get$oneof_capitalized_name$Case() {\n"
+ " return $oneof_capitalized_name$Case.forNumber(\n"
+ " $oneof_name$Case_);\n"
+ "}\n"
+ "\n"
+ "public Builder clear$oneof_capitalized_name$() {\n"
+ " $oneof_name$Case_ = 0;\n"
+ " $oneof_name$_ = null;\n");
printer->Print(" onChanged();\n");
printer->Print(
- " return this;\n"
- "}\n"
- "\n");
+ " return this;\n"
+ "}\n"
+ "\n");
}
// Integers for bit fields.
@@ -159,32 +161,32 @@
for (int i = 0; i < descriptor_->field_count(); i++) {
printer->Print("\n");
field_generators_.get(descriptor_->field(i))
- .GenerateBuilderMembers(printer);
+ .GenerateBuilderMembers(printer);
}
- // Override methods declared in GeneratedMessage to return the concrete
- // generated type so callsites won't depend on GeneratedMessage. This
- // is needed to keep binary compatibility when we change generated code
- // to subclass a different GeneratedMessage class (e.g., in v3.0.0 release
- // we changed all generated code to subclass GeneratedMessageV3).
+ // Override methods declared in GeneratedMessage to return the concrete
+ // generated type so callsites won't depend on GeneratedMessage. This
+ // is needed to keep binary compatibility when we change generated code
+ // to subclass a different GeneratedMessage class (e.g., in v3.0.0 release
+ // we changed all generated code to subclass GeneratedMessageV3).
printer->Print(
- "@java.lang.Override\n"
- "public final Builder setUnknownFields(\n"
- " final com.google.protobuf.UnknownFieldSet unknownFields) {\n"
- " return super.setUnknownFields(unknownFields);\n"
- "}\n"
- "\n"
- "@java.lang.Override\n"
- "public final Builder mergeUnknownFields(\n"
- " final com.google.protobuf.UnknownFieldSet unknownFields) {\n"
- " return super.mergeUnknownFields(unknownFields);\n"
- "}\n"
- "\n");
+ "@java.lang.Override\n"
+ "public final Builder setUnknownFields(\n"
+ " final com.google.protobuf.UnknownFieldSet unknownFields) {\n"
+ " return super.setUnknownFields(unknownFields);\n"
+ "}\n"
+ "\n"
+ "@java.lang.Override\n"
+ "public final Builder mergeUnknownFields(\n"
+ " final com.google.protobuf.UnknownFieldSet unknownFields) {\n"
+ " return super.mergeUnknownFields(unknownFields);\n"
+ "}\n"
+ "\n");
printer->Print(
- "\n"
- "// @@protoc_insertion_point(builder_scope:$full_name$)\n",
- "full_name", descriptor_->full_name());
+ "\n"
+ "// @@protoc_insertion_point(builder_scope:$full_name$)\n",
+ "full_name", descriptor_->full_name());
printer->Outdent();
printer->Print("}\n");
@@ -192,17 +194,16 @@
// ===================================================================
-void MessageBuilderGenerator::
-GenerateDescriptorMethods(io::Printer* printer) {
+void MessageBuilderGenerator::GenerateDescriptorMethods(io::Printer* printer) {
if (!descriptor_->options().no_standard_descriptor_accessor()) {
printer->Print(
- "public static final com.google.protobuf.Descriptors.Descriptor\n"
- " getDescriptor() {\n"
- " return $fileclass$.internal_$identifier$_descriptor;\n"
- "}\n"
- "\n",
- "fileclass", name_resolver_->GetImmutableClassName(descriptor_->file()),
- "identifier", UniqueFileScopeIdentifier(descriptor_));
+ "public static final com.google.protobuf.Descriptors.Descriptor\n"
+ " getDescriptor() {\n"
+ " return $fileclass$.internal_$identifier$_descriptor;\n"
+ "}\n"
+ "\n",
+ "fileclass", name_resolver_->GetImmutableClassName(descriptor_->file()),
+ "identifier", UniqueFileScopeIdentifier(descriptor_));
}
std::vector<const FieldDescriptor*> map_fields;
for (int i = 0; i < descriptor_->field_count(); i++) {
@@ -214,10 +215,10 @@
}
if (!map_fields.empty()) {
printer->Print(
- "@SuppressWarnings({\"rawtypes\"})\n"
- "protected com.google.protobuf.MapField internalGetMapField(\n"
- " int number) {\n"
- " switch (number) {\n");
+ "@SuppressWarnings({\"rawtypes\"})\n"
+ "protected com.google.protobuf.MapField internalGetMapField(\n"
+ " int number) {\n"
+ " switch (number) {\n");
printer->Indent();
printer->Indent();
for (int i = 0; i < map_fields.size(); ++i) {
@@ -239,16 +240,15 @@
" }\n"
"}\n");
printer->Print(
- "@SuppressWarnings({\"rawtypes\"})\n"
- "protected com.google.protobuf.MapField internalGetMutableMapField(\n"
- " int number) {\n"
- " switch (number) {\n");
+ "@SuppressWarnings({\"rawtypes\"})\n"
+ "protected com.google.protobuf.MapField internalGetMutableMapField(\n"
+ " int number) {\n"
+ " switch (number) {\n");
printer->Indent();
printer->Indent();
for (int i = 0; i < map_fields.size(); ++i) {
const FieldDescriptor* field = map_fields[i];
- const FieldGeneratorInfo* info =
- context_->GetFieldGeneratorInfo(field);
+ const FieldGeneratorInfo* info = context_->GetFieldGeneratorInfo(field);
printer->Print(
"case $number$:\n"
" return internalGetMutable$capitalized_name$();\n",
@@ -266,24 +266,24 @@
"}\n");
}
printer->Print(
- "@java.lang.Override\n"
- "protected com.google.protobuf.GeneratedMessage$ver$.FieldAccessorTable\n"
- " internalGetFieldAccessorTable() {\n"
- " return $fileclass$.internal_$identifier$_fieldAccessorTable\n"
- " .ensureFieldAccessorsInitialized(\n"
- " $classname$.class, $classname$.Builder.class);\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_),
- "fileclass", name_resolver_->GetImmutableClassName(descriptor_->file()),
- "identifier", UniqueFileScopeIdentifier(descriptor_),
- "ver", GeneratedCodeVersionSuffix());
+ "@java.lang.Override\n"
+ "protected com.google.protobuf.GeneratedMessage$ver$.FieldAccessorTable\n"
+ " internalGetFieldAccessorTable() {\n"
+ " return $fileclass$.internal_$identifier$_fieldAccessorTable\n"
+ " .ensureFieldAccessorsInitialized(\n"
+ " $classname$.class, $classname$.Builder.class);\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_),
+ "fileclass", name_resolver_->GetImmutableClassName(descriptor_->file()),
+ "identifier", UniqueFileScopeIdentifier(descriptor_), "ver",
+ GeneratedCodeVersionSuffix());
}
// ===================================================================
-void MessageBuilderGenerator::
-GenerateCommonBuilderMethods(io::Printer* printer) {
+void MessageBuilderGenerator::GenerateCommonBuilderMethods(
+ io::Printer* printer) {
printer->Print(
"// Construct using $classname$.newBuilder()\n"
"private Builder() {\n"
@@ -293,19 +293,19 @@
"classname", name_resolver_->GetImmutableClassName(descriptor_));
printer->Print(
- "private Builder(\n"
- " com.google.protobuf.GeneratedMessage$ver$.BuilderParent parent) {\n"
- " super(parent);\n"
- " maybeForceBuilderInitialization();\n"
- "}\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_),
- "ver", GeneratedCodeVersionSuffix());
+ "private Builder(\n"
+ " com.google.protobuf.GeneratedMessage$ver$.BuilderParent parent) {\n"
+ " super(parent);\n"
+ " maybeForceBuilderInitialization();\n"
+ "}\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_), "ver",
+ GeneratedCodeVersionSuffix());
printer->Print(
- "private void maybeForceBuilderInitialization() {\n"
- " if (com.google.protobuf.GeneratedMessage$ver$\n"
- " .alwaysUseFieldBuilders) {\n",
- "ver", GeneratedCodeVersionSuffix());
+ "private void maybeForceBuilderInitialization() {\n"
+ " if (com.google.protobuf.GeneratedMessage$ver$\n"
+ " .alwaysUseFieldBuilders) {\n",
+ "ver", GeneratedCodeVersionSuffix());
printer->Indent();
printer->Indent();
@@ -319,13 +319,13 @@
printer->Outdent();
printer->Print(
- " }\n"
- "}\n");
+ " }\n"
+ "}\n");
printer->Print(
- "@java.lang.Override\n"
- "public Builder clear() {\n"
- " super.clear();\n");
+ "@java.lang.Override\n"
+ "public Builder clear() {\n"
+ " super.clear();\n");
printer->Indent();
@@ -338,55 +338,55 @@
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
printer->Print(
- "$oneof_name$Case_ = 0;\n"
- "$oneof_name$_ = null;\n",
- "oneof_name", context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->name);
+ "$oneof_name$Case_ = 0;\n"
+ "$oneof_name$_ = null;\n",
+ "oneof_name",
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))->name);
}
printer->Outdent();
printer->Print(
- " return this;\n"
- "}\n"
- "\n");
+ " return this;\n"
+ "}\n"
+ "\n");
printer->Print(
- "@java.lang.Override\n"
- "public com.google.protobuf.Descriptors.Descriptor\n"
- " getDescriptorForType() {\n"
- " return $fileclass$.internal_$identifier$_descriptor;\n"
- "}\n"
- "\n",
- "fileclass", name_resolver_->GetImmutableClassName(descriptor_->file()),
- "identifier", UniqueFileScopeIdentifier(descriptor_));
+ "@java.lang.Override\n"
+ "public com.google.protobuf.Descriptors.Descriptor\n"
+ " getDescriptorForType() {\n"
+ " return $fileclass$.internal_$identifier$_descriptor;\n"
+ "}\n"
+ "\n",
+ "fileclass", name_resolver_->GetImmutableClassName(descriptor_->file()),
+ "identifier", UniqueFileScopeIdentifier(descriptor_));
// LITE runtime implements this in GeneratedMessageLite.
printer->Print(
- "@java.lang.Override\n"
- "public $classname$ getDefaultInstanceForType() {\n"
- " return $classname$.getDefaultInstance();\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "@java.lang.Override\n"
+ "public $classname$ getDefaultInstanceForType() {\n"
+ " return $classname$.getDefaultInstance();\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
printer->Print(
- "@java.lang.Override\n"
- "public $classname$ build() {\n"
- " $classname$ result = buildPartial();\n"
- " if (!result.isInitialized()) {\n"
- " throw newUninitializedMessageException(result);\n"
- " }\n"
- " return result;\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "@java.lang.Override\n"
+ "public $classname$ build() {\n"
+ " $classname$ result = buildPartial();\n"
+ " if (!result.isInitialized()) {\n"
+ " throw newUninitializedMessageException(result);\n"
+ " }\n"
+ " return result;\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
printer->Print(
- "@java.lang.Override\n"
- "public $classname$ buildPartial() {\n"
- " $classname$ result = new $classname$(this);\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "@java.lang.Override\n"
+ "public $classname$ buildPartial() {\n"
+ " $classname$ result = new $classname$(this);\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
printer->Indent();
@@ -426,21 +426,20 @@
}
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
- printer->Print("result.$oneof_name$Case_ = $oneof_name$Case_;\n",
- "oneof_name", context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->name);
+ printer->Print(
+ "result.$oneof_name$Case_ = $oneof_name$Case_;\n", "oneof_name",
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))->name);
}
printer->Outdent();
- printer->Print(
- " onBuilt();\n");
+ printer->Print(" onBuilt();\n");
printer->Print(
- " return result;\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ " return result;\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
// Override methods declared in GeneratedMessage to return the concrete
// generated type so callsites won't depend on GeneratedMessage. This
@@ -448,190 +447,181 @@
// to subclass a different GeneratedMessage class (e.g., in v3.0.0 release
// we changed all generated code to subclass GeneratedMessageV3).
printer->Print(
- "@java.lang.Override\n"
- "public Builder clone() {\n"
- " return super.clone();\n"
- "}\n"
- "@java.lang.Override\n"
- "public Builder setField(\n"
- " com.google.protobuf.Descriptors.FieldDescriptor field,\n"
- " java.lang.Object value) {\n"
- " return super.setField(field, value);\n"
- "}\n"
- "@java.lang.Override\n"
- "public Builder clearField(\n"
- " com.google.protobuf.Descriptors.FieldDescriptor field) {\n"
- " return super.clearField(field);\n"
- "}\n"
- "@java.lang.Override\n"
- "public Builder clearOneof(\n"
- " com.google.protobuf.Descriptors.OneofDescriptor oneof) {\n"
- " return super.clearOneof(oneof);\n"
- "}\n"
- "@java.lang.Override\n"
- "public Builder setRepeatedField(\n"
- " com.google.protobuf.Descriptors.FieldDescriptor field,\n"
- " int index, java.lang.Object value) {\n"
- " return super.setRepeatedField(field, index, value);\n"
- "}\n"
- "@java.lang.Override\n"
- "public Builder addRepeatedField(\n"
- " com.google.protobuf.Descriptors.FieldDescriptor field,\n"
- " java.lang.Object value) {\n"
- " return super.addRepeatedField(field, value);\n"
- "}\n");
+ "@java.lang.Override\n"
+ "public Builder clone() {\n"
+ " return super.clone();\n"
+ "}\n"
+ "@java.lang.Override\n"
+ "public Builder setField(\n"
+ " com.google.protobuf.Descriptors.FieldDescriptor field,\n"
+ " java.lang.Object value) {\n"
+ " return super.setField(field, value);\n"
+ "}\n"
+ "@java.lang.Override\n"
+ "public Builder clearField(\n"
+ " com.google.protobuf.Descriptors.FieldDescriptor field) {\n"
+ " return super.clearField(field);\n"
+ "}\n"
+ "@java.lang.Override\n"
+ "public Builder clearOneof(\n"
+ " com.google.protobuf.Descriptors.OneofDescriptor oneof) {\n"
+ " return super.clearOneof(oneof);\n"
+ "}\n"
+ "@java.lang.Override\n"
+ "public Builder setRepeatedField(\n"
+ " com.google.protobuf.Descriptors.FieldDescriptor field,\n"
+ " int index, java.lang.Object value) {\n"
+ " return super.setRepeatedField(field, index, value);\n"
+ "}\n"
+ "@java.lang.Override\n"
+ "public Builder addRepeatedField(\n"
+ " com.google.protobuf.Descriptors.FieldDescriptor field,\n"
+ " java.lang.Object value) {\n"
+ " return super.addRepeatedField(field, value);\n"
+ "}\n");
if (descriptor_->extension_range_count() > 0) {
printer->Print(
- "@java.lang.Override\n"
- "public <Type> Builder setExtension(\n"
- " com.google.protobuf.GeneratedMessage.GeneratedExtension<\n"
- " $classname$, Type> extension,\n"
- " Type value) {\n"
- " return super.setExtension(extension, value);\n"
- "}\n"
- "@java.lang.Override\n"
- "public <Type> Builder setExtension(\n"
- " com.google.protobuf.GeneratedMessage.GeneratedExtension<\n"
- " $classname$, java.util.List<Type>> extension,\n"
- " int index, Type value) {\n"
- " return super.setExtension(extension, index, value);\n"
- "}\n"
- "@java.lang.Override\n"
- "public <Type> Builder addExtension(\n"
- " com.google.protobuf.GeneratedMessage.GeneratedExtension<\n"
- " $classname$, java.util.List<Type>> extension,\n"
- " Type value) {\n"
- " return super.addExtension(extension, value);\n"
- "}\n"
- "@java.lang.Override\n"
- "public <Type> Builder clearExtension(\n"
- " com.google.protobuf.GeneratedMessage.GeneratedExtension<\n"
- " $classname$, ?> extension) {\n"
- " return super.clearExtension(extension);\n"
- "}\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "@java.lang.Override\n"
+ "public <Type> Builder setExtension(\n"
+ " com.google.protobuf.GeneratedMessage.GeneratedExtension<\n"
+ " $classname$, Type> extension,\n"
+ " Type value) {\n"
+ " return super.setExtension(extension, value);\n"
+ "}\n"
+ "@java.lang.Override\n"
+ "public <Type> Builder setExtension(\n"
+ " com.google.protobuf.GeneratedMessage.GeneratedExtension<\n"
+ " $classname$, java.util.List<Type>> extension,\n"
+ " int index, Type value) {\n"
+ " return super.setExtension(extension, index, value);\n"
+ "}\n"
+ "@java.lang.Override\n"
+ "public <Type> Builder addExtension(\n"
+ " com.google.protobuf.GeneratedMessage.GeneratedExtension<\n"
+ " $classname$, java.util.List<Type>> extension,\n"
+ " Type value) {\n"
+ " return super.addExtension(extension, value);\n"
+ "}\n"
+ "@java.lang.Override\n"
+ "public <Type> Builder clearExtension(\n"
+ " com.google.protobuf.GeneratedMessage.GeneratedExtension<\n"
+ " $classname$, ?> extension) {\n"
+ " return super.clearExtension(extension);\n"
+ "}\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
}
// -----------------------------------------------------------------
if (context_->HasGeneratedMethods(descriptor_)) {
printer->Print(
- "@java.lang.Override\n"
- "public Builder mergeFrom(com.google.protobuf.Message other) {\n"
- " if (other instanceof $classname$) {\n"
- " return mergeFrom(($classname$)other);\n"
- " } else {\n"
- " super.mergeFrom(other);\n"
- " return this;\n"
- " }\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "@java.lang.Override\n"
+ "public Builder mergeFrom(com.google.protobuf.Message other) {\n"
+ " if (other instanceof $classname$) {\n"
+ " return mergeFrom(($classname$)other);\n"
+ " } else {\n"
+ " super.mergeFrom(other);\n"
+ " return this;\n"
+ " }\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
printer->Print(
- "public Builder mergeFrom($classname$ other) {\n"
- // Optimization: If other is the default instance, we know none of its
- // fields are set so we can skip the merge.
- " if (other == $classname$.getDefaultInstance()) return this;\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "public Builder mergeFrom($classname$ other) {\n"
+ // Optimization: If other is the default instance, we know none of its
+ // fields are set so we can skip the merge.
+ " if (other == $classname$.getDefaultInstance()) return this;\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
printer->Indent();
for (int i = 0; i < descriptor_->field_count(); i++) {
if (!descriptor_->field(i)->containing_oneof()) {
- field_generators_.get(
- descriptor_->field(i)).GenerateMergingCode(printer);
+ field_generators_.get(descriptor_->field(i))
+ .GenerateMergingCode(printer);
}
}
// Merge oneof fields.
for (int i = 0; i < descriptor_->oneof_decl_count(); ++i) {
- printer->Print(
- "switch (other.get$oneof_capitalized_name$Case()) {\n",
- "oneof_capitalized_name",
- context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->capitalized_name);
+ printer->Print("switch (other.get$oneof_capitalized_name$Case()) {\n",
+ "oneof_capitalized_name",
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))
+ ->capitalized_name);
printer->Indent();
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
- printer->Print(
- "case $field_name$: {\n",
- "field_name",
- ToUpper(field->name()));
+ printer->Print("case $field_name$: {\n", "field_name",
+ ToUpper(field->name()));
printer->Indent();
field_generators_.get(field).GenerateMergingCode(printer);
- printer->Print(
- "break;\n");
+ printer->Print("break;\n");
printer->Outdent();
- printer->Print(
- "}\n");
+ printer->Print("}\n");
}
printer->Print(
- "case $cap_oneof_name$_NOT_SET: {\n"
- " break;\n"
- "}\n",
- "cap_oneof_name",
- ToUpper(context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->name));
+ "case $cap_oneof_name$_NOT_SET: {\n"
+ " break;\n"
+ "}\n",
+ "cap_oneof_name",
+ ToUpper(
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))
+ ->name));
printer->Outdent();
- printer->Print(
- "}\n");
+ printer->Print("}\n");
}
printer->Outdent();
// if message type has extensions
if (descriptor_->extension_range_count() > 0) {
- printer->Print(
- " this.mergeExtensionFields(other);\n");
+ printer->Print(" this.mergeExtensionFields(other);\n");
}
- printer->Print(
- " this.mergeUnknownFields(other.unknownFields);\n");
+ printer->Print(" this.mergeUnknownFields(other.unknownFields);\n");
+
+ printer->Print(" onChanged();\n");
printer->Print(
- " onChanged();\n");
-
- printer->Print(
- " return this;\n"
- "}\n"
- "\n");
+ " return this;\n"
+ "}\n"
+ "\n");
}
}
// ===================================================================
-void MessageBuilderGenerator::
-GenerateBuilderParsingMethods(io::Printer* printer) {
+void MessageBuilderGenerator::GenerateBuilderParsingMethods(
+ io::Printer* printer) {
printer->Print(
- "@java.lang.Override\n"
- "public Builder mergeFrom(\n"
- " com.google.protobuf.CodedInputStream input,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws java.io.IOException {\n"
- " $classname$ parsedMessage = null;\n"
- " try {\n"
- " parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);\n"
- " } catch (com.google.protobuf.InvalidProtocolBufferException e) {\n"
- " parsedMessage = ($classname$) e.getUnfinishedMessage();\n"
- " throw e.unwrapIOException();\n"
- " } finally {\n"
- " if (parsedMessage != null) {\n"
- " mergeFrom(parsedMessage);\n"
- " }\n"
- " }\n"
- " return this;\n"
- "}\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "@java.lang.Override\n"
+ "public Builder mergeFrom(\n"
+ " com.google.protobuf.CodedInputStream input,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws java.io.IOException {\n"
+ " $classname$ parsedMessage = null;\n"
+ " try {\n"
+ " parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);\n"
+ " } catch (com.google.protobuf.InvalidProtocolBufferException e) {\n"
+ " parsedMessage = ($classname$) e.getUnfinishedMessage();\n"
+ " throw e.unwrapIOException();\n"
+ " } finally {\n"
+ " if (parsedMessage != null) {\n"
+ " mergeFrom(parsedMessage);\n"
+ " }\n"
+ " }\n"
+ " return this;\n"
+ "}\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
}
// ===================================================================
-void MessageBuilderGenerator::GenerateIsInitialized(
- io::Printer* printer) {
+void MessageBuilderGenerator::GenerateIsInitialized(io::Printer* printer) {
printer->Print(
- "@java.lang.Override\n"
- "public final boolean isInitialized() {\n");
+ "@java.lang.Override\n"
+ "public final boolean isInitialized() {\n");
printer->Indent();
// Check that all required fields in this message are set.
@@ -643,10 +633,10 @@
if (field->is_required()) {
printer->Print(
- "if (!has$name$()) {\n"
- " return false;\n"
- "}\n",
- "name", info->capitalized_name);
+ "if (!has$name$()) {\n"
+ " return false;\n"
+ "}\n",
+ "name", info->capitalized_name);
}
}
@@ -659,12 +649,12 @@
switch (field->label()) {
case FieldDescriptor::LABEL_REQUIRED:
printer->Print(
- "if (!get$name$().isInitialized()) {\n"
- " return false;\n"
- "}\n",
- "type", name_resolver_->GetImmutableClassName(
- field->message_type()),
- "name", info->capitalized_name);
+ "if (!get$name$().isInitialized()) {\n"
+ " return false;\n"
+ "}\n",
+ "type",
+ name_resolver_->GetImmutableClassName(field->message_type()),
+ "name", info->capitalized_name);
break;
case FieldDescriptor::LABEL_OPTIONAL:
if (!SupportFieldPresence(descriptor_->file()) &&
@@ -676,38 +666,38 @@
"oneof_name", oneof_info->name, "field_number",
StrCat(field->number()));
} else {
- printer->Print(
- "if (has$name$()) {\n",
- "name", info->capitalized_name);
+ printer->Print("if (has$name$()) {\n", "name",
+ info->capitalized_name);
}
printer->Print(
- " if (!get$name$().isInitialized()) {\n"
- " return false;\n"
- " }\n"
- "}\n",
- "name", info->capitalized_name);
+ " if (!get$name$().isInitialized()) {\n"
+ " return false;\n"
+ " }\n"
+ "}\n",
+ "name", info->capitalized_name);
break;
case FieldDescriptor::LABEL_REPEATED:
if (IsMapEntry(field->message_type())) {
printer->Print(
- "for ($type$ item : get$name$Map().values()) {\n"
- " if (!item.isInitialized()) {\n"
- " return false;\n"
- " }\n"
- "}\n",
- "type", MapValueImmutableClassdName(field->message_type(),
- name_resolver_),
- "name", info->capitalized_name);
+ "for ($type$ item : get$name$Map().values()) {\n"
+ " if (!item.isInitialized()) {\n"
+ " return false;\n"
+ " }\n"
+ "}\n",
+ "type",
+ MapValueImmutableClassdName(field->message_type(),
+ name_resolver_),
+ "name", info->capitalized_name);
} else {
printer->Print(
- "for (int i = 0; i < get$name$Count(); i++) {\n"
- " if (!get$name$(i).isInitialized()) {\n"
- " return false;\n"
- " }\n"
- "}\n",
- "type", name_resolver_->GetImmutableClassName(
- field->message_type()),
- "name", info->capitalized_name);
+ "for (int i = 0; i < get$name$Count(); i++) {\n"
+ " if (!get$name$(i).isInitialized()) {\n"
+ " return false;\n"
+ " }\n"
+ "}\n",
+ "type",
+ name_resolver_->GetImmutableClassName(field->message_type()),
+ "name", info->capitalized_name);
}
break;
}
@@ -716,17 +706,17 @@
if (descriptor_->extension_range_count() > 0) {
printer->Print(
- "if (!extensionsAreInitialized()) {\n"
- " return false;\n"
- "}\n");
+ "if (!extensionsAreInitialized()) {\n"
+ " return false;\n"
+ "}\n");
}
printer->Outdent();
printer->Print(
- " return true;\n"
- "}\n"
- "\n");
+ " return true;\n"
+ "}\n"
+ "\n");
}
// ===================================================================
diff --git a/src/google/protobuf/compiler/java/java_message_builder.h b/src/google/protobuf/compiler/java/java_message_builder.h
index d67a9c9..a31d0ba 100644
--- a/src/google/protobuf/compiler/java/java_message_builder.h
+++ b/src/google/protobuf/compiler/java/java_message_builder.h
@@ -35,8 +35,8 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_BUILDER_H__
#define GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_BUILDER_H__
-#include <string>
#include <map>
+#include <string>
#include <google/protobuf/compiler/java/java_field.h>
namespace google {
diff --git a/src/google/protobuf/compiler/java/java_message_builder_lite.cc b/src/google/protobuf/compiler/java/java_message_builder_lite.cc
index 0e2de15..ae34499 100644
--- a/src/google/protobuf/compiler/java/java_message_builder_lite.cc
+++ b/src/google/protobuf/compiler/java/java_message_builder_lite.cc
@@ -61,9 +61,10 @@
MessageBuilderLiteGenerator::MessageBuilderLiteGenerator(
const Descriptor* descriptor, Context* context)
- : descriptor_(descriptor), context_(context),
- name_resolver_(context->GetNameResolver()),
- field_generators_(descriptor, context_) {
+ : descriptor_(descriptor),
+ context_(context),
+ name_resolver_(context->GetNameResolver()),
+ field_generators_(descriptor, context_) {
GOOGLE_CHECK(!HasDescriptorMethods(descriptor->file(), context->EnforceLite()))
<< "Generator factory error: A lite message generator is used to "
"generate non-lite messages.";
@@ -71,19 +72,17 @@
MessageBuilderLiteGenerator::~MessageBuilderLiteGenerator() {}
-void MessageBuilderLiteGenerator::
-Generate(io::Printer* printer) {
+void MessageBuilderLiteGenerator::Generate(io::Printer* printer) {
WriteMessageDocComment(printer, descriptor_);
printer->Print(
- "public static final class Builder extends\n"
- " com.google.protobuf.GeneratedMessageLite.$extendible$Builder<\n"
- " $classname$, Builder> implements\n"
- " $extra_interfaces$\n"
- " $classname$OrBuilder {\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_),
- "extra_interfaces", ExtraBuilderInterfaces(descriptor_),
- "extendible",
- descriptor_->extension_range_count() > 0 ? "Extendable" : "");
+ "public static final class Builder extends\n"
+ " com.google.protobuf.GeneratedMessageLite.$extendible$Builder<\n"
+ " $classname$, Builder> implements\n"
+ " $extra_interfaces$\n"
+ " $classname$OrBuilder {\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_),
+ "extra_interfaces", ExtraBuilderInterfaces(descriptor_), "extendible",
+ descriptor_->extension_range_count() > 0 ? "Extendable" : "");
printer->Indent();
GenerateCommonBuilderMethods(printer);
@@ -91,38 +90,39 @@
// oneof
std::map<std::string, std::string> vars;
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
- vars["oneof_name"] = context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->name;
- vars["oneof_capitalized_name"] = context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->capitalized_name;
+ vars["oneof_name"] =
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))->name;
+ vars["oneof_capitalized_name"] =
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))
+ ->capitalized_name;
vars["oneof_index"] = StrCat(descriptor_->oneof_decl(i)->index());
// oneofCase() and clearOneof()
printer->Print(vars,
- "@java.lang.Override\n"
- "public $oneof_capitalized_name$Case\n"
- " get$oneof_capitalized_name$Case() {\n"
- " return instance.get$oneof_capitalized_name$Case();\n"
- "}\n"
- "\n"
- "public Builder clear$oneof_capitalized_name$() {\n"
- " copyOnWrite();\n"
- " instance.clear$oneof_capitalized_name$();\n"
- " return this;\n"
- "}\n"
- "\n");
+ "@java.lang.Override\n"
+ "public $oneof_capitalized_name$Case\n"
+ " get$oneof_capitalized_name$Case() {\n"
+ " return instance.get$oneof_capitalized_name$Case();\n"
+ "}\n"
+ "\n"
+ "public Builder clear$oneof_capitalized_name$() {\n"
+ " copyOnWrite();\n"
+ " instance.clear$oneof_capitalized_name$();\n"
+ " return this;\n"
+ "}\n"
+ "\n");
}
for (int i = 0; i < descriptor_->field_count(); i++) {
printer->Print("\n");
field_generators_.get(descriptor_->field(i))
- .GenerateBuilderMembers(printer);
+ .GenerateBuilderMembers(printer);
}
printer->Print(
- "\n"
- "// @@protoc_insertion_point(builder_scope:$full_name$)\n",
- "full_name", descriptor_->full_name());
+ "\n"
+ "// @@protoc_insertion_point(builder_scope:$full_name$)\n",
+ "full_name", descriptor_->full_name());
printer->Outdent();
printer->Print("}\n");
@@ -130,15 +130,15 @@
// ===================================================================
-void MessageBuilderLiteGenerator::
-GenerateCommonBuilderMethods(io::Printer* printer) {
+void MessageBuilderLiteGenerator::GenerateCommonBuilderMethods(
+ io::Printer* printer) {
printer->Print(
- "// Construct using $classname$.newBuilder()\n"
- "private Builder() {\n"
- " super(DEFAULT_INSTANCE);\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "// Construct using $classname$.newBuilder()\n"
+ "private Builder() {\n"
+ " super(DEFAULT_INSTANCE);\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
}
// ===================================================================
diff --git a/src/google/protobuf/compiler/java/java_message_builder_lite.h b/src/google/protobuf/compiler/java/java_message_builder_lite.h
index 079d86a..e0a48dc 100644
--- a/src/google/protobuf/compiler/java/java_message_builder_lite.h
+++ b/src/google/protobuf/compiler/java/java_message_builder_lite.h
@@ -35,8 +35,8 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_BUILDER_LITE_H__
#define GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_BUILDER_LITE_H__
-#include <string>
#include <map>
+#include <string>
#include <google/protobuf/compiler/java/java_field.h>
namespace google {
diff --git a/src/google/protobuf/compiler/java/java_message_field.cc b/src/google/protobuf/compiler/java/java_message_field.cc
index 011cc56..8c57675 100644
--- a/src/google/protobuf/compiler/java/java_message_field.cc
+++ b/src/google/protobuf/compiler/java/java_message_field.cc
@@ -36,9 +36,9 @@
#include <string>
#include <google/protobuf/compiler/java/java_context.h>
-#include <google/protobuf/compiler/java/java_message_field.h>
#include <google/protobuf/compiler/java/java_doc_comment.h>
#include <google/protobuf/compiler/java/java_helpers.h>
+#include <google/protobuf/compiler/java/java_message_field.h>
#include <google/protobuf/compiler/java/java_name_resolver.h>
#include <google/protobuf/io/printer.h>
#include <google/protobuf/wire_format.h>
@@ -62,17 +62,17 @@
(*variables)["mutable_type"] =
name_resolver->GetMutableClassName(descriptor->message_type());
(*variables)["group_or_message"] =
- (GetType(descriptor) == FieldDescriptor::TYPE_GROUP) ?
- "Group" : "Message";
+ (GetType(descriptor) == FieldDescriptor::TYPE_GROUP) ? "Group"
+ : "Message";
// TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
// by the proto compiler
- (*variables)["deprecation"] = descriptor->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ (*variables)["deprecation"] =
+ descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
(*variables)["on_changed"] = "onChanged();";
(*variables)["ver"] = GeneratedCodeVersionSuffix();
(*variables)["get_parser"] =
- ExposePublicParser(descriptor->message_type()->file())
- ? "PARSER" : "parser()";
+ ExposePublicParser(descriptor->message_type()->file()) ? "PARSER"
+ : "parser()";
if (SupportFieldPresence(descriptor->file())) {
// For singular messages and builders, one bit is used for the hasField bit.
@@ -119,17 +119,17 @@
// ===================================================================
-ImmutableMessageFieldGenerator::
-ImmutableMessageFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
- builderBitIndex_(builderBitIndex), context_(context),
- name_resolver_(context->GetNameResolver()) {
- SetMessageVariables(descriptor, messageBitIndex, builderBitIndex,
- context->GetFieldGeneratorInfo(descriptor),
- name_resolver_, &variables_);
+ImmutableMessageFieldGenerator::ImmutableMessageFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : descriptor_(descriptor),
+ messageBitIndex_(messageBitIndex),
+ builderBitIndex_(builderBitIndex),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
+ SetMessageVariables(descriptor, messageBitIndex, builderBitIndex,
+ context->GetFieldGeneratorInfo(descriptor),
+ name_resolver_, &variables_);
}
ImmutableMessageFieldGenerator::~ImmutableMessageFieldGenerator() {}
@@ -142,78 +142,80 @@
return GetNumBitsForMessage();
}
-void ImmutableMessageFieldGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void ImmutableMessageFieldGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
// TODO(jonp): In the future, consider having a method specific to the
// interface so that builders can choose dynamically to either return a
// message or a nested builder, so that asking for the interface doesn't
// cause a message to ever be built.
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$boolean has$capitalized_name$();\n");
+ printer->Print(variables_, "$deprecation$boolean has$capitalized_name$();\n");
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$();\n");
+ printer->Print(variables_, "$deprecation$$type$ get$capitalized_name$();\n");
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$$type$OrBuilder get$capitalized_name$OrBuilder();\n");
+ printer->Print(
+ variables_,
+ "$deprecation$$type$OrBuilder get$capitalized_name$OrBuilder();\n");
}
-void ImmutableMessageFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private $type$ $name$_;\n");
+void ImmutableMessageFieldGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_, "private $type$ $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$OrBuilder "
- "${$get$capitalized_name$OrBuilder$}$() {\n"
- " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public $type$OrBuilder "
+ "${$get$capitalized_name$OrBuilder$}$() {\n"
+ " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
} else {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $name$_ != null;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $name$_ != null;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$OrBuilder "
- "${$get$capitalized_name$OrBuilder$}$() {\n"
- " return get$capitalized_name$();\n"
- "}\n");
+ "$deprecation$public $type$OrBuilder "
+ "${$get$capitalized_name$OrBuilder$}$() {\n"
+ " return get$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
}
void ImmutableMessageFieldGenerator::PrintNestedBuilderCondition(
- io::Printer* printer,
- const char* regular_case,
+ io::Printer* printer, const char* regular_case,
const char* nested_builder_case) const {
printer->Print(variables_, "if ($name$Builder_ == null) {\n");
printer->Indent();
@@ -227,10 +229,8 @@
}
void ImmutableMessageFieldGenerator::PrintNestedBuilderFunction(
- io::Printer* printer,
- const char* method_prototype,
- const char* regular_case,
- const char* nested_builder_case,
+ io::Printer* printer, const char* method_prototype,
+ const char* regular_case, const char* nested_builder_case,
const char* trailing_code) const {
printer->Print(variables_, method_prototype);
printer->Annotate("{", "}", descriptor_);
@@ -244,8 +244,8 @@
printer->Print("}\n");
}
-void ImmutableMessageFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutableMessageFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
// When using nested-builders, the code initially works just like the
// non-nested builder case. It only creates a nested builder lazily on
// demand and then forever delegates to it after creation.
@@ -255,11 +255,11 @@
printer->Print(variables_, "private $type$ $name$_;\n");
printer->Print(variables_,
- // If this builder is non-null, it is used and the other fields are
- // ignored.
- "private com.google.protobuf.SingleFieldBuilder$ver$<\n"
- " $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;"
- "\n");
+ // If this builder is non-null, it is used and the other fields
+ // are ignored.
+ "private com.google.protobuf.SingleFieldBuilder$ver$<\n"
+ " $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;"
+ "\n");
// The comments above the methods below are based on a hypothetical
// field of type "Field" called "Field".
@@ -267,178 +267,178 @@
// boolean hasField()
WriteFieldDocComment(printer, descriptor_);
if (support_field_presence) {
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_builder$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_builder$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
} else {
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $name$Builder_ != null || $name$_ != null;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $name$Builder_ != null || $name$_ != null;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
// Field getField()
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$()",
- "return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n",
- "return $name$Builder_.getMessage();\n",
- NULL);
+ PrintNestedBuilderFunction(
+ printer, "$deprecation$public $type$ ${$get$capitalized_name$$}$()",
+ "return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n",
+ "return $name$Builder_.getMessage();\n", NULL);
// Field.Builder setField(Field value)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value)",
- "if (value == null) {\n"
- " throw new NullPointerException();\n"
- "}\n"
- "$name$_ = value;\n"
- "$on_changed$\n",
+ "if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ "}\n"
+ "$name$_ = value;\n"
+ "$on_changed$\n",
- "$name$Builder_.setMessage(value);\n",
+ "$name$Builder_.setMessage(value);\n",
- "$set_has_field_bit_builder$\n"
- "return this;\n");
+ "$set_has_field_bit_builder$\n"
+ "return this;\n");
// Field.Builder setField(Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " $type$.Builder builderForValue)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " $type$.Builder builderForValue)",
- "$name$_ = builderForValue.build();\n"
- "$on_changed$\n",
+ "$name$_ = builderForValue.build();\n"
+ "$on_changed$\n",
- "$name$Builder_.setMessage(builderForValue.build());\n",
+ "$name$Builder_.setMessage(builderForValue.build());\n",
- "$set_has_field_bit_builder$\n"
- "return this;\n");
+ "$set_has_field_bit_builder$\n"
+ "return this;\n");
// Field.Builder mergeField(Field value)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$merge$capitalized_name$$}$($type$ value)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$merge$capitalized_name$$}$($type$ value)",
- support_field_presence
- ? "if ($get_has_field_bit_builder$ &&\n"
- " $name$_ != null &&\n"
- " $name$_ != $type$.getDefaultInstance()) {\n"
- " $name$_ =\n"
- " $type$.newBuilder($name$_).mergeFrom(value).buildPartial();\n"
- "} else {\n"
- " $name$_ = value;\n"
- "}\n"
- "$on_changed$\n"
- : "if ($name$_ != null) {\n"
- " $name$_ =\n"
- " $type$.newBuilder($name$_).mergeFrom(value).buildPartial();\n"
- "} else {\n"
- " $name$_ = value;\n"
- "}\n"
- "$on_changed$\n",
+ support_field_presence
+ ? "if ($get_has_field_bit_builder$ &&\n"
+ " $name$_ != null &&\n"
+ " $name$_ != $type$.getDefaultInstance()) {\n"
+ " $name$_ =\n"
+ " $type$.newBuilder($name$_).mergeFrom(value).buildPartial();\n"
+ "} else {\n"
+ " $name$_ = value;\n"
+ "}\n"
+ "$on_changed$\n"
+ : "if ($name$_ != null) {\n"
+ " $name$_ =\n"
+ " $type$.newBuilder($name$_).mergeFrom(value).buildPartial();\n"
+ "} else {\n"
+ " $name$_ = value;\n"
+ "}\n"
+ "$on_changed$\n",
- "$name$Builder_.mergeFrom(value);\n",
+ "$name$Builder_.mergeFrom(value);\n",
- "$set_has_field_bit_builder$\n"
- "return this;\n");
+ "$set_has_field_bit_builder$\n"
+ "return this;\n");
// Field.Builder clearField()
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$()",
-
- "$name$_ = null;\n"
- "$on_changed$\n",
-
- support_field_presence
- ? "$name$Builder_.clear();\n"
- : "$name$_ = null;\n"
- "$name$Builder_ = null;\n",
-
- "$clear_has_field_bit_builder$\n"
- "return this;\n");
-
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$.Builder "
- "${$get$capitalized_name$Builder$}$() {\n"
- " $set_has_field_bit_builder$\n"
- " $on_changed$\n"
- " return get$capitalized_name$FieldBuilder().getBuilder();\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$OrBuilder "
- "${$get$capitalized_name$OrBuilder$}$() {\n"
- " if ($name$Builder_ != null) {\n"
- " return $name$Builder_.getMessageOrBuilder();\n"
- " } else {\n"
- " return $name$_ == null ?\n"
- " $type$.getDefaultInstance() : $name$_;\n"
- " }\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private com.google.protobuf.SingleFieldBuilder$ver$<\n"
- " $type$, $type$.Builder, $type$OrBuilder> \n"
- " get$capitalized_name$FieldBuilder() {\n"
- " if ($name$Builder_ == null) {\n"
- " $name$Builder_ = new com.google.protobuf.SingleFieldBuilder$ver$<\n"
- " $type$, $type$.Builder, $type$OrBuilder>(\n"
- " get$capitalized_name$(),\n"
- " getParentForChildren(),\n"
- " isClean());\n"
- " $name$_ = null;\n"
- " }\n"
- " return $name$Builder_;\n"
- "}\n");
-}
-
-void ImmutableMessageFieldGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
- if (SupportFieldPresence(descriptor_->file())) {
- printer->Print(variables_,
- "get$capitalized_name$FieldBuilder();\n");
- }
-}
-
-
-void ImmutableMessageFieldGenerator::
-GenerateInitializationCode(io::Printer* printer) const {}
-
-void ImmutableMessageFieldGenerator::
-GenerateBuilderClearCode(io::Printer* printer) const {
- if (SupportFieldPresence(descriptor_->file())) {
- PrintNestedBuilderCondition(printer,
- "$name$_ = null;\n",
-
- "$name$Builder_.clear();\n");
- printer->Print(variables_, "$clear_has_field_bit_builder$\n");
- } else {
- PrintNestedBuilderCondition(printer,
- "$name$_ = null;\n",
+ PrintNestedBuilderFunction(
+ printer, "$deprecation$public Builder ${$clear$capitalized_name$$}$()",
"$name$_ = null;\n"
- "$name$Builder_ = null;\n");
+ "$on_changed$\n",
+
+ support_field_presence ? "$name$Builder_.clear();\n"
+ : "$name$_ = null;\n"
+ "$name$Builder_ = null;\n",
+
+ "$clear_has_field_bit_builder$\n"
+ "return this;\n");
+
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public $type$.Builder "
+ "${$get$capitalized_name$Builder$}$() {\n"
+ " $set_has_field_bit_builder$\n"
+ " $on_changed$\n"
+ " return get$capitalized_name$FieldBuilder().getBuilder();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public $type$OrBuilder "
+ "${$get$capitalized_name$OrBuilder$}$() {\n"
+ " if ($name$Builder_ != null) {\n"
+ " return $name$Builder_.getMessageOrBuilder();\n"
+ " } else {\n"
+ " return $name$_ == null ?\n"
+ " $type$.getDefaultInstance() : $name$_;\n"
+ " }\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "private com.google.protobuf.SingleFieldBuilder$ver$<\n"
+ " $type$, $type$.Builder, $type$OrBuilder> \n"
+ " get$capitalized_name$FieldBuilder() {\n"
+ " if ($name$Builder_ == null) {\n"
+ " $name$Builder_ = new com.google.protobuf.SingleFieldBuilder$ver$<\n"
+ " $type$, $type$.Builder, $type$OrBuilder>(\n"
+ " get$capitalized_name$(),\n"
+ " getParentForChildren(),\n"
+ " isClean());\n"
+ " $name$_ = null;\n"
+ " }\n"
+ " return $name$Builder_;\n"
+ "}\n");
+}
+
+void ImmutableMessageFieldGenerator::GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const {
+ if (SupportFieldPresence(descriptor_->file())) {
+ printer->Print(variables_, "get$capitalized_name$FieldBuilder();\n");
}
}
-void ImmutableMessageFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (other.has$capitalized_name$()) {\n"
- " merge$capitalized_name$(other.get$capitalized_name$());\n"
- "}\n");
+void ImmutableMessageFieldGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {}
+
+void ImmutableMessageFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
+ if (SupportFieldPresence(descriptor_->file())) {
+ PrintNestedBuilderCondition(printer, "$name$_ = null;\n",
+
+ "$name$Builder_.clear();\n");
+ printer->Print(variables_, "$clear_has_field_bit_builder$\n");
+ } else {
+ PrintNestedBuilderCondition(printer, "$name$_ = null;\n",
+
+ "$name$_ = null;\n"
+ "$name$Builder_ = null;\n");
+ }
}
-void ImmutableMessageFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
+void ImmutableMessageFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
+ printer->Print(variables_,
+ "if (other.has$capitalized_name$()) {\n"
+ " merge$capitalized_name$(other.get$capitalized_name$());\n"
+ "}\n");
+}
+
+void ImmutableMessageFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
printer->Print(variables_, "if ($get_has_field_bit_from_local$) {\n");
printer->Indent();
@@ -454,65 +454,68 @@
}
}
-void ImmutableMessageFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void ImmutableMessageFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "$type$.Builder subBuilder = null;\n"
- "if ($is_field_present_message$) {\n"
- " subBuilder = $name$_.toBuilder();\n"
- "}\n");
+ "$type$.Builder subBuilder = null;\n"
+ "if ($is_field_present_message$) {\n"
+ " subBuilder = $name$_.toBuilder();\n"
+ "}\n");
if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
printer->Print(variables_,
- "$name$_ = input.readGroup($number$, $type$.$get_parser$,\n"
- " extensionRegistry);\n");
+ "$name$_ = input.readGroup($number$, $type$.$get_parser$,\n"
+ " extensionRegistry);\n");
} else {
printer->Print(variables_,
- "$name$_ = input.readMessage($type$.$get_parser$, extensionRegistry);\n");
+ "$name$_ = input.readMessage($type$.$get_parser$, "
+ "extensionRegistry);\n");
}
printer->Print(variables_,
- "if (subBuilder != null) {\n"
- " subBuilder.mergeFrom($name$_);\n"
- " $name$_ = subBuilder.buildPartial();\n"
- "}\n"
- "$set_has_field_bit_message$\n");
+ "if (subBuilder != null) {\n"
+ " subBuilder.mergeFrom($name$_);\n"
+ " $name$_ = subBuilder.buildPartial();\n"
+ "}\n"
+ "$set_has_field_bit_message$\n");
}
-void ImmutableMessageFieldGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
+void ImmutableMessageFieldGenerator::GenerateParsingDoneCode(
+ io::Printer* printer) const {
// noop for messages.
}
-void ImmutableMessageFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " output.write$group_or_message$($number$, get$capitalized_name$());\n"
- "}\n");
+void ImmutableMessageFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if ($is_field_present_message$) {\n"
+ " output.write$group_or_message$($number$, get$capitalized_name$());\n"
+ "}\n");
}
-void ImmutableMessageFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .compute$group_or_message$Size($number$, get$capitalized_name$());\n"
- "}\n");
+void ImmutableMessageFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if ($is_field_present_message$) {\n"
+ " size += com.google.protobuf.CodedOutputStream\n"
+ " .compute$group_or_message$Size($number$, get$capitalized_name$());\n"
+ "}\n");
}
-void ImmutableMessageFieldGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
+void ImmutableMessageFieldGenerator::GenerateEqualsCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if (!get$capitalized_name$()\n"
- " .equals(other.get$capitalized_name$())) return false;\n");
+ "if (!get$capitalized_name$()\n"
+ " .equals(other.get$capitalized_name$())) return false;\n");
}
-void ImmutableMessageFieldGenerator::
-GenerateHashCode(io::Printer* printer) const {
+void ImmutableMessageFieldGenerator::GenerateHashCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n"
- "hash = (53 * hash) + get$capitalized_name$().hashCode();\n");
+ "hash = (37 * hash) + $constant_name$;\n"
+ "hash = (53 * hash) + get$capitalized_name$().hashCode();\n");
}
std::string ImmutableMessageFieldGenerator::GetBoxedType() const {
@@ -521,63 +524,60 @@
// ===================================================================
-ImmutableMessageOneofFieldGenerator::
-ImmutableMessageOneofFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : ImmutableMessageFieldGenerator(
- descriptor, messageBitIndex, builderBitIndex, context) {
+ImmutableMessageOneofFieldGenerator::ImmutableMessageOneofFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : ImmutableMessageFieldGenerator(descriptor, messageBitIndex,
+ builderBitIndex, context) {
const OneofGeneratorInfo* info =
context->GetOneofGeneratorInfo(descriptor->containing_oneof());
SetCommonOneofVariables(descriptor, info, &variables_);
}
-ImmutableMessageOneofFieldGenerator::
-~ImmutableMessageOneofFieldGenerator() {}
+ImmutableMessageOneofFieldGenerator::~ImmutableMessageOneofFieldGenerator() {}
-void ImmutableMessageOneofFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutableMessageOneofFieldGenerator::GenerateMembers(
+ io::Printer* printer) const {
PrintExtraFieldInfo(variables_, printer);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " return ($type$) $oneof_name$_;\n"
- " }\n"
- " return $type$.getDefaultInstance();\n"
- "}\n");
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " return ($type$) $oneof_name$_;\n"
+ " }\n"
+ " return $type$.getDefaultInstance();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$OrBuilder "
- "${$get$capitalized_name$OrBuilder$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " return ($type$) $oneof_name$_;\n"
- " }\n"
- " return $type$.getDefaultInstance();\n"
- "}\n");
+ "$deprecation$public $type$OrBuilder "
+ "${$get$capitalized_name$OrBuilder$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " return ($type$) $oneof_name$_;\n"
+ " }\n"
+ " return $type$.getDefaultInstance();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutableMessageOneofFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutableMessageOneofFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
// When using nested-builders, the code initially works just like the
// non-nested builder case. It only creates a nested builder lazily on
// demand and then forever delegates to it after creation.
printer->Print(variables_,
- // If this builder is non-null, it is used and the other fields are
- // ignored.
- "private com.google.protobuf.SingleFieldBuilder$ver$<\n"
- " $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;"
- "\n");
+ // If this builder is non-null, it is used and the other fields
+ // are ignored.
+ "private com.google.protobuf.SingleFieldBuilder$ver$<\n"
+ " $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;"
+ "\n");
// The comments above the methods below are based on a hypothetical
// field of type "Field" called "Field".
@@ -585,226 +585,232 @@
// boolean hasField()
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Field getField()
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$()",
+ PrintNestedBuilderFunction(
+ printer, "$deprecation$public $type$ ${$get$capitalized_name$$}$()",
- "if ($has_oneof_case_message$) {\n"
- " return ($type$) $oneof_name$_;\n"
- "}\n"
- "return $type$.getDefaultInstance();\n",
+ "if ($has_oneof_case_message$) {\n"
+ " return ($type$) $oneof_name$_;\n"
+ "}\n"
+ "return $type$.getDefaultInstance();\n",
- "if ($has_oneof_case_message$) {\n"
- " return $name$Builder_.getMessage();\n"
- "}\n"
- "return $type$.getDefaultInstance();\n",
+ "if ($has_oneof_case_message$) {\n"
+ " return $name$Builder_.getMessage();\n"
+ "}\n"
+ "return $type$.getDefaultInstance();\n",
- NULL);
+ NULL);
// Field.Builder setField(Field value)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value)",
- "if (value == null) {\n"
- " throw new NullPointerException();\n"
- "}\n"
- "$oneof_name$_ = value;\n"
- "$on_changed$\n",
+ "if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ "}\n"
+ "$oneof_name$_ = value;\n"
+ "$on_changed$\n",
- "$name$Builder_.setMessage(value);\n",
+ "$name$Builder_.setMessage(value);\n",
- "$set_oneof_case_message$;\n"
- "return this;\n");
+ "$set_oneof_case_message$;\n"
+ "return this;\n");
// Field.Builder setField(Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " $type$.Builder builderForValue)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " $type$.Builder builderForValue)",
- "$oneof_name$_ = builderForValue.build();\n"
- "$on_changed$\n",
+ "$oneof_name$_ = builderForValue.build();\n"
+ "$on_changed$\n",
- "$name$Builder_.setMessage(builderForValue.build());\n",
+ "$name$Builder_.setMessage(builderForValue.build());\n",
- "$set_oneof_case_message$;\n"
- "return this;\n");
+ "$set_oneof_case_message$;\n"
+ "return this;\n");
// Field.Builder mergeField(Field value)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$merge$capitalized_name$$}$($type$ value)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$merge$capitalized_name$$}$($type$ value)",
- "if ($has_oneof_case_message$ &&\n"
- " $oneof_name$_ != $type$.getDefaultInstance()) {\n"
- " $oneof_name$_ = $type$.newBuilder(($type$) $oneof_name$_)\n"
- " .mergeFrom(value).buildPartial();\n"
- "} else {\n"
- " $oneof_name$_ = value;\n"
- "}\n"
- "$on_changed$\n",
+ "if ($has_oneof_case_message$ &&\n"
+ " $oneof_name$_ != $type$.getDefaultInstance()) {\n"
+ " $oneof_name$_ = $type$.newBuilder(($type$) $oneof_name$_)\n"
+ " .mergeFrom(value).buildPartial();\n"
+ "} else {\n"
+ " $oneof_name$_ = value;\n"
+ "}\n"
+ "$on_changed$\n",
- "if ($has_oneof_case_message$) {\n"
- " $name$Builder_.mergeFrom(value);\n"
- "}\n"
- "$name$Builder_.setMessage(value);\n",
+ "if ($has_oneof_case_message$) {\n"
+ " $name$Builder_.mergeFrom(value);\n"
+ "}\n"
+ "$name$Builder_.setMessage(value);\n",
- "$set_oneof_case_message$;\n"
- "return this;\n");
+ "$set_oneof_case_message$;\n"
+ "return this;\n");
// Field.Builder clearField()
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$()",
+ PrintNestedBuilderFunction(
+ printer, "$deprecation$public Builder ${$clear$capitalized_name$$}$()",
- "if ($has_oneof_case_message$) {\n"
- " $clear_oneof_case_message$;\n"
- " $oneof_name$_ = null;\n"
- " $on_changed$\n"
- "}\n",
+ "if ($has_oneof_case_message$) {\n"
+ " $clear_oneof_case_message$;\n"
+ " $oneof_name$_ = null;\n"
+ " $on_changed$\n"
+ "}\n",
- "if ($has_oneof_case_message$) {\n"
- " $clear_oneof_case_message$;\n"
- " $oneof_name$_ = null;\n"
- "}\n"
- "$name$Builder_.clear();\n",
+ "if ($has_oneof_case_message$) {\n"
+ " $clear_oneof_case_message$;\n"
+ " $oneof_name$_ = null;\n"
+ "}\n"
+ "$name$Builder_.clear();\n",
- "return this;\n");
+ "return this;\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$.Builder "
- "${$get$capitalized_name$Builder$}$() {\n"
- " return get$capitalized_name$FieldBuilder().getBuilder();\n"
- "}\n");
+ "$deprecation$public $type$.Builder "
+ "${$get$capitalized_name$Builder$}$() {\n"
+ " return get$capitalized_name$FieldBuilder().getBuilder();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$OrBuilder "
- "${$get$capitalized_name$OrBuilder$}$() {\n"
- " if (($has_oneof_case_message$) && ($name$Builder_ != null)) {\n"
- " return $name$Builder_.getMessageOrBuilder();\n"
- " } else {\n"
- " if ($has_oneof_case_message$) {\n"
- " return ($type$) $oneof_name$_;\n"
- " }\n"
- " return $type$.getDefaultInstance();\n"
- " }\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public $type$OrBuilder "
+ "${$get$capitalized_name$OrBuilder$}$() {\n"
+ " if (($has_oneof_case_message$) && ($name$Builder_ != null)) {\n"
+ " return $name$Builder_.getMessageOrBuilder();\n"
+ " } else {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " return ($type$) $oneof_name$_;\n"
+ " }\n"
+ " return $type$.getDefaultInstance();\n"
+ " }\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private com.google.protobuf.SingleFieldBuilder$ver$<\n"
- " $type$, $type$.Builder, $type$OrBuilder> \n"
- " ${$get$capitalized_name$FieldBuilder$}$() {\n"
- " if ($name$Builder_ == null) {\n"
- " if (!($has_oneof_case_message$)) {\n"
- " $oneof_name$_ = $type$.getDefaultInstance();\n"
- " }\n"
- " $name$Builder_ = new com.google.protobuf.SingleFieldBuilder$ver$<\n"
- " $type$, $type$.Builder, $type$OrBuilder>(\n"
- " ($type$) $oneof_name$_,\n"
- " getParentForChildren(),\n"
- " isClean());\n"
- " $oneof_name$_ = null;\n"
- " }\n"
- " $set_oneof_case_message$;\n"
- " $on_changed$;\n"
- " return $name$Builder_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "private com.google.protobuf.SingleFieldBuilder$ver$<\n"
+ " $type$, $type$.Builder, $type$OrBuilder> \n"
+ " ${$get$capitalized_name$FieldBuilder$}$() {\n"
+ " if ($name$Builder_ == null) {\n"
+ " if (!($has_oneof_case_message$)) {\n"
+ " $oneof_name$_ = $type$.getDefaultInstance();\n"
+ " }\n"
+ " $name$Builder_ = new com.google.protobuf.SingleFieldBuilder$ver$<\n"
+ " $type$, $type$.Builder, $type$OrBuilder>(\n"
+ " ($type$) $oneof_name$_,\n"
+ " getParentForChildren(),\n"
+ " isClean());\n"
+ " $oneof_name$_ = null;\n"
+ " }\n"
+ " $set_oneof_case_message$;\n"
+ " $on_changed$;\n"
+ " return $name$Builder_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutableMessageOneofFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
-
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n");
+void ImmutableMessageOneofFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
+ printer->Print(variables_, "if ($has_oneof_case_message$) {\n");
printer->Indent();
- PrintNestedBuilderCondition(printer,
- "result.$oneof_name$_ = $oneof_name$_;\n",
+ PrintNestedBuilderCondition(
+ printer, "result.$oneof_name$_ = $oneof_name$_;\n",
- "result.$oneof_name$_ = $name$Builder_.build();\n");
+ "result.$oneof_name$_ = $name$Builder_.build();\n");
printer->Outdent();
printer->Print("}\n");
}
-void ImmutableMessageOneofFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void ImmutableMessageOneofFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "merge$capitalized_name$(other.get$capitalized_name$());\n");
+ "merge$capitalized_name$(other.get$capitalized_name$());\n");
}
-void ImmutableMessageOneofFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void ImmutableMessageOneofFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "$type$.Builder subBuilder = null;\n"
- "if ($has_oneof_case_message$) {\n"
- " subBuilder = (($type$) $oneof_name$_).toBuilder();\n"
- "}\n");
+ "$type$.Builder subBuilder = null;\n"
+ "if ($has_oneof_case_message$) {\n"
+ " subBuilder = (($type$) $oneof_name$_).toBuilder();\n"
+ "}\n");
if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
- printer->Print(variables_,
- "$oneof_name$_ = input.readGroup($number$, $type$.$get_parser$,\n"
- " extensionRegistry);\n");
+ printer->Print(
+ variables_,
+ "$oneof_name$_ = input.readGroup($number$, $type$.$get_parser$,\n"
+ " extensionRegistry);\n");
} else {
- printer->Print(variables_,
- "$oneof_name$_ =\n"
- " input.readMessage($type$.$get_parser$, extensionRegistry);\n");
+ printer->Print(
+ variables_,
+ "$oneof_name$_ =\n"
+ " input.readMessage($type$.$get_parser$, extensionRegistry);\n");
}
printer->Print(variables_,
- "if (subBuilder != null) {\n"
- " subBuilder.mergeFrom(($type$) $oneof_name$_);\n"
- " $oneof_name$_ = subBuilder.buildPartial();\n"
- "}\n");
- printer->Print(variables_,
- "$set_oneof_case_message$;\n");
+ "if (subBuilder != null) {\n"
+ " subBuilder.mergeFrom(($type$) $oneof_name$_);\n"
+ " $oneof_name$_ = subBuilder.buildPartial();\n"
+ "}\n");
+ printer->Print(variables_, "$set_oneof_case_message$;\n");
}
-void ImmutableMessageOneofFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " output.write$group_or_message$($number$, ($type$) $oneof_name$_);\n"
- "}\n");
+void ImmutableMessageOneofFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if ($has_oneof_case_message$) {\n"
+ " output.write$group_or_message$($number$, ($type$) $oneof_name$_);\n"
+ "}\n");
}
-void ImmutableMessageOneofFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .compute$group_or_message$Size($number$, ($type$) $oneof_name$_);\n"
- "}\n");
+void ImmutableMessageOneofFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if ($has_oneof_case_message$) {\n"
+ " size += com.google.protobuf.CodedOutputStream\n"
+ " .compute$group_or_message$Size($number$, ($type$) $oneof_name$_);\n"
+ "}\n");
}
// ===================================================================
-RepeatedImmutableMessageFieldGenerator::
-RepeatedImmutableMessageFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
- builderBitIndex_(builderBitIndex), context_(context),
- name_resolver_(context->GetNameResolver()) {
+RepeatedImmutableMessageFieldGenerator::RepeatedImmutableMessageFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : descriptor_(descriptor),
+ messageBitIndex_(messageBitIndex),
+ builderBitIndex_(builderBitIndex),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
SetMessageVariables(descriptor, messageBitIndex, builderBitIndex,
context->GetFieldGeneratorInfo(descriptor),
name_resolver_, &variables_);
}
RepeatedImmutableMessageFieldGenerator::
-~RepeatedImmutableMessageFieldGenerator() {}
+ ~RepeatedImmutableMessageFieldGenerator() {}
int RepeatedImmutableMessageFieldGenerator::GetNumBitsForMessage() const {
return 0;
@@ -814,78 +820,79 @@
return 1;
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void RepeatedImmutableMessageFieldGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
// TODO(jonp): In the future, consider having methods specific to the
// interface so that builders can choose dynamically to either return a
// message or a nested builder, so that asking for the interface doesn't
// cause a message to ever be built.
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.util.List<$type$> \n"
- " get$capitalized_name$List();\n");
+ "$deprecation$java.util.List<$type$> \n"
+ " get$capitalized_name$List();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$(int index);\n");
+ "$deprecation$$type$ get$capitalized_name$(int index);\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Count();\n");
+ "$deprecation$int get$capitalized_name$Count();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.util.List<? extends $type$OrBuilder> \n"
- " get$capitalized_name$OrBuilderList();\n");
+ "$deprecation$java.util.List<? extends $type$OrBuilder> \n"
+ " get$capitalized_name$OrBuilderList();\n");
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$$type$OrBuilder get$capitalized_name$OrBuilder(\n"
- " int index);\n");
+ printer->Print(
+ variables_,
+ "$deprecation$$type$OrBuilder get$capitalized_name$OrBuilder(\n"
+ " int index);\n");
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private java.util.List<$type$> $name$_;\n");
+void RepeatedImmutableMessageFieldGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_, "private java.util.List<$type$> $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public java.util.List<$type$> "
- "${$get$capitalized_name$List$}$() {\n"
- " return $name$_;\n" // note: unmodifiable list
- "}\n");
+ "$deprecation$public java.util.List<$type$> "
+ "${$get$capitalized_name$List$}$() {\n"
+ " return $name$_;\n" // note: unmodifiable list
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
+ " ${$get$capitalized_name$OrBuilderList$}$() {\n"
+ " return $name$_;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return $name$_.size();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
- " ${$get$capitalized_name$OrBuilderList$}$() {\n"
- " return $name$_;\n"
- "}\n");
+ "$deprecation$public $type$OrBuilder "
+ "${$get$capitalized_name$OrBuilder$}$(\n"
+ " int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return $name$_.size();\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
- " return $name$_.get(index);\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$OrBuilder "
- "${$get$capitalized_name$OrBuilder$}$(\n"
- " int index) {\n"
- " return $name$_.get(index);\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
-
}
void RepeatedImmutableMessageFieldGenerator::PrintNestedBuilderCondition(
- io::Printer* printer,
- const char* regular_case,
+ io::Printer* printer, const char* regular_case,
const char* nested_builder_case) const {
printer->Print(variables_, "if ($name$Builder_ == null) {\n");
printer->Indent();
@@ -899,10 +906,8 @@
}
void RepeatedImmutableMessageFieldGenerator::PrintNestedBuilderFunction(
- io::Printer* printer,
- const char* method_prototype,
- const char* regular_case,
- const char* nested_builder_case,
+ io::Printer* printer, const char* method_prototype,
+ const char* regular_case, const char* nested_builder_case,
const char* trailing_code) const {
printer->Print(variables_, method_prototype);
printer->Annotate("{", "}", descriptor_);
@@ -916,406 +921,429 @@
printer->Print("}\n");
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void RepeatedImmutableMessageFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
// When using nested-builders, the code initially works just like the
// non-nested builder case. It only creates a nested builder lazily on
// demand and then forever delegates to it after creation.
- printer->Print(variables_,
- // Used when the builder is null.
- // One field is the list and the other field keeps track of whether the
- // list is immutable. If it's immutable, the invariant is that it must
- // either an instance of Collections.emptyList() or it's an ArrayList
- // wrapped in a Collections.unmodifiableList() wrapper and nobody else has
- // a refererence to the underlying ArrayList. This invariant allows us to
- // share instances of lists between protocol buffers avoiding expensive
- // memory allocations. Note, immutable is a strong guarantee here -- not
- // just that the list cannot be modified via the reference but that the
- // list can never be modified.
- "private java.util.List<$type$> $name$_ =\n"
- " java.util.Collections.emptyList();\n"
+ printer->Print(
+ variables_,
+ // Used when the builder is null.
+ // One field is the list and the other field keeps track of whether the
+ // list is immutable. If it's immutable, the invariant is that it must
+ // either an instance of Collections.emptyList() or it's an ArrayList
+ // wrapped in a Collections.unmodifiableList() wrapper and nobody else has
+ // a refererence to the underlying ArrayList. This invariant allows us to
+ // share instances of lists between protocol buffers avoiding expensive
+ // memory allocations. Note, immutable is a strong guarantee here -- not
+ // just that the list cannot be modified via the reference but that the
+ // list can never be modified.
+ "private java.util.List<$type$> $name$_ =\n"
+ " java.util.Collections.emptyList();\n"
- "private void ensure$capitalized_name$IsMutable() {\n"
- " if (!$get_mutable_bit_builder$) {\n"
- " $name$_ = new java.util.ArrayList<$type$>($name$_);\n"
- " $set_mutable_bit_builder$;\n"
- " }\n"
- "}\n"
- "\n");
+ "private void ensure$capitalized_name$IsMutable() {\n"
+ " if (!$get_mutable_bit_builder$) {\n"
+ " $name$_ = new java.util.ArrayList<$type$>($name$_);\n"
+ " $set_mutable_bit_builder$;\n"
+ " }\n"
+ "}\n"
+ "\n");
- printer->Print(variables_,
- // If this builder is non-null, it is used and the other fields are
- // ignored.
- "private com.google.protobuf.RepeatedFieldBuilder$ver$<\n"
- " $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;\n"
- "\n");
+ printer->Print(
+ variables_,
+ // If this builder is non-null, it is used and the other fields are
+ // ignored.
+ "private com.google.protobuf.RepeatedFieldBuilder$ver$<\n"
+ " $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;\n"
+ "\n");
// The comments above the methods below are based on a hypothetical
// repeated field of type "Field" called "RepeatedField".
// List<Field> getRepeatedFieldList()
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public java.util.List<$type$> "
- "${$get$capitalized_name$List$}$()",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public java.util.List<$type$> "
+ "${$get$capitalized_name$List$}$()",
- "return java.util.Collections.unmodifiableList($name$_);\n",
- "return $name$Builder_.getMessageList();\n",
+ "return java.util.Collections.unmodifiableList($name$_);\n",
+ "return $name$Builder_.getMessageList();\n",
- NULL);
+ NULL);
// int getRepeatedFieldCount()
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public int ${$get$capitalized_name$Count$}$()",
+ PrintNestedBuilderFunction(
+ printer, "$deprecation$public int ${$get$capitalized_name$Count$}$()",
- "return $name$_.size();\n",
- "return $name$Builder_.getCount();\n",
+ "return $name$_.size();\n", "return $name$Builder_.getCount();\n",
- NULL);
+ NULL);
// Field getRepeatedField(int index)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index)",
- "return $name$_.get(index);\n",
+ "return $name$_.get(index);\n",
- "return $name$Builder_.getMessage(index);\n",
+ "return $name$Builder_.getMessage(index);\n",
- NULL);
+ NULL);
// Builder setRepeatedField(int index, Field value)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " int index, $type$ value)",
- "if (value == null) {\n"
- " throw new NullPointerException();\n"
- "}\n"
- "ensure$capitalized_name$IsMutable();\n"
- "$name$_.set(index, value);\n"
- "$on_changed$\n",
- "$name$Builder_.setMessage(index, value);\n",
- "return this;\n");
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " int index, $type$ value)",
+ "if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ "}\n"
+ "ensure$capitalized_name$IsMutable();\n"
+ "$name$_.set(index, value);\n"
+ "$on_changed$\n",
+ "$name$Builder_.setMessage(index, value);\n", "return this;\n");
// Builder setRepeatedField(int index, Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " int index, $type$.Builder builderForValue)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " int index, $type$.Builder builderForValue)",
- "ensure$capitalized_name$IsMutable();\n"
- "$name$_.set(index, builderForValue.build());\n"
- "$on_changed$\n",
+ "ensure$capitalized_name$IsMutable();\n"
+ "$name$_.set(index, builderForValue.build());\n"
+ "$on_changed$\n",
- "$name$Builder_.setMessage(index, builderForValue.build());\n",
+ "$name$Builder_.setMessage(index, builderForValue.build());\n",
- "return this;\n");
+ "return this;\n");
// Builder addRepeatedField(Field value)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$add$capitalized_name$$}$($type$ value)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$add$capitalized_name$$}$($type$ value)",
- "if (value == null) {\n"
- " throw new NullPointerException();\n"
- "}\n"
- "ensure$capitalized_name$IsMutable();\n"
- "$name$_.add(value);\n"
+ "if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ "}\n"
+ "ensure$capitalized_name$IsMutable();\n"
+ "$name$_.add(value);\n"
- "$on_changed$\n",
+ "$on_changed$\n",
- "$name$Builder_.addMessage(value);\n",
+ "$name$Builder_.addMessage(value);\n",
- "return this;\n");
+ "return this;\n");
// Builder addRepeatedField(int index, Field value)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
- " int index, $type$ value)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
+ " int index, $type$ value)",
- "if (value == null) {\n"
- " throw new NullPointerException();\n"
- "}\n"
- "ensure$capitalized_name$IsMutable();\n"
- "$name$_.add(index, value);\n"
- "$on_changed$\n",
+ "if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ "}\n"
+ "ensure$capitalized_name$IsMutable();\n"
+ "$name$_.add(index, value);\n"
+ "$on_changed$\n",
- "$name$Builder_.addMessage(index, value);\n",
+ "$name$Builder_.addMessage(index, value);\n",
- "return this;\n");
+ "return this;\n");
// Builder addRepeatedField(Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
- " $type$.Builder builderForValue)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
+ " $type$.Builder builderForValue)",
- "ensure$capitalized_name$IsMutable();\n"
- "$name$_.add(builderForValue.build());\n"
- "$on_changed$\n",
+ "ensure$capitalized_name$IsMutable();\n"
+ "$name$_.add(builderForValue.build());\n"
+ "$on_changed$\n",
- "$name$Builder_.addMessage(builderForValue.build());\n",
+ "$name$Builder_.addMessage(builderForValue.build());\n",
- "return this;\n");
+ "return this;\n");
// Builder addRepeatedField(int index, Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
- " int index, $type$.Builder builderForValue)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
+ " int index, $type$.Builder builderForValue)",
- "ensure$capitalized_name$IsMutable();\n"
- "$name$_.add(index, builderForValue.build());\n"
- "$on_changed$\n",
+ "ensure$capitalized_name$IsMutable();\n"
+ "$name$_.add(index, builderForValue.build());\n"
+ "$on_changed$\n",
- "$name$Builder_.addMessage(index, builderForValue.build());\n",
+ "$name$Builder_.addMessage(index, builderForValue.build());\n",
- "return this;\n");
+ "return this;\n");
// Builder addAllRepeatedField(Iterable<Field> values)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
- " java.lang.Iterable<? extends $type$> values)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
+ " java.lang.Iterable<? extends $type$> values)",
- "ensure$capitalized_name$IsMutable();\n"
- "com.google.protobuf.AbstractMessageLite.Builder.addAll(\n"
- " values, $name$_);\n"
- "$on_changed$\n",
+ "ensure$capitalized_name$IsMutable();\n"
+ "com.google.protobuf.AbstractMessageLite.Builder.addAll(\n"
+ " values, $name$_);\n"
+ "$on_changed$\n",
- "$name$Builder_.addAllMessages(values);\n",
+ "$name$Builder_.addAllMessages(values);\n",
- "return this;\n");
+ "return this;\n");
// Builder clearAllRepeatedField()
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$()",
+ PrintNestedBuilderFunction(
+ printer, "$deprecation$public Builder ${$clear$capitalized_name$$}$()",
- "$name$_ = java.util.Collections.emptyList();\n"
- "$clear_mutable_bit_builder$;\n"
- "$on_changed$\n",
+ "$name$_ = java.util.Collections.emptyList();\n"
+ "$clear_mutable_bit_builder$;\n"
+ "$on_changed$\n",
- "$name$Builder_.clear();\n",
+ "$name$Builder_.clear();\n",
- "return this;\n");
+ "return this;\n");
// Builder removeRepeatedField(int index)
WriteFieldDocComment(printer, descriptor_);
- PrintNestedBuilderFunction(printer,
- "$deprecation$public Builder ${$remove$capitalized_name$$}$(int index)",
+ PrintNestedBuilderFunction(
+ printer,
+ "$deprecation$public Builder ${$remove$capitalized_name$$}$(int index)",
- "ensure$capitalized_name$IsMutable();\n"
- "$name$_.remove(index);\n"
- "$on_changed$\n",
+ "ensure$capitalized_name$IsMutable();\n"
+ "$name$_.remove(index);\n"
+ "$on_changed$\n",
- "$name$Builder_.remove(index);\n",
+ "$name$Builder_.remove(index);\n",
- "return this;\n");
+ "return this;\n");
+
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public $type$.Builder ${$get$capitalized_name$Builder$}$(\n"
+ " int index) {\n"
+ " return get$capitalized_name$FieldBuilder().getBuilder(index);\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$.Builder ${$get$capitalized_name$Builder$}$(\n"
- " int index) {\n"
- " return get$capitalized_name$FieldBuilder().getBuilder(index);\n"
- "}\n");
+ "$deprecation$public $type$OrBuilder "
+ "${$get$capitalized_name$OrBuilder$}$(\n"
+ " int index) {\n"
+ " if ($name$Builder_ == null) {\n"
+ " return $name$_.get(index);"
+ " } else {\n"
+ " return $name$Builder_.getMessageOrBuilder(index);\n"
+ " }\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$OrBuilder "
- "${$get$capitalized_name$OrBuilder$}$(\n"
- " int index) {\n"
- " if ($name$Builder_ == null) {\n"
- " return $name$_.get(index);"
- " } else {\n"
- " return $name$Builder_.getMessageOrBuilder(index);\n"
- " }\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
+ " ${$get$capitalized_name$OrBuilderList$}$() {\n"
+ " if ($name$Builder_ != null) {\n"
+ " return $name$Builder_.getMessageOrBuilderList();\n"
+ " } else {\n"
+ " return java.util.Collections.unmodifiableList($name$_);\n"
+ " }\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
- " ${$get$capitalized_name$OrBuilderList$}$() {\n"
- " if ($name$Builder_ != null) {\n"
- " return $name$Builder_.getMessageOrBuilderList();\n"
- " } else {\n"
- " return java.util.Collections.unmodifiableList($name$_);\n"
- " }\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
-
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$.Builder "
- "${$add$capitalized_name$Builder$}$() {\n"
- " return get$capitalized_name$FieldBuilder().addBuilder(\n"
- " $type$.getDefaultInstance());\n"
- "}\n");
+ printer->Print(variables_,
+ "$deprecation$public $type$.Builder "
+ "${$add$capitalized_name$Builder$}$() {\n"
+ " return get$capitalized_name$FieldBuilder().addBuilder(\n"
+ " $type$.getDefaultInstance());\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$.Builder ${$add$capitalized_name$Builder$}$(\n"
- " int index) {\n"
- " return get$capitalized_name$FieldBuilder().addBuilder(\n"
- " index, $type$.getDefaultInstance());\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public $type$.Builder ${$add$capitalized_name$Builder$}$(\n"
+ " int index) {\n"
+ " return get$capitalized_name$FieldBuilder().addBuilder(\n"
+ " index, $type$.getDefaultInstance());\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public java.util.List<$type$.Builder> \n"
- " ${$get$capitalized_name$BuilderList$}$() {\n"
- " return get$capitalized_name$FieldBuilder().getBuilderList();\n"
- "}\n"
- "private com.google.protobuf.RepeatedFieldBuilder$ver$<\n"
- " $type$, $type$.Builder, $type$OrBuilder> \n"
- " get$capitalized_name$FieldBuilder() {\n"
- " if ($name$Builder_ == null) {\n"
- " $name$Builder_ = new com.google.protobuf.RepeatedFieldBuilder$ver$<\n"
- " $type$, $type$.Builder, $type$OrBuilder>(\n"
- " $name$_,\n"
- " $get_mutable_bit_builder$,\n"
- " getParentForChildren(),\n"
- " isClean());\n"
- " $name$_ = null;\n"
- " }\n"
- " return $name$Builder_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public java.util.List<$type$.Builder> \n"
+ " ${$get$capitalized_name$BuilderList$}$() {\n"
+ " return get$capitalized_name$FieldBuilder().getBuilderList();\n"
+ "}\n"
+ "private com.google.protobuf.RepeatedFieldBuilder$ver$<\n"
+ " $type$, $type$.Builder, $type$OrBuilder> \n"
+ " get$capitalized_name$FieldBuilder() {\n"
+ " if ($name$Builder_ == null) {\n"
+ " $name$Builder_ = new "
+ "com.google.protobuf.RepeatedFieldBuilder$ver$<\n"
+ " $type$, $type$.Builder, $type$OrBuilder>(\n"
+ " $name$_,\n"
+ " $get_mutable_bit_builder$,\n"
+ " getParentForChildren(),\n"
+ " isClean());\n"
+ " $name$_ = null;\n"
+ " }\n"
+ " return $name$Builder_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
void RepeatedImmutableMessageFieldGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
- printer->Print(variables_,
- "get$capitalized_name$FieldBuilder();\n");
+ GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+ printer->Print(variables_, "get$capitalized_name$FieldBuilder();\n");
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void RepeatedImmutableMessageFieldGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
printer->Print(variables_, "$name$_ = java.util.Collections.emptyList();\n");
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateBuilderClearCode(io::Printer* printer) const {
+void RepeatedImmutableMessageFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
PrintNestedBuilderCondition(printer,
- "$name$_ = java.util.Collections.emptyList();\n"
- "$clear_mutable_bit_builder$;\n",
+ "$name$_ = java.util.Collections.emptyList();\n"
+ "$clear_mutable_bit_builder$;\n",
- "$name$Builder_.clear();\n");
+ "$name$Builder_.clear();\n");
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void RepeatedImmutableMessageFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
// The code below does two optimizations (non-nested builder case):
// 1. If the other list is empty, there's nothing to do. This ensures we
// don't allocate a new array if we already have an immutable one.
// 2. If the other list is non-empty and our current list is empty, we can
// reuse the other list which is guaranteed to be immutable.
- PrintNestedBuilderCondition(printer,
- "if (!other.$name$_.isEmpty()) {\n"
- " if ($name$_.isEmpty()) {\n"
- " $name$_ = other.$name$_;\n"
- " $clear_mutable_bit_builder$;\n"
- " } else {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.addAll(other.$name$_);\n"
- " }\n"
- " $on_changed$\n"
- "}\n",
+ PrintNestedBuilderCondition(
+ printer,
+ "if (!other.$name$_.isEmpty()) {\n"
+ " if ($name$_.isEmpty()) {\n"
+ " $name$_ = other.$name$_;\n"
+ " $clear_mutable_bit_builder$;\n"
+ " } else {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.addAll(other.$name$_);\n"
+ " }\n"
+ " $on_changed$\n"
+ "}\n",
- "if (!other.$name$_.isEmpty()) {\n"
- " if ($name$Builder_.isEmpty()) {\n"
- " $name$Builder_.dispose();\n"
- " $name$Builder_ = null;\n"
- " $name$_ = other.$name$_;\n"
- " $clear_mutable_bit_builder$;\n"
- " $name$Builder_ = \n"
- " com.google.protobuf.GeneratedMessage$ver$.alwaysUseFieldBuilders ?\n"
- " get$capitalized_name$FieldBuilder() : null;\n"
- " } else {\n"
- " $name$Builder_.addAllMessages(other.$name$_);\n"
- " }\n"
- "}\n");
+ "if (!other.$name$_.isEmpty()) {\n"
+ " if ($name$Builder_.isEmpty()) {\n"
+ " $name$Builder_.dispose();\n"
+ " $name$Builder_ = null;\n"
+ " $name$_ = other.$name$_;\n"
+ " $clear_mutable_bit_builder$;\n"
+ " $name$Builder_ = \n"
+ " com.google.protobuf.GeneratedMessage$ver$.alwaysUseFieldBuilders "
+ "?\n"
+ " get$capitalized_name$FieldBuilder() : null;\n"
+ " } else {\n"
+ " $name$Builder_.addAllMessages(other.$name$_);\n"
+ " }\n"
+ "}\n");
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
+void RepeatedImmutableMessageFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
// The code below (non-nested builder case) ensures that the result has an
// immutable list. If our list is immutable, we can just reuse it. If not,
// we make it immutable.
- PrintNestedBuilderCondition(printer,
- "if ($get_mutable_bit_builder$) {\n"
- " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
- " $clear_mutable_bit_builder$;\n"
- "}\n"
- "result.$name$_ = $name$_;\n",
+ PrintNestedBuilderCondition(
+ printer,
+ "if ($get_mutable_bit_builder$) {\n"
+ " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
+ " $clear_mutable_bit_builder$;\n"
+ "}\n"
+ "result.$name$_ = $name$_;\n",
- "result.$name$_ = $name$Builder_.build();\n");
+ "result.$name$_ = $name$Builder_.build();\n");
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void RepeatedImmutableMessageFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = new java.util.ArrayList<$type$>();\n"
- " $set_mutable_bit_parser$;\n"
- "}\n");
+ "if (!$get_mutable_bit_parser$) {\n"
+ " $name$_ = new java.util.ArrayList<$type$>();\n"
+ " $set_mutable_bit_parser$;\n"
+ "}\n");
if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
- printer->Print(variables_,
- "$name$_.add(input.readGroup($number$, $type$.$get_parser$,\n"
- " extensionRegistry));\n");
+ printer->Print(
+ variables_,
+ "$name$_.add(input.readGroup($number$, $type$.$get_parser$,\n"
+ " extensionRegistry));\n");
} else {
- printer->Print(variables_,
- "$name$_.add(\n"
- " input.readMessage($type$.$get_parser$, extensionRegistry));\n");
+ printer->Print(
+ variables_,
+ "$name$_.add(\n"
+ " input.readMessage($type$.$get_parser$, extensionRegistry));\n");
}
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($get_mutable_bit_parser$) {\n"
- " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
- "}\n");
+void RepeatedImmutableMessageFieldGenerator::GenerateParsingDoneCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if ($get_mutable_bit_parser$) {\n"
+ " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
+ "}\n");
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
+void RepeatedImmutableMessageFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " output.write$group_or_message$($number$, $name$_.get(i));\n"
- "}\n");
+ "for (int i = 0; i < $name$_.size(); i++) {\n"
+ " output.write$group_or_message$($number$, $name$_.get(i));\n"
+ "}\n");
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .compute$group_or_message$Size($number$, $name$_.get(i));\n"
- "}\n");
+void RepeatedImmutableMessageFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "for (int i = 0; i < $name$_.size(); i++) {\n"
+ " size += com.google.protobuf.CodedOutputStream\n"
+ " .compute$group_or_message$Size($number$, $name$_.get(i));\n"
+ "}\n");
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (!get$capitalized_name$List()\n"
- " .equals(other.get$capitalized_name$List())) return false;\n");
+void RepeatedImmutableMessageFieldGenerator::GenerateEqualsCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if (!get$capitalized_name$List()\n"
+ " .equals(other.get$capitalized_name$List())) return false;\n");
}
-void RepeatedImmutableMessageFieldGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (get$capitalized_name$Count() > 0) {\n"
- " hash = (37 * hash) + $constant_name$;\n"
- " hash = (53 * hash) + get$capitalized_name$List().hashCode();\n"
- "}\n");
+void RepeatedImmutableMessageFieldGenerator::GenerateHashCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if (get$capitalized_name$Count() > 0) {\n"
+ " hash = (37 * hash) + $constant_name$;\n"
+ " hash = (53 * hash) + get$capitalized_name$List().hashCode();\n"
+ "}\n");
}
std::string RepeatedImmutableMessageFieldGenerator::GetBoxedType() const {
diff --git a/src/google/protobuf/compiler/java/java_message_field_lite.cc b/src/google/protobuf/compiler/java/java_message_field_lite.cc
index c992ed3..c405981 100644
--- a/src/google/protobuf/compiler/java/java_message_field_lite.cc
+++ b/src/google/protobuf/compiler/java/java_message_field_lite.cc
@@ -63,12 +63,12 @@
(*variables)["mutable_type"] =
name_resolver->GetMutableClassName(descriptor->message_type());
(*variables)["group_or_message"] =
- (GetType(descriptor) == FieldDescriptor::TYPE_GROUP) ?
- "Group" : "Message";
+ (GetType(descriptor) == FieldDescriptor::TYPE_GROUP) ? "Group"
+ : "Message";
// TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
// by the proto compiler
- (*variables)["deprecation"] = descriptor->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ (*variables)["deprecation"] =
+ descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
(*variables)["required"] = descriptor->is_required() ? "true" : "false";
if (SupportFieldPresence(descriptor->file())) {
@@ -120,258 +120,185 @@
return SupportFieldPresence(descriptor_->file()) ? 1 : 0;
}
-void ImmutableMessageFieldLiteGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void ImmutableMessageFieldLiteGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$boolean has$capitalized_name$();\n");
+ printer->Print(variables_, "$deprecation$boolean has$capitalized_name$();\n");
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$();\n");
+ printer->Print(variables_, "$deprecation$$type$ get$capitalized_name$();\n");
}
-void ImmutableMessageFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutableMessageFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
- printer->Print(variables_,
- "private $type$ $name$_;\n");
+ printer->Print(variables_, "private $type$ $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
} else {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $name$_ != null;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $name$_ != null;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
// Field.Builder setField(Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$($type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " $name$_ = value;\n"
- " $set_has_field_bit_message$\n"
- " }\n");
+ "private void set$capitalized_name$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " $name$_ = value;\n"
+ " $set_has_field_bit_message$\n"
+ " }\n");
// Field.Builder setField(Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$(\n"
- " $type$.Builder builderForValue) {\n"
- " $name$_ = builderForValue.build();\n"
- " $set_has_field_bit_message$\n"
- "}\n");
+ "private void set$capitalized_name$(\n"
+ " $type$.Builder builderForValue) {\n"
+ " $name$_ = builderForValue.build();\n"
+ " $set_has_field_bit_message$\n"
+ "}\n");
// Field.Builder mergeField(Field value)
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.SuppressWarnings({\"ReferenceEquality\"})\n"
- "private void merge$capitalized_name$($type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " if ($name$_ != null &&\n"
- " $name$_ != $type$.getDefaultInstance()) {\n"
- " $name$_ =\n"
- " $type$.newBuilder($name$_).mergeFrom(value).buildPartial();\n"
- " } else {\n"
- " $name$_ = value;\n"
- " }\n"
- " $set_has_field_bit_message$\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.SuppressWarnings({\"ReferenceEquality\"})\n"
+ "private void merge$capitalized_name$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " if ($name$_ != null &&\n"
+ " $name$_ != $type$.getDefaultInstance()) {\n"
+ " $name$_ =\n"
+ " $type$.newBuilder($name$_).mergeFrom(value).buildPartial();\n"
+ " } else {\n"
+ " $name$_ = value;\n"
+ " }\n"
+ " $set_has_field_bit_message$\n"
+ "}\n");
// Field.Builder clearField()
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void clear$capitalized_name$() {"
- " $name$_ = null;\n"
- " $clear_has_field_bit_message$\n"
- "}\n");
+ "private void clear$capitalized_name$() {"
+ " $name$_ = null;\n"
+ " $clear_has_field_bit_message$\n"
+ "}\n");
}
-void ImmutableMessageFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutableMessageFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
// The comments above the methods below are based on a hypothetical
// field of type "Field" called "Field".
// boolean hasField()
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return instance.has$capitalized_name$();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return instance.has$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Field getField()
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return instance.get$capitalized_name$();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return instance.get$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Field.Builder setField(Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(value);\n"
- " return this;\n"
- " }\n");
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$$}$($type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(value);\n"
+ " return this;\n"
+ " }\n");
printer->Annotate("{", "}", descriptor_);
// Field.Builder setField(Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " $type$.Builder builderForValue) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(builderForValue);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " $type$.Builder builderForValue) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(builderForValue);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Field.Builder mergeField(Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder "
- "${$merge$capitalized_name$$}$($type$ value) {\n"
- " copyOnWrite();\n"
- " instance.merge$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$merge$capitalized_name$$}$($type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.merge$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Field.Builder clearField()
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {"
+ " copyOnWrite();\n"
+ " instance.clear$capitalized_name$();\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutableMessageFieldLiteGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+
+void ImmutableMessageFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
if (SupportFieldPresence(descriptor_->file())) {
- printer->Print(variables_,
- "get$capitalized_name$FieldBuilder();\n");
+ WriteIntToUtf16CharSequence(messageBitIndex_, output);
}
+ printer->Print(variables_, "\"$name$_\",\n");
}
-
-void ImmutableMessageFieldLiteGenerator::
-GenerateInitializationCode(io::Printer* printer) const {}
-
-void ImmutableMessageFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$name$_ = visitor.visitMessage($name$_, other.$name$_);\n");
-}
-
-void ImmutableMessageFieldLiteGenerator::
-GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const {
- // noop for scalars
-}
-
-void ImmutableMessageFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- // TODO(dweis): Update this code to avoid the builder allocation and instead
- // only allocate a submessage that isn't made immutable. Rely on the top
- // message calling makeImmutable once done to actually traverse the tree and
- // finalize state. This will avoid:
- // - transitive builder allocations
- // - the extra transitive iteration for streamed fields
- // - reallocations for copying repeated fields
- printer->Print(variables_,
- "$type$.Builder subBuilder = null;\n"
- "if ($is_field_present_message$) {\n"
- " subBuilder = $name$_.toBuilder();\n"
- "}\n");
-
- if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
- printer->Print(variables_,
- "$name$_ = input.readGroup($number$, $type$.parser(),\n"
- " extensionRegistry);\n");
- } else {
- printer->Print(variables_,
- "$name$_ = input.readMessage($type$.parser(), extensionRegistry);\n");
- }
-
- printer->Print(variables_,
- "if (subBuilder != null) {\n"
- " subBuilder.mergeFrom($name$_);\n"
- " $name$_ = subBuilder.buildPartial();\n"
- "}\n"
- "$set_has_field_bit_message$\n");
-}
-
-void ImmutableMessageFieldLiteGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- // noop for messages.
-}
-
-void ImmutableMessageFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " output.write$group_or_message$($number$, get$capitalized_name$());\n"
- "}\n");
-}
-
-void ImmutableMessageFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .compute$group_or_message$Size($number$, get$capitalized_name$());\n"
- "}\n");
-}
-
-void ImmutableMessageFieldLiteGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(variables_,
- "result = result && get$capitalized_name$()\n"
- " .equals(other.get$capitalized_name$());\n");
-}
-
-void ImmutableMessageFieldLiteGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n"
- "hash = (53 * hash) + get$capitalized_name$().hashCode();\n");
-}
+void ImmutableMessageFieldLiteGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {}
std::string ImmutableMessageFieldLiteGenerator::GetBoxedType() const {
return name_resolver_->GetImmutableClassName(descriptor_->message_type());
@@ -390,197 +317,155 @@
}
ImmutableMessageOneofFieldLiteGenerator::
-~ImmutableMessageOneofFieldLiteGenerator() {}
+ ~ImmutableMessageOneofFieldLiteGenerator() {}
-void ImmutableMessageOneofFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutableMessageOneofFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
PrintExtraFieldInfo(variables_, printer);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " return ($type$) $oneof_name$_;\n"
- " }\n"
- " return $type$.getDefaultInstance();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " return ($type$) $oneof_name$_;\n"
+ " }\n"
+ " return $type$.getDefaultInstance();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Field.Builder setField(Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$($type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " $oneof_name$_ = value;\n"
- " $set_oneof_case_message$;\n"
- "}\n");
+ "private void set$capitalized_name$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " $oneof_name$_ = value;\n"
+ " $set_oneof_case_message$;\n"
+ "}\n");
// Field.Builder setField(Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$(\n"
- " $type$.Builder builderForValue) {\n"
- " $oneof_name$_ = builderForValue.build();\n"
- " $set_oneof_case_message$;\n"
- "}\n");
+ "private void set$capitalized_name$(\n"
+ " $type$.Builder builderForValue) {\n"
+ " $oneof_name$_ = builderForValue.build();\n"
+ " $set_oneof_case_message$;\n"
+ "}\n");
// Field.Builder mergeField(Field value)
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void merge$capitalized_name$($type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " if ($has_oneof_case_message$ &&\n"
- " $oneof_name$_ != $type$.getDefaultInstance()) {\n"
- " $oneof_name$_ = $type$.newBuilder(($type$) $oneof_name$_)\n"
- " .mergeFrom(value).buildPartial();\n"
- " } else {\n"
- " $oneof_name$_ = value;\n"
- " }\n"
- " $set_oneof_case_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "private void merge$capitalized_name$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " if ($has_oneof_case_message$ &&\n"
+ " $oneof_name$_ != $type$.getDefaultInstance()) {\n"
+ " $oneof_name$_ = $type$.newBuilder(($type$) $oneof_name$_)\n"
+ " .mergeFrom(value).buildPartial();\n"
+ " } else {\n"
+ " $oneof_name$_ = value;\n"
+ " }\n"
+ " $set_oneof_case_message$;\n"
+ "}\n");
// Field.Builder clearField()
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void clear$capitalized_name$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " $clear_oneof_case_message$;\n"
- " $oneof_name$_ = null;\n"
- " }\n"
- "}\n");
+ "private void clear$capitalized_name$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " $clear_oneof_case_message$;\n"
+ " $oneof_name$_ = null;\n"
+ " }\n"
+ "}\n");
}
+void ImmutableMessageOneofFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
+ WriteIntToUtf16CharSequence(descriptor_->containing_oneof()->index(), output);
+ printer->Print(variables_, "$oneof_stored_type$.class,\n");
+}
-void ImmutableMessageOneofFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutableMessageOneofFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
// The comments above the methods below are based on a hypothetical
// field of type "Field" called "Field".
// boolean hasField()
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return instance.has$capitalized_name$();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return instance.has$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Field getField()
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return instance.get$capitalized_name$();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return instance.get$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Field.Builder setField(Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$$}$($type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Field.Builder setField(Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " $type$.Builder builderForValue) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(builderForValue);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " $type$.Builder builderForValue) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(builderForValue);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Field.Builder mergeField(Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder "
- "${$merge$capitalized_name$$}$($type$ value) {\n"
- " copyOnWrite();\n"
- " instance.merge$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$merge$capitalized_name$$}$($type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.merge$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Field.Builder clearField()
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " copyOnWrite();\n"
+ " instance.clear$capitalized_name$();\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutableMessageOneofFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$oneof_name$_ = visitor.visitOneofMessage(\n"
- " $has_oneof_case_message$,\n"
- " $oneof_name$_,\n"
- " other.$oneof_name$_);\n");
-}
-
-void ImmutableMessageOneofFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$type$.Builder subBuilder = null;\n"
- "if ($has_oneof_case_message$) {\n"
- " subBuilder = (($type$) $oneof_name$_).toBuilder();\n"
- "}\n");
-
- if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
- printer->Print(variables_,
- "$oneof_name$_ = input.readGroup($number$, $type$.parser(),\n"
- " extensionRegistry);\n");
- } else {
- printer->Print(variables_,
- "$oneof_name$_ =\n"
- " input.readMessage($type$.parser(), extensionRegistry);\n");
- }
-
- printer->Print(variables_,
- "if (subBuilder != null) {\n"
- " subBuilder.mergeFrom(($type$) $oneof_name$_);\n"
- " $oneof_name$_ = subBuilder.buildPartial();\n"
- "}\n");
- printer->Print(variables_,
- "$set_oneof_case_message$;\n");
-}
-
-void ImmutableMessageOneofFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " output.write$group_or_message$($number$, ($type$) $oneof_name$_);\n"
- "}\n");
-}
-
-void ImmutableMessageOneofFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .compute$group_or_message$Size($number$, ($type$) $oneof_name$_);\n"
- "}\n");
-}
-
// ===================================================================
RepeatedImmutableMessageFieldLiteGenerator::
@@ -597,383 +482,325 @@
}
RepeatedImmutableMessageFieldLiteGenerator::
-~RepeatedImmutableMessageFieldLiteGenerator() {}
+ ~RepeatedImmutableMessageFieldLiteGenerator() {}
int RepeatedImmutableMessageFieldLiteGenerator::GetNumBitsForMessage() const {
return 0;
}
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void RepeatedImmutableMessageFieldLiteGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
// TODO(jonp): In the future, consider having methods specific to the
// interface so that builders can choose dynamically to either return a
// message or a nested builder, so that asking for the interface doesn't
// cause a message to ever be built.
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.util.List<$type$> \n"
- " get$capitalized_name$List();\n");
+ "$deprecation$java.util.List<$type$> \n"
+ " get$capitalized_name$List();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$(int index);\n");
+ "$deprecation$$type$ get$capitalized_name$(int index);\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Count();\n");
+ "$deprecation$int get$capitalized_name$Count();\n");
}
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private com.google.protobuf.Internal.ProtobufList<$type$> $name$_;\n");
+void RepeatedImmutableMessageFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "private com.google.protobuf.Internal.ProtobufList<$type$> $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.util.List<$type$> "
- "${$get$capitalized_name$List$}$() {\n"
- " return $name$_;\n" // note: unmodifiable list
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public java.util.List<$type$> "
+ "${$get$capitalized_name$List$}$() {\n"
+ " return $name$_;\n" // note: unmodifiable list
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
+ " ${$get$capitalized_name$OrBuilderList$}$() {\n"
+ " return $name$_;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return $name$_.size();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
- " ${$get$capitalized_name$OrBuilderList$}$() {\n"
- " return $name$_;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return $name$_.size();\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
- " return $name$_.get(index);\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$OrBuilder "
- "${$get$capitalized_name$OrBuilder$}$(\n"
- " int index) {\n"
- " return $name$_.get(index);\n"
- "}\n");
+ "$deprecation$public $type$OrBuilder "
+ "${$get$capitalized_name$OrBuilder$}$(\n"
+ " int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
- printer->Print(variables_,
- "private void ensure$capitalized_name$IsMutable() {\n"
- " if (!$is_mutable$) {\n"
- " $name$_ =\n"
- " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
- " }\n"
- "}\n"
- "\n");
+ printer->Print(
+ variables_,
+ "private void ensure$capitalized_name$IsMutable() {\n"
+ " if (!$is_mutable$) {\n"
+ " $name$_ =\n"
+ " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
+ " }\n"
+ "}\n"
+ "\n");
// Builder setRepeatedField(int index, Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$(\n"
- " int index, $type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.set(index, value);\n"
- "}\n");
+ "private void set$capitalized_name$(\n"
+ " int index, $type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.set(index, value);\n"
+ "}\n");
// Builder setRepeatedField(int index, Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$(\n"
- " int index, $type$.Builder builderForValue) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.set(index, builderForValue.build());\n"
- "}\n");
+ "private void set$capitalized_name$(\n"
+ " int index, $type$.Builder builderForValue) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.set(index, builderForValue.build());\n"
+ "}\n");
// Builder addRepeatedField(Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void add$capitalized_name$($type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.add(value);\n"
- "}\n");
+ "private void add$capitalized_name$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.add(value);\n"
+ "}\n");
// Builder addRepeatedField(int index, Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void add$capitalized_name$(\n"
- " int index, $type$ value) {\n"
- " if (value == null) {\n"
- " throw new NullPointerException();\n"
- " }\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.add(index, value);\n"
- "}\n");
+ "private void add$capitalized_name$(\n"
+ " int index, $type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.add(index, value);\n"
+ "}\n");
// Builder addRepeatedField(Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void add$capitalized_name$(\n"
- " $type$.Builder builderForValue) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.add(builderForValue.build());\n"
- "}\n");
+ "private void add$capitalized_name$(\n"
+ " $type$.Builder builderForValue) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.add(builderForValue.build());\n"
+ "}\n");
// Builder addRepeatedField(int index, Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void add$capitalized_name$(\n"
- " int index, $type$.Builder builderForValue) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.add(index, builderForValue.build());\n"
- "}\n");
+ "private void add$capitalized_name$(\n"
+ " int index, $type$.Builder builderForValue) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.add(index, builderForValue.build());\n"
+ "}\n");
// Builder addAllRepeatedField(Iterable<Field> values)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void addAll$capitalized_name$(\n"
- " java.lang.Iterable<? extends $type$> values) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " com.google.protobuf.AbstractMessageLite.addAll(\n"
- " values, $name$_);\n"
- "}\n");
+ "private void addAll$capitalized_name$(\n"
+ " java.lang.Iterable<? extends $type$> values) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " com.google.protobuf.AbstractMessageLite.addAll(\n"
+ " values, $name$_);\n"
+ "}\n");
// Builder clearAllRepeatedField()
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void clear$capitalized_name$() {\n"
- " $name$_ = emptyProtobufList();\n"
- "}\n");
+ "private void clear$capitalized_name$() {\n"
+ " $name$_ = emptyProtobufList();\n"
+ "}\n");
// Builder removeRepeatedField(int index)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void remove$capitalized_name$(int index) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.remove(index);\n"
- "}\n");
+ "private void remove$capitalized_name$(int index) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.remove(index);\n"
+ "}\n");
}
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void RepeatedImmutableMessageFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
// The comments above the methods below are based on a hypothetical
// repeated field of type "Field" called "RepeatedField".
// List<Field> getRepeatedFieldList()
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.util.List<$type$> "
- "${$get$capitalized_name$List$}$() {\n"
- " return java.util.Collections.unmodifiableList(\n"
- " instance.get$capitalized_name$List());\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public java.util.List<$type$> "
+ "${$get$capitalized_name$List$}$() {\n"
+ " return java.util.Collections.unmodifiableList(\n"
+ " instance.get$capitalized_name$List());\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// int getRepeatedFieldCount()
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return instance.get$capitalized_name$Count();\n"
- "}");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return instance.get$capitalized_name$Count();\n"
+ "}");
printer->Annotate("{", "}", descriptor_);
// Field getRepeatedField(int index)
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
- " return instance.get$capitalized_name$(index);\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
+ " return instance.get$capitalized_name$(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Builder setRepeatedField(int index, Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " int index, $type$ value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(index, value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " int index, $type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(index, value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Builder setRepeatedField(int index, Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " int index, $type$.Builder builderForValue) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(index, builderForValue);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " int index, $type$.Builder builderForValue) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(index, builderForValue);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Builder addRepeatedField(Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$$}$($type$ value) {\n"
- " copyOnWrite();\n"
- " instance.add$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$add$capitalized_name$$}$($type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.add$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Builder addRepeatedField(int index, Field value)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
- " int index, $type$ value) {\n"
- " copyOnWrite();\n"
- " instance.add$capitalized_name$(index, value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
+ " int index, $type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.add$capitalized_name$(index, value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Builder addRepeatedField(Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
- " $type$.Builder builderForValue) {\n"
- " copyOnWrite();\n"
- " instance.add$capitalized_name$(builderForValue);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
+ " $type$.Builder builderForValue) {\n"
+ " copyOnWrite();\n"
+ " instance.add$capitalized_name$(builderForValue);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Builder addRepeatedField(int index, Field.Builder builderForValue)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
- " int index, $type$.Builder builderForValue) {\n"
- " copyOnWrite();\n"
- " instance.add$capitalized_name$(index, builderForValue);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
+ " int index, $type$.Builder builderForValue) {\n"
+ " copyOnWrite();\n"
+ " instance.add$capitalized_name$(index, builderForValue);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Builder addAllRepeatedField(Iterable<Field> values)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
- " java.lang.Iterable<? extends $type$> values) {\n"
- " copyOnWrite();\n"
- " instance.addAll$capitalized_name$(values);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
+ " java.lang.Iterable<? extends $type$> values) {\n"
+ " copyOnWrite();\n"
+ " instance.addAll$capitalized_name$(values);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Builder clearAllRepeatedField()
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " copyOnWrite();\n"
+ " instance.clear$capitalized_name$();\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
// Builder removeRepeatedField(int index)
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$remove$capitalized_name$$}$(int index) {\n"
- " copyOnWrite();\n"
- " instance.remove$capitalized_name$(index);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$remove$capitalized_name$$}$(int index) {\n"
+ " copyOnWrite();\n"
+ " instance.remove$capitalized_name$(index);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+
+void RepeatedImmutableMessageFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
printer->Print(variables_,
- "get$capitalized_name$FieldBuilder();\n");
+ "\"$name$_\",\n"
+ "$type$.class,\n");
}
-
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void RepeatedImmutableMessageFieldLiteGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
printer->Print(variables_, "$name$_ = emptyProtobufList();\n");
}
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$name$_= visitor.visitList($name$_, other.$name$_);\n");
-}
-
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$name$_.makeImmutable();\n");
-}
-
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (!$is_mutable$) {\n"
- " $name$_ =\n"
- " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
- "}\n");
-
- if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
- printer->Print(variables_,
- "$name$_.add(input.readGroup($number$, $type$.parser(),\n"
- " extensionRegistry));\n");
- } else {
- printer->Print(variables_,
- "$name$_.add(\n"
- " input.readMessage($type$.parser(), extensionRegistry));\n");
- }
-}
-
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_mutable$) {\n"
- " $name$_.makeImmutable();\n"
- "}\n");
-}
-
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " output.write$group_or_message$($number$, $name$_.get(i));\n"
- "}\n");
-}
-
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .compute$group_or_message$Size($number$, $name$_.get(i));\n"
- "}\n");
-}
-
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(variables_,
- "result = result && get$capitalized_name$List()\n"
- " .equals(other.get$capitalized_name$List());\n");
-}
-
-void RepeatedImmutableMessageFieldLiteGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (get$capitalized_name$Count() > 0) {\n"
- " hash = (37 * hash) + $constant_name$;\n"
- " hash = (53 * hash) + get$capitalized_name$List().hashCode();\n"
- "}\n");
-}
-
std::string RepeatedImmutableMessageFieldLiteGenerator::GetBoxedType() const {
return name_resolver_->GetImmutableClassName(descriptor_->message_type());
}
diff --git a/src/google/protobuf/compiler/java/java_message_field_lite.h b/src/google/protobuf/compiler/java/java_message_field_lite.h
index 7e78ca4..c409728 100644
--- a/src/google/protobuf/compiler/java/java_message_field_lite.h
+++ b/src/google/protobuf/compiler/java/java_message_field_lite.h
@@ -69,15 +69,8 @@
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
std::string GetBoxedType() const;
@@ -102,11 +95,8 @@
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
-
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImmutableMessageOneofFieldLiteGenerator);
@@ -125,16 +115,8 @@
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
std::string GetBoxedType() const;
diff --git a/src/google/protobuf/compiler/java/java_message_lite.cc b/src/google/protobuf/compiler/java/java_message_lite.cc
index c6d3991..c798feb 100644
--- a/src/google/protobuf/compiler/java/java_message_lite.cc
+++ b/src/google/protobuf/compiler/java/java_message_lite.cc
@@ -66,14 +66,6 @@
using internal::WireFormatLite;
namespace {
-bool EnableExperimentalRuntimeForLite() {
-#ifdef PROTOBUF_EXPERIMENT
- return PROTOBUF_EXPERIMENT;
-#else // PROTOBUF_EXPERIMENT
- return false;
-#endif // !PROTOBUF_EXPERIMENT
-}
-
std::string MapValueImmutableClassdName(const Descriptor* descriptor,
ClassNameResolver* name_resolver) {
const FieldDescriptor* value_field = descriptor->FindFieldByName("value");
@@ -85,9 +77,10 @@
// ===================================================================
ImmutableMessageLiteGenerator::ImmutableMessageLiteGenerator(
const Descriptor* descriptor, Context* context)
- : MessageGenerator(descriptor), context_(context),
- name_resolver_(context->GetNameResolver()),
- field_generators_(descriptor, context_) {
+ : MessageGenerator(descriptor),
+ context_(context),
+ name_resolver_(context->GetNameResolver()),
+ field_generators_(descriptor, context_) {
GOOGLE_CHECK(!HasDescriptorMethods(descriptor->file(), context->EnforceLite()))
<< "Generator factory error: A lite message generator is used to "
"generate non-lite messages.";
@@ -130,41 +123,39 @@
" com.google.protobuf.GeneratedMessageLite.\n"
" ExtendableMessageOrBuilder<\n"
" $classname$, $classname$.Builder> {\n",
- "deprecation", descriptor_->options().deprecated() ?
- "@java.lang.Deprecated " : "",
+ "deprecation",
+ descriptor_->options().deprecated() ? "@java.lang.Deprecated " : "",
"extra_interfaces", ExtraMessageOrBuilderInterfaces(descriptor_),
- "classname", descriptor_->name(),
- "{", "", "}", "");
+ "classname", descriptor_->name(), "{", "", "}", "");
} else {
printer->Print(
"$deprecation$public interface ${$$classname$OrBuilder$}$ extends\n"
" $extra_interfaces$\n"
" com.google.protobuf.MessageLiteOrBuilder {\n",
- "deprecation", descriptor_->options().deprecated() ?
- "@java.lang.Deprecated " : "",
+ "deprecation",
+ descriptor_->options().deprecated() ? "@java.lang.Deprecated " : "",
"extra_interfaces", ExtraMessageOrBuilderInterfaces(descriptor_),
- "classname", descriptor_->name(),
- "{", "", "}", "");
+ "classname", descriptor_->name(), "{", "", "}", "");
}
printer->Annotate("{", "}", descriptor_);
printer->Indent();
- for (int i = 0; i < descriptor_->field_count(); i++) {
- printer->Print("\n");
- field_generators_.get(descriptor_->field(i))
- .GenerateInterfaceMembers(printer);
- }
- for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
- printer->Print(
- "\n"
- "public $classname$.$oneof_capitalized_name$Case "
- "get$oneof_capitalized_name$Case();\n",
- "oneof_capitalized_name",
- context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->capitalized_name,
- "classname",
- context_->GetNameResolver()->GetImmutableClassName(descriptor_));
- }
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ printer->Print("\n");
+ field_generators_.get(descriptor_->field(i))
+ .GenerateInterfaceMembers(printer);
+ }
+ for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
+ printer->Print(
+ "\n"
+ "public $classname$.$oneof_capitalized_name$Case "
+ "get$oneof_capitalized_name$Case();\n",
+ "oneof_capitalized_name",
+ context_->GetOneofGeneratorInfo(descriptor_->oneof_decl(i))
+ ->capitalized_name,
+ "classname",
+ context_->GetNameResolver()->GetImmutableClassName(descriptor_));
+ }
printer->Outdent();
printer->Print("}\n");
@@ -179,8 +170,8 @@
variables["static"] = is_own_file ? " " : " static ";
variables["classname"] = descriptor_->name();
variables["extra_interfaces"] = ExtraMessageInterfaces(descriptor_);
- variables["deprecation"] = descriptor_->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ variables["deprecation"] =
+ descriptor_->options().deprecated() ? "@java.lang.Deprecated " : "";
WriteMessageDocComment(printer, descriptor_);
MaybePrintGeneratedAnnotation(context_, printer, descriptor_,
@@ -190,17 +181,19 @@
// The builder_type stores the super type name of the nested Builder class.
std::string builder_type;
if (descriptor_->extension_range_count() > 0) {
- printer->Print(variables,
- "$deprecation$public $static$final class $classname$ extends\n"
- " com.google.protobuf.GeneratedMessageLite.ExtendableMessage<\n"
- " $classname$, $classname$.Builder> implements\n"
- " $extra_interfaces$\n"
- " $classname$OrBuilder {\n");
+ printer->Print(
+ variables,
+ "$deprecation$public $static$final class $classname$ extends\n"
+ " com.google.protobuf.GeneratedMessageLite.ExtendableMessage<\n"
+ " $classname$, $classname$.Builder> implements\n"
+ " $extra_interfaces$\n"
+ " $classname$OrBuilder {\n");
builder_type = strings::Substitute(
"com.google.protobuf.GeneratedMessageLite.ExtendableBuilder<$0, ?>",
name_resolver_->GetImmutableClassName(descriptor_));
} else {
- printer->Print(variables,
+ printer->Print(
+ variables,
"$deprecation$public $static$final class $classname$ extends\n"
" com.google.protobuf.GeneratedMessageLite<\n"
" $classname$, $classname$.Builder> implements\n"
@@ -222,8 +215,8 @@
for (int i = 0; i < descriptor_->nested_type_count(); i++) {
// Don't generate Java classes for map entry messages.
if (IsMapEntry(descriptor_->nested_type(i))) continue;
- ImmutableMessageLiteGenerator messageGenerator(
- descriptor_->nested_type(i), context_);
+ ImmutableMessageLiteGenerator messageGenerator(descriptor_->nested_type(i),
+ context_);
messageGenerator.GenerateInterface(printer);
messageGenerator.Generate(printer);
}
@@ -245,17 +238,17 @@
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
const OneofDescriptor* oneof = descriptor_->oneof_decl(i);
vars["oneof_name"] = context_->GetOneofGeneratorInfo(oneof)->name;
- vars["oneof_capitalized_name"] = context_->GetOneofGeneratorInfo(
- oneof)->capitalized_name;
+ vars["oneof_capitalized_name"] =
+ context_->GetOneofGeneratorInfo(oneof)->capitalized_name;
vars["oneof_index"] = StrCat(oneof->index());
// oneofCase_ and oneof_
printer->Print(vars,
- "private int $oneof_name$Case_ = 0;\n"
- "private java.lang.Object $oneof_name$_;\n");
+ "private int $oneof_name$Case_ = 0;\n"
+ "private java.lang.Object $oneof_name$_;\n");
// OneofCase enum
printer->Print(vars,
- "public enum $oneof_capitalized_name$Case\n"
- " implements com.google.protobuf.Internal.EnumLite {\n");
+ "public enum $oneof_capitalized_name$Case\n"
+ " implements com.google.protobuf.Internal.EnumLite {\n");
printer->Indent();
for (int j = 0; j < oneof->field_count(); j++) {
const FieldDescriptor* field = oneof->field(j);
@@ -263,26 +256,25 @@
ToUpper(field->name()), "field_number",
StrCat(field->number()));
}
+ printer->Print("$cap_oneof_name$_NOT_SET(0);\n", "cap_oneof_name",
+ ToUpper(vars["oneof_name"]));
+ printer->Print(vars,
+ "private final int value;\n"
+ "private $oneof_capitalized_name$Case(int value) {\n"
+ " this.value = value;\n"
+ "}\n");
printer->Print(
- "$cap_oneof_name$_NOT_SET(0);\n",
- "cap_oneof_name",
- ToUpper(vars["oneof_name"]));
- printer->Print(vars,
- "private final int value;\n"
- "private $oneof_capitalized_name$Case(int value) {\n"
- " this.value = value;\n"
- "}\n");
- printer->Print(vars,
- "/**\n"
- " * @deprecated Use {@link #forNumber(int)} instead.\n"
- " */\n"
- "@java.lang.Deprecated\n"
- "public static $oneof_capitalized_name$Case valueOf(int value) {\n"
- " return forNumber(value);\n"
- "}\n"
- "\n"
- "public static $oneof_capitalized_name$Case forNumber(int value) {\n"
- " switch (value) {\n");
+ vars,
+ "/**\n"
+ " * @deprecated Use {@link #forNumber(int)} instead.\n"
+ " */\n"
+ "@java.lang.Deprecated\n"
+ "public static $oneof_capitalized_name$Case valueOf(int value) {\n"
+ " return forNumber(value);\n"
+ "}\n"
+ "\n"
+ "public static $oneof_capitalized_name$Case forNumber(int value) {\n"
+ " switch (value) {\n");
for (int j = 0; j < oneof->field_count(); j++) {
const FieldDescriptor* field = oneof->field(j);
printer->Print(" case $field_number$: return $field_name$;\n",
@@ -290,31 +282,31 @@
"field_name", ToUpper(field->name()));
}
printer->Print(
- " case 0: return $cap_oneof_name$_NOT_SET;\n"
- " default: return null;\n"
- " }\n"
- "}\n"
- "@java.lang.Override\n"
- "public int getNumber() {\n"
- " return this.value;\n"
- "}\n",
- "cap_oneof_name", ToUpper(vars["oneof_name"]));
+ " case 0: return $cap_oneof_name$_NOT_SET;\n"
+ " default: return null;\n"
+ " }\n"
+ "}\n"
+ "@java.lang.Override\n"
+ "public int getNumber() {\n"
+ " return this.value;\n"
+ "}\n",
+ "cap_oneof_name", ToUpper(vars["oneof_name"]));
printer->Outdent();
printer->Print("};\n\n");
// oneofCase()
printer->Print(vars,
- "@java.lang.Override\n"
- "public $oneof_capitalized_name$Case\n"
- "get$oneof_capitalized_name$Case() {\n"
- " return $oneof_capitalized_name$Case.forNumber(\n"
- " $oneof_name$Case_);\n"
- "}\n"
- "\n"
- "private void clear$oneof_capitalized_name$() {\n"
- " $oneof_name$Case_ = 0;\n"
- " $oneof_name$_ = null;\n"
- "}\n"
- "\n");
+ "@java.lang.Override\n"
+ "public $oneof_capitalized_name$Case\n"
+ "get$oneof_capitalized_name$Case() {\n"
+ " return $oneof_capitalized_name$Case.forNumber(\n"
+ " $oneof_name$Case_);\n"
+ "}\n"
+ "\n"
+ "private void clear$oneof_capitalized_name$() {\n"
+ " $oneof_name$Case_ = 0;\n"
+ " $oneof_name$_ = null;\n"
+ "}\n"
+ "\n");
}
// Fields
@@ -326,7 +318,6 @@
printer->Print("\n");
}
- GenerateMessageSerializationMethods(printer);
GenerateParseFromMethods(printer);
GenerateBuilder(printer);
@@ -334,8 +325,7 @@
// Memoizes whether the protocol buffer is fully initialized (has all
// required fields). 0 means false, 1 means true, and all other values
// mean not yet computed.
- printer->Print(
- "private byte memoizedIsInitialized = 2;\n");
+ printer->Print("private byte memoizedIsInitialized = 2;\n");
}
printer->Print(
@@ -353,74 +343,46 @@
printer->Indent();
printer->Indent();
- printer->Print(
- "case NEW_BUILDER: {\n");
+ printer->Print("case NEW_BUILDER: {\n");
printer->Indent();
GenerateDynamicMethodNewBuilder(printer);
printer->Outdent();
- if (!EnableExperimentalRuntimeForLite()) {
- printer->Print(
+ printer->Print(
"}\n"
- "case IS_INITIALIZED: {\n");
- printer->Indent();
- GenerateDynamicMethodIsInitialized(printer);
- printer->Outdent();
+ "case BUILD_MESSAGE_INFO: {\n");
- printer->Print("}\n");
-
- printer->Print(
- "case MAKE_IMMUTABLE: {\n");
-
- printer->Indent();
- GenerateDynamicMethodMakeImmutable(printer);
- printer->Outdent();
-
- printer->Print(
- "}\n"
- "case VISIT: {\n");
-
- printer->Indent();
- GenerateDynamicMethodVisit(printer);
- printer->Outdent();
-
- printer->Print(
- "}\n"
- "case MERGE_FROM_STREAM: {\n");
-
- printer->Indent();
- GenerateDynamicMethodMergeFromStream(printer);
- printer->Outdent();
- }
-
+ printer->Indent();
+ GenerateDynamicMethodNewBuildMessageInfo(printer);
+ printer->Outdent();
printer->Print(
- "}\n"
- "// fall through\n"
- "case GET_DEFAULT_INSTANCE: {\n"
- " return DEFAULT_INSTANCE;\n"
- "}\n"
- "case GET_PARSER: {\n"
- // Generally one would use the lazy initialization holder pattern for
- // manipulating static fields but that has exceptional cost on Android as
- // it will generate an extra class for every message. Instead, use the
- // double-check locking pattern which works just as well.
- //
- // The "parser" temporary mirrors the "PARSER" field to eliminate a read
- // at the final return statement.
- " com.google.protobuf.Parser<$classname$> parser = PARSER;\n"
- " if (parser == null) {\n"
- " synchronized ($classname$.class) {\n"
- " parser = PARSER;\n"
- " if (parser == null) {\n"
- " parser = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);\n"
- " PARSER = parser;\n"
- " }\n"
- " }\n"
- " }\n"
- " return parser;\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "}\n"
+ "// fall through\n"
+ "case GET_DEFAULT_INSTANCE: {\n"
+ " return DEFAULT_INSTANCE;\n"
+ "}\n"
+ "case GET_PARSER: {\n"
+ // Generally one would use the lazy initialization holder pattern for
+ // manipulating static fields but that has exceptional cost on Android as
+ // it will generate an extra class for every message. Instead, use the
+ // double-check locking pattern which works just as well.
+ //
+ // The "parser" temporary mirrors the "PARSER" field to eliminate a read
+ // at the final return statement.
+ " com.google.protobuf.Parser<$classname$> parser = PARSER;\n"
+ " if (parser == null) {\n"
+ " synchronized ($classname$.class) {\n"
+ " parser = PARSER;\n"
+ " if (parser == null) {\n"
+ " parser = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);\n"
+ " PARSER = parser;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return parser;\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
printer->Outdent();
@@ -447,43 +409,40 @@
printer->Outdent();
printer->Print(
- " }\n"
- " throw new UnsupportedOperationException();\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ " }\n"
+ " throw new UnsupportedOperationException();\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
printer->Print(
- "\n"
- "// @@protoc_insertion_point(class_scope:$full_name$)\n",
- "full_name", descriptor_->full_name());
-
+ "\n"
+ "// @@protoc_insertion_point(class_scope:$full_name$)\n",
+ "full_name", descriptor_->full_name());
// Carefully initialize the default instance in such a way that it doesn't
// conflict with other initialization.
- printer->Print(
- "private static final $classname$ DEFAULT_INSTANCE;\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ printer->Print("private static final $classname$ DEFAULT_INSTANCE;\n",
+ "classname",
+ name_resolver_->GetImmutableClassName(descriptor_));
printer->Print(
- "static {\n"
- " // New instances are implicitly immutable so no need to make\n"
- " // immutable.\n"
- " DEFAULT_INSTANCE = new $classname$();\n"
- "}\n"
- "\n",
- "classname", descriptor_->name());
- if (EnableExperimentalRuntimeForLite()) {
- // Register the default instance in a map. This map will be used by
- // experimental runtime to lookup default instance given a class instance
- // without using Java reflection.
- printer->Print(
- "static {\n"
- " com.google.protobuf.GeneratedMessageLite.registerDefaultInstance(\n"
- " $classname$.class, DEFAULT_INSTANCE);\n"
- "}\n",
- "classname", descriptor_->name());
- }
+ "static {\n"
+ " // New instances are implicitly immutable so no need to make\n"
+ " // immutable.\n"
+ " DEFAULT_INSTANCE = new $classname$();\n"
+ "}\n"
+ "\n",
+ "classname", descriptor_->name());
+ // Register the default instance in a map. This map will be used by
+ // experimental runtime to lookup default instance given a class instance
+ // without using Java reflection.
+ printer->Print(
+ "static {\n"
+ " com.google.protobuf.GeneratedMessageLite.registerDefaultInstance(\n"
+ " $classname$.class, DEFAULT_INSTANCE);\n"
+ "}\n",
+ "classname", descriptor_->name());
printer->Print(
"public static $classname$ getDefaultInstance() {\n"
@@ -513,216 +472,194 @@
.Generate(printer);
}
-
printer->Outdent();
printer->Print("}\n\n");
}
+void ImmutableMessageLiteGenerator::GenerateDynamicMethodNewBuildMessageInfo(
+ io::Printer* printer) {
+ printer->Indent();
+
+ // Collect field info into a sequence of UTF-16 chars. It will be embedded
+ // as a Java string in the generated code.
+ std::vector<uint16> chars;
+
+ int flags = 0;
+ if (SupportFieldPresence(descriptor_->file())) {
+ flags |= 0x1;
+ }
+ if (descriptor_->options().message_set_wire_format()) {
+ flags |= 0x2;
+ }
+ WriteIntToUtf16CharSequence(flags, &chars);
+ WriteIntToUtf16CharSequence(descriptor_->field_count(), &chars);
+
+ if (descriptor_->field_count() == 0) {
+ printer->Print("java.lang.Object[] objects = null;");
+ } else {
+ // A single array of all fields (including oneof, oneofCase, hasBits).
+ printer->Print("java.lang.Object[] objects = new java.lang.Object[] {\n");
+ printer->Indent();
+
+ // Record the number of oneofs.
+ WriteIntToUtf16CharSequence(descriptor_->oneof_decl_count(), &chars);
+ for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
+ const OneofDescriptor* oneof = descriptor_->oneof_decl(i);
+ printer->Print(
+ "\"$oneof_name$_\",\n"
+ "\"$oneof_name$Case_\",\n",
+ "oneof_name", context_->GetOneofGeneratorInfo(oneof)->name);
+ }
+
+ // Integers for bit fields.
+ int total_bits = 0;
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ total_bits +=
+ field_generators_.get(descriptor_->field(i)).GetNumBitsForMessage();
+ }
+ int total_ints = (total_bits + 31) / 32;
+ for (int i = 0; i < total_ints; i++) {
+ printer->Print("\"$bit_field_name$\",\n", "bit_field_name",
+ GetBitFieldName(i));
+ }
+ WriteIntToUtf16CharSequence(total_ints, &chars);
+
+ int map_count = 0;
+ int repeated_count = 0;
+ std::unique_ptr<const FieldDescriptor*[]> sorted_fields(
+ SortFieldsByNumber(descriptor_));
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ const FieldDescriptor* field = sorted_fields[i];
+ if (field->is_map()) {
+ map_count++;
+ } else if (field->is_repeated()) {
+ repeated_count++;
+ }
+ }
+
+ WriteIntToUtf16CharSequence(sorted_fields[0]->number(), &chars);
+ WriteIntToUtf16CharSequence(
+ sorted_fields[descriptor_->field_count() - 1]->number(), &chars);
+ WriteIntToUtf16CharSequence(descriptor_->field_count(), &chars);
+ WriteIntToUtf16CharSequence(map_count, &chars);
+ WriteIntToUtf16CharSequence(repeated_count, &chars);
+
+ std::vector<const FieldDescriptor*> fields_for_is_initialized_check;
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ if (descriptor_->field(i)->is_required() ||
+ (GetJavaType(descriptor_->field(i)) == JAVATYPE_MESSAGE &&
+ HasRequiredFields(descriptor_->field(i)->message_type()))) {
+ fields_for_is_initialized_check.push_back(descriptor_->field(i));
+ }
+ }
+ WriteIntToUtf16CharSequence(fields_for_is_initialized_check.size(), &chars);
+
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ const FieldDescriptor* field = sorted_fields[i];
+ field_generators_.get(field).GenerateFieldInfo(printer, &chars);
+ }
+ printer->Outdent();
+ printer->Print("};\n");
+ }
+
+ printer->Print("java.lang.String info =\n");
+ std::string line;
+ for (size_t i = 0; i < chars.size(); i++) {
+ uint16 code = chars[i];
+ EscapeUtf16ToString(code, &line);
+ if (line.size() >= 80) {
+ printer->Print(" \"$string$\" +\n", "string", line);
+ line.clear();
+ }
+ }
+ printer->Print(" \"$string$\";\n", "string", line);
+
+ printer->Print("return newMessageInfo(DEFAULT_INSTANCE, info, objects);\n");
+ printer->Outdent();
+}
// ===================================================================
-void ImmutableMessageLiteGenerator::
-GenerateMessageSerializationMethods(io::Printer* printer) {
- if (EnableExperimentalRuntimeForLite()) {
- return;
- }
-
- std::unique_ptr<const FieldDescriptor * []> sorted_fields(
- SortFieldsByNumber(descriptor_));
-
- std::vector<const Descriptor::ExtensionRange*> sorted_extensions;
- for (int i = 0; i < descriptor_->extension_range_count(); ++i) {
- sorted_extensions.push_back(descriptor_->extension_range(i));
- }
- std::sort(sorted_extensions.begin(), sorted_extensions.end(),
- ExtensionRangeOrdering());
-
+void ImmutableMessageLiteGenerator::GenerateParseFromMethods(
+ io::Printer* printer) {
printer->Print(
- "@java.lang.Override\n"
- "public void writeTo(com.google.protobuf.CodedOutputStream output)\n"
- " throws java.io.IOException {\n");
- printer->Indent();
- if (HasPackedFields(descriptor_)) {
- // writeTo(CodedOutputStream output) might be invoked without
- // getSerializedSize() ever being called, but we need the memoized
- // sizes in case this message has packed fields. Rather than emit checks
- // for each packed field, just call getSerializedSize() up front. In most
- // cases, getSerializedSize() will have already been called anyway by one
- // of the wrapper writeTo() methods, making this call cheap.
- printer->Print("getSerializedSize();\n");
- }
-
- if (descriptor_->extension_range_count() > 0) {
- if (descriptor_->options().message_set_wire_format()) {
- printer->Print(
- "com.google.protobuf.GeneratedMessageLite\n"
- " .ExtendableMessage<$classname$, $classname$.Builder>\n"
- " .ExtensionWriter extensionWriter =\n"
- " newMessageSetExtensionWriter();\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
- } else {
- printer->Print(
- "com.google.protobuf.GeneratedMessageLite\n"
- " .ExtendableMessage<$classname$, $classname$.Builder>\n"
- " .ExtensionWriter extensionWriter =\n"
- " newExtensionWriter();\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
- }
- }
-
- // Merge the fields and the extension ranges, both sorted by field number.
- for (int i = 0, j = 0;
- i < descriptor_->field_count() || j < sorted_extensions.size();) {
- if (i == descriptor_->field_count()) {
- GenerateSerializeOneExtensionRange(printer, sorted_extensions[j++]);
- } else if (j == sorted_extensions.size()) {
- GenerateSerializeOneField(printer, sorted_fields[i++]);
- } else if (sorted_fields[i]->number() < sorted_extensions[j]->start) {
- GenerateSerializeOneField(printer, sorted_fields[i++]);
- } else {
- GenerateSerializeOneExtensionRange(printer, sorted_extensions[j++]);
- }
- }
-
- if (descriptor_->options().message_set_wire_format()) {
- printer->Print("unknownFields.writeAsMessageSetTo(output);\n");
- } else {
- printer->Print("unknownFields.writeTo(output);\n");
- }
-
- printer->Outdent();
- printer->Print(
+ "public static $classname$ parseFrom(\n"
+ " java.nio.ByteBuffer data)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
+ " DEFAULT_INSTANCE, data);\n"
"}\n"
- "\n"
- "@java.lang.Override\n"
- "public int getSerializedSize() {\n"
- " int size = memoizedSerializedSize;\n"
- " if (size != -1) return size;\n"
- "\n");
- printer->Indent();
- printer->Print(
- "size = 0;\n");
-
- for (int i = 0; i < descriptor_->field_count(); i++) {
- field_generators_.get(sorted_fields[i]).GenerateSerializedSizeCode(printer);
- }
-
- if (descriptor_->extension_range_count() > 0) {
- if (descriptor_->options().message_set_wire_format()) {
- printer->Print("size += extensionsSerializedSizeAsMessageSet();\n");
- } else {
- printer->Print("size += extensionsSerializedSize();\n");
- }
- }
-
- if (descriptor_->options().message_set_wire_format()) {
- printer->Print("size += unknownFields.getSerializedSizeAsMessageSet();\n");
- } else {
- printer->Print("size += unknownFields.getSerializedSize();\n");
- }
-
- printer->Print(
- "memoizedSerializedSize = size;\n"
- "return size;\n");
-
- printer->Outdent();
- printer->Print(
- "}\n"
- "\n");
-}
-
-void ImmutableMessageLiteGenerator::
-GenerateParseFromMethods(io::Printer* printer) {
- // Note: These are separate from GenerateMessageSerializationMethods()
- // because they need to be generated even for messages that are optimized
- // for code size.
- printer->Print(
- "public static $classname$ parseFrom(\n"
- " java.nio.ByteBuffer data)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
- " DEFAULT_INSTANCE, data);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " java.nio.ByteBuffer data,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
- " DEFAULT_INSTANCE, data, extensionRegistry);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " com.google.protobuf.ByteString data)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
- " DEFAULT_INSTANCE, data);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " com.google.protobuf.ByteString data,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
- " DEFAULT_INSTANCE, data, extensionRegistry);\n"
- "}\n"
- "public static $classname$ parseFrom(byte[] data)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
- " DEFAULT_INSTANCE, data);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " byte[] data,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n"
- " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
- " DEFAULT_INSTANCE, data, extensionRegistry);\n"
- "}\n"
- "public static $classname$ parseFrom(java.io.InputStream input)\n"
- " throws java.io.IOException {\n"
- " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
- " DEFAULT_INSTANCE, input);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " java.io.InputStream input,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws java.io.IOException {\n"
- " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
- " DEFAULT_INSTANCE, input, extensionRegistry);\n"
- "}\n"
- "public static $classname$ parseDelimitedFrom(java.io.InputStream input)\n"
- " throws java.io.IOException {\n"
- " return parseDelimitedFrom(DEFAULT_INSTANCE, input);\n"
- "}\n"
- "public static $classname$ parseDelimitedFrom(\n"
- " java.io.InputStream input,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws java.io.IOException {\n"
- " return parseDelimitedFrom(DEFAULT_INSTANCE, input, extensionRegistry);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " com.google.protobuf.CodedInputStream input)\n"
- " throws java.io.IOException {\n"
- " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
- " DEFAULT_INSTANCE, input);\n"
- "}\n"
- "public static $classname$ parseFrom(\n"
- " com.google.protobuf.CodedInputStream input,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws java.io.IOException {\n"
- " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
- " DEFAULT_INSTANCE, input, extensionRegistry);\n"
- "}\n"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
-}
-
-void ImmutableMessageLiteGenerator::GenerateSerializeOneField(
- io::Printer* printer, const FieldDescriptor* field) {
- field_generators_.get(field).GenerateSerializationCode(printer);
-}
-
-void ImmutableMessageLiteGenerator::GenerateSerializeOneExtensionRange(
- io::Printer* printer, const Descriptor::ExtensionRange* range) {
- printer->Print("extensionWriter.writeUntil($end$, output);\n", "end",
- StrCat(range->end));
+ "public static $classname$ parseFrom(\n"
+ " java.nio.ByteBuffer data,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
+ " DEFAULT_INSTANCE, data, extensionRegistry);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " com.google.protobuf.ByteString data)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
+ " DEFAULT_INSTANCE, data);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " com.google.protobuf.ByteString data,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
+ " DEFAULT_INSTANCE, data, extensionRegistry);\n"
+ "}\n"
+ "public static $classname$ parseFrom(byte[] data)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
+ " DEFAULT_INSTANCE, data);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " byte[] data,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
+ " DEFAULT_INSTANCE, data, extensionRegistry);\n"
+ "}\n"
+ "public static $classname$ parseFrom(java.io.InputStream input)\n"
+ " throws java.io.IOException {\n"
+ " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
+ " DEFAULT_INSTANCE, input);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " java.io.InputStream input,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws java.io.IOException {\n"
+ " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
+ " DEFAULT_INSTANCE, input, extensionRegistry);\n"
+ "}\n"
+ "public static $classname$ parseDelimitedFrom(java.io.InputStream "
+ "input)\n"
+ " throws java.io.IOException {\n"
+ " return parseDelimitedFrom(DEFAULT_INSTANCE, input);\n"
+ "}\n"
+ "public static $classname$ parseDelimitedFrom(\n"
+ " java.io.InputStream input,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws java.io.IOException {\n"
+ " return parseDelimitedFrom(DEFAULT_INSTANCE, input, "
+ "extensionRegistry);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " com.google.protobuf.CodedInputStream input)\n"
+ " throws java.io.IOException {\n"
+ " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
+ " DEFAULT_INSTANCE, input);\n"
+ "}\n"
+ "public static $classname$ parseFrom(\n"
+ " com.google.protobuf.CodedInputStream input,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws java.io.IOException {\n"
+ " return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
+ " DEFAULT_INSTANCE, input, extensionRegistry);\n"
+ "}\n"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
}
// ===================================================================
@@ -744,383 +681,43 @@
// ===================================================================
-void ImmutableMessageLiteGenerator::GenerateDynamicMethodIsInitialized(
- io::Printer* printer) {
- // Returns null for false, DEFAULT_INSTANCE for true.
- if (!HasRequiredFields(descriptor_)) {
- printer->Print("return DEFAULT_INSTANCE;\n");
- return;
- }
-
- // TODO(xiaofeng): Remove this when b/64445758 is fixed. We don't need to
- // check memoizedIsInitialized here because the caller does that already,
- // but right now proguard proto shrinker asserts on the bytecode layout of
- // this code so it can't be removed until proguard is updated.
- printer->Print(
- "byte isInitialized = memoizedIsInitialized;\n"
- "if (isInitialized == 1) return DEFAULT_INSTANCE;\n"
- "if (isInitialized == 0) return null;\n"
- "\n"
- "boolean shouldMemoize = ((Boolean) arg0).booleanValue();\n");
-
- // Check that all required fields in this message are set.
- // TODO(kenton): We can optimize this when we switch to putting all the
- // "has" fields into a single bitfield.
- for (int i = 0; i < descriptor_->field_count(); i++) {
- const FieldDescriptor* field = descriptor_->field(i);
- const FieldGeneratorInfo* info = context_->GetFieldGeneratorInfo(field);
-
- if (field->is_required()) {
- printer->Print(
- "if (!has$name$()) {\n"
- " return null;\n"
- "}\n",
- "name", info->capitalized_name);
- }
- }
-
- // Now check that all embedded messages are initialized.
- for (int i = 0; i < descriptor_->field_count(); i++) {
- const FieldDescriptor* field = descriptor_->field(i);
- const FieldGeneratorInfo* info = context_->GetFieldGeneratorInfo(field);
- if (GetJavaType(field) == JAVATYPE_MESSAGE &&
- HasRequiredFields(field->message_type())) {
- switch (field->label()) {
- case FieldDescriptor::LABEL_REQUIRED:
- printer->Print(
- "if (!get$name$().isInitialized()) {\n"
- " return null;\n"
- "}\n",
- "type", name_resolver_->GetImmutableClassName(
- field->message_type()),
- "name", info->capitalized_name);
- break;
- case FieldDescriptor::LABEL_OPTIONAL:
- if (!SupportFieldPresence(descriptor_->file()) &&
- field->containing_oneof() != NULL) {
- const OneofDescriptor* oneof = field->containing_oneof();
- const OneofGeneratorInfo* oneof_info =
- context_->GetOneofGeneratorInfo(oneof);
- printer->Print("if ($oneof_name$Case_ == $field_number$) {\n",
- "oneof_name", oneof_info->name, "field_number",
- StrCat(field->number()));
- } else {
- printer->Print(
- "if (has$name$()) {\n",
- "name", info->capitalized_name);
- }
- printer->Print(
- " if (!get$name$().isInitialized()) {\n"
- " return null;\n"
- " }\n"
- "}\n",
- "name", info->capitalized_name);
- break;
- case FieldDescriptor::LABEL_REPEATED:
- if (IsMapEntry(field->message_type())) {
- printer->Print(
- "for ($type$ item : get$name$Map().values()) {\n"
- " if (!item.isInitialized()) {\n"
- " return null;\n"
- " }\n"
- "}\n",
- "type", MapValueImmutableClassdName(field->message_type(),
- name_resolver_),
- "name", info->capitalized_name);
- } else {
- printer->Print(
- "for (int i = 0; i < get$name$Count(); i++) {\n"
- " if (!get$name$(i).isInitialized()) {\n"
- " return null;\n"
- " }\n"
- "}\n",
- "type", name_resolver_->GetImmutableClassName(
- field->message_type()),
- "name", info->capitalized_name);
- }
- break;
- }
- }
- }
-
- if (descriptor_->extension_range_count() > 0) {
- printer->Print(
- "if (!extensionsAreInitialized()) {\n"
- " return null;\n"
- "}\n");
- }
-
- printer->Print(
- "return DEFAULT_INSTANCE;\n"
- "\n");
-}
-
-// ===================================================================
-
-void ImmutableMessageLiteGenerator::GenerateDynamicMethodMakeImmutable(
- io::Printer* printer) {
-
- // Output generation code for each field.
- for (int i = 0; i < descriptor_->field_count(); i++) {
- field_generators_.get(descriptor_->field(i))
- .GenerateDynamicMethodMakeImmutableCode(printer);
- }
-
- printer->Print(
- "return null;\n");
-}
-
-// ===================================================================
-
void ImmutableMessageLiteGenerator::GenerateDynamicMethodNewBuilder(
io::Printer* printer) {
- printer->Print(
- "return new Builder();\n");
+ printer->Print("return new Builder();\n");
}
// ===================================================================
-void ImmutableMessageLiteGenerator::GenerateDynamicMethodVisit(
+void ImmutableMessageLiteGenerator::GenerateExtensionRegistrationCode(
io::Printer* printer) {
- printer->Print(
- "Visitor visitor = (Visitor) arg0;\n"
- "$classname$ other = ($classname$) arg1;\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
-
- for (int i = 0; i < descriptor_->field_count(); i++) {
- if (!descriptor_->field(i)->containing_oneof()) {
- field_generators_.get(
- descriptor_->field(i)).GenerateVisitCode(printer);
- }
- }
-
- // Merge oneof fields.
- for (int i = 0; i < descriptor_->oneof_decl_count(); ++i) {
- printer->Print(
- "switch (other.get$oneof_capitalized_name$Case()) {\n",
- "oneof_capitalized_name",
- context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->capitalized_name);
- printer->Indent();
- for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
- const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
- printer->Print(
- "case $field_name$: {\n",
- "field_name",
- ToUpper(field->name()));
- printer->Indent();
- field_generators_.get(field).GenerateVisitCode(printer);
- printer->Print(
- "break;\n");
- printer->Outdent();
- printer->Print(
- "}\n");
- }
- printer->Print(
- "case $cap_oneof_name$_NOT_SET: {\n"
- " visitor.visitOneofNotSet($oneof_name$Case_ != 0);\n"
- " break;\n"
- "}\n",
- "cap_oneof_name",
- ToUpper(context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->name),
- "oneof_name",
- context_->GetOneofGeneratorInfo(
- descriptor_->oneof_decl(i))->name);
- printer->Outdent();
- printer->Print(
- "}\n");
- }
-
- printer->Print(
- "if (visitor == com.google.protobuf.GeneratedMessageLite.MergeFromVisitor\n"
- " .INSTANCE) {\n");
- printer->Indent();
- for (int i = 0; i < descriptor_->oneof_decl_count(); ++i) {
- const OneofDescriptor* field = descriptor_->oneof_decl(i);
- printer->Print(
- "if (other.$oneof_name$Case_ != 0) {\n"
- " $oneof_name$Case_ = other.$oneof_name$Case_;\n"
- "}\n",
- "oneof_name", context_->GetOneofGeneratorInfo(field)->name);
- }
-
- // Integers for bit fields.
- int totalBits = 0;
- for (int i = 0; i < descriptor_->field_count(); i++) {
- totalBits +=
- field_generators_.get(descriptor_->field(i)).GetNumBitsForMessage();
- }
- int totalInts = (totalBits + 31) / 32;
-
- for (int i = 0; i < totalInts; i++) {
- printer->Print("$bit_field_name$ |= other.$bit_field_name$;\n",
- "bit_field_name", GetBitFieldName(i));
- }
- printer->Outdent();
- printer->Print(
- "}\n");
-
-
- printer->Print(
- "return this;\n");
-}
-
-// ===================================================================
-
-void ImmutableMessageLiteGenerator::GenerateDynamicMethodMergeFromStream(
- io::Printer* printer) {
- printer->Print(
- "com.google.protobuf.CodedInputStream input =\n"
- " (com.google.protobuf.CodedInputStream) arg0;\n"
- "com.google.protobuf.ExtensionRegistryLite extensionRegistry =\n"
- " (com.google.protobuf.ExtensionRegistryLite) arg1;\n"
- "if (extensionRegistry == null) {\n"
- " throw new java.lang.NullPointerException();\n"
- "}\n");
- printer->Print(
- "try {\n");
- printer->Indent();
- printer->Print(
- "boolean done = false;\n"
- "while (!done) {\n");
- printer->Indent();
-
- printer->Print(
- "int tag = input.readTag();\n"
- "switch (tag) {\n");
- printer->Indent();
-
- printer->Print(
- "case 0:\n" // zero signals EOF / limit reached
- " done = true;\n"
- " break;\n");
-
- std::unique_ptr<const FieldDescriptor* []> sorted_fields(
- SortFieldsByNumber(descriptor_));
- for (int i = 0; i < descriptor_->field_count(); i++) {
- const FieldDescriptor* field = sorted_fields[i];
- uint32 tag = WireFormatLite::MakeTag(
- field->number(), WireFormat::WireTypeForFieldType(field->type()));
-
- printer->Print("case $tag$: {\n", "tag",
- StrCat(static_cast<int32>(tag)));
- printer->Indent();
-
- field_generators_.get(field).GenerateParsingCode(printer);
-
- printer->Outdent();
- printer->Print(
- " break;\n"
- "}\n");
-
- if (field->is_packable()) {
- // To make packed = true wire compatible, we generate parsing code from
- // a packed version of this field regardless of
- // field->options().packed().
- uint32 packed_tag = WireFormatLite::MakeTag(
- field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
- printer->Print("case $tag$: {\n", "tag",
- StrCat(static_cast<int32>(packed_tag)));
- printer->Indent();
-
- field_generators_.get(field).GenerateParsingCodeFromPacked(printer);
-
- printer->Outdent();
- printer->Print(
- " break;\n"
- "}\n");
- }
- }
-
- if (descriptor_->extension_range_count() > 0) {
- if (descriptor_->options().message_set_wire_format()) {
- printer->Print(
- "default: {\n"
- " if (!parseUnknownFieldAsMessageSet(\n"
- " getDefaultInstanceForType(), input, extensionRegistry,\n"
- " tag)) {\n"
- " done = true;\n" // it's an endgroup tag
- " }\n"
- " break;\n"
- "}\n");
- } else {
- printer->Print(
- "default: {\n"
- " if (!parseUnknownField(getDefaultInstanceForType(),\n"
- " input, extensionRegistry, tag)) {\n"
- " done = true;\n" // it's an endgroup tag
- " }\n"
- " break;\n"
- "}\n");
- }
- } else {
- printer->Print(
- "default: {\n"
- " if (!parseUnknownField(tag, input)) {\n"
- " done = true;\n" // it's an endgroup tag
- " }\n"
- " break;\n"
- "}\n");
- }
-
- printer->Outdent();
- printer->Outdent();
- printer->Print(
- " }\n" // switch (tag)
- "}\n"); // while (!done)
-
- printer->Outdent();
- printer->Print(
- "} catch (com.google.protobuf.InvalidProtocolBufferException e) {\n"
- " throw new RuntimeException(e.setUnfinishedMessage(this));\n"
- "} catch (java.io.IOException e) {\n"
- " throw new RuntimeException(\n"
- " new com.google.protobuf.InvalidProtocolBufferException(\n"
- " e.getMessage()).setUnfinishedMessage(this));\n"
- "} finally {\n");
- printer->Indent();
-
- printer->Outdent();
- printer->Print(
- "}\n"); // finally
-}
-
-// ===================================================================
-
-void ImmutableMessageLiteGenerator::
-GenerateExtensionRegistrationCode(io::Printer* printer) {
for (int i = 0; i < descriptor_->extension_count(); i++) {
ImmutableExtensionLiteGenerator(descriptor_->extension(i), context_)
- .GenerateRegistrationCode(printer);
+ .GenerateRegistrationCode(printer);
}
for (int i = 0; i < descriptor_->nested_type_count(); i++) {
ImmutableMessageLiteGenerator(descriptor_->nested_type(i), context_)
- .GenerateExtensionRegistrationCode(printer);
+ .GenerateExtensionRegistrationCode(printer);
}
}
// ===================================================================
-void ImmutableMessageLiteGenerator::
-GenerateConstructor(io::Printer* printer) {
- printer->Print(
- "private $classname$() {\n",
- "classname", descriptor_->name());
+void ImmutableMessageLiteGenerator::GenerateConstructor(io::Printer* printer) {
+ printer->Print("private $classname$() {\n", "classname", descriptor_->name());
printer->Indent();
// Initialize all fields to default.
GenerateInitializers(printer);
printer->Outdent();
- printer->Print(
- "}\n");
+ printer->Print("}\n");
}
// ===================================================================
void ImmutableMessageLiteGenerator::GenerateParser(io::Printer* printer) {
printer->Print(
- "private static volatile com.google.protobuf.Parser<$classname$> PARSER;\n"
+ "private static volatile com.google.protobuf.Parser<$classname$> "
+ "PARSER;\n"
"\n"
"public static com.google.protobuf.Parser<$classname$> parser() {\n"
" return DEFAULT_INSTANCE.getParserForType();\n"
diff --git a/src/google/protobuf/compiler/java/java_message_lite.h b/src/google/protobuf/compiler/java/java_message_lite.h
index d38c54a..61e81df 100644
--- a/src/google/protobuf/compiler/java/java_message_lite.h
+++ b/src/google/protobuf/compiler/java/java_message_lite.h
@@ -35,8 +35,8 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_LITE_H__
#define GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_LITE_H__
-#include <string>
#include <map>
+#include <string>
#include <google/protobuf/compiler/java/java_field.h>
#include <google/protobuf/compiler/java/java_message.h>
@@ -53,29 +53,20 @@
virtual void Generate(io::Printer* printer);
virtual void GenerateInterface(io::Printer* printer);
virtual void GenerateExtensionRegistrationCode(io::Printer* printer);
- virtual void GenerateStaticVariables(
- io::Printer* printer, int* bytecode_estimate);
+ virtual void GenerateStaticVariables(io::Printer* printer,
+ int* bytecode_estimate);
virtual int GenerateStaticVariableInitializers(io::Printer* printer);
private:
-
- void GenerateMessageSerializationMethods(io::Printer* printer);
void GenerateParseFromMethods(io::Printer* printer);
- void GenerateSerializeOneField(io::Printer* printer,
- const FieldDescriptor* field);
- void GenerateSerializeOneExtensionRange(
- io::Printer* printer, const Descriptor::ExtensionRange* range);
void GenerateBuilder(io::Printer* printer);
- void GenerateDynamicMethodIsInitialized(io::Printer* printer);
- void GenerateDynamicMethodMakeImmutable(io::Printer* printer);
- void GenerateDynamicMethodVisit(io::Printer* printer);
- void GenerateDynamicMethodMergeFromStream(io::Printer* printer);
void GenerateDynamicMethodNewBuilder(io::Printer* printer);
void GenerateInitializers(io::Printer* printer);
void GenerateEqualsAndHashCode(io::Printer* printer);
void GenerateParser(io::Printer* printer);
void GenerateConstructor(io::Printer* printer);
+ void GenerateDynamicMethodNewBuildMessageInfo(io::Printer* printer);
Context* context_;
ClassNameResolver* name_resolver_;
diff --git a/src/google/protobuf/compiler/java/java_name_resolver.cc b/src/google/protobuf/compiler/java/java_name_resolver.cc
index f8e4b3a..d07c628 100644
--- a/src/google/protobuf/compiler/java/java_name_resolver.cc
+++ b/src/google/protobuf/compiler/java/java_name_resolver.cc
@@ -66,8 +66,7 @@
// Get the name of a message's Java class without package name prefix.
std::string ClassNameWithoutPackage(const Descriptor* descriptor,
bool immutable) {
- return StripPackageName(descriptor->full_name(),
- descriptor->file());
+ return StripPackageName(descriptor->full_name(), descriptor->file());
}
// Get the name of an enum's Java class without package name prefix.
@@ -78,8 +77,8 @@
if (message_descriptor == NULL) {
return descriptor->name();
} else {
- return ClassNameWithoutPackage(message_descriptor, immutable) +
- "." + descriptor->name();
+ return ClassNameWithoutPackage(message_descriptor, immutable) + "." +
+ descriptor->name();
}
}
@@ -128,11 +127,9 @@
} // namespace
-ClassNameResolver::ClassNameResolver() {
-}
+ClassNameResolver::ClassNameResolver() {}
-ClassNameResolver::~ClassNameResolver() {
-}
+ClassNameResolver::~ClassNameResolver() {}
std::string ClassNameResolver::GetFileDefaultImmutableClassName(
const FileDescriptor* file) {
@@ -174,9 +171,9 @@
// Check whether there is any type defined in the proto file that has
// the given class name.
-bool ClassNameResolver::HasConflictingClassName(
- const FileDescriptor* file, const std::string& classname,
- NameEquality equality_mode) {
+bool ClassNameResolver::HasConflictingClassName(const FileDescriptor* file,
+ const std::string& classname,
+ NameEquality equality_mode) {
for (int i = 0; i < file->enum_type_count(); i++) {
if (CheckNameEquality(file->enum_type(i)->name(), classname) ==
equality_mode) {
@@ -274,16 +271,14 @@
std::string ClassNameResolver::GetJavaImmutableClassName(
const Descriptor* descriptor) {
- return GetJavaClassFullName(
- ClassNameWithoutPackage(descriptor, true),
- descriptor->file(), true);
+ return GetJavaClassFullName(ClassNameWithoutPackage(descriptor, true),
+ descriptor->file(), true);
}
std::string ClassNameResolver::GetJavaImmutableClassName(
const EnumDescriptor* descriptor) {
- return GetJavaClassFullName(
- ClassNameWithoutPackage(descriptor, true),
- descriptor->file(), true);
+ return GetJavaClassFullName(ClassNameWithoutPackage(descriptor, true),
+ descriptor->file(), true);
}
diff --git a/src/google/protobuf/compiler/java/java_plugin_unittest.cc b/src/google/protobuf/compiler/java/java_plugin_unittest.cc
index b3e220f..744b2c8 100644
--- a/src/google/protobuf/compiler/java/java_plugin_unittest.cc
+++ b/src/google/protobuf/compiler/java/java_plugin_unittest.cc
@@ -38,8 +38,8 @@
#include <google/protobuf/compiler/java/java_generator.h>
#include <google/protobuf/compiler/command_line_interface.h>
-#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/io/printer.h>
+#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/testing/file.h>
#include <google/protobuf/testing/file.h>
@@ -107,13 +107,8 @@
std::string java_out = "--java_out=" + TestTempDir();
std::string test_out = "--test_out=" + TestTempDir();
- const char* argv[] = {
- "protoc",
- proto_path.c_str(),
- java_out.c_str(),
- test_out.c_str(),
- "test.proto"
- };
+ const char* argv[] = {"protoc", proto_path.c_str(), java_out.c_str(),
+ test_out.c_str(), "test.proto"};
EXPECT_EQ(0, cli.Run(5, argv));
}
diff --git a/src/google/protobuf/compiler/java/java_primitive_field.cc b/src/google/protobuf/compiler/java/java_primitive_field.cc
index d26d43d..43c7f8f 100644
--- a/src/google/protobuf/compiler/java/java_primitive_field.cc
+++ b/src/google/protobuf/compiler/java/java_primitive_field.cc
@@ -69,10 +69,8 @@
(*variables)["boxed_type"] = BoxedPrimitiveTypeName(javaType);
(*variables)["field_type"] = (*variables)["type"];
- if (javaType == JAVATYPE_BOOLEAN ||
- javaType == JAVATYPE_DOUBLE ||
- javaType == JAVATYPE_FLOAT ||
- javaType == JAVATYPE_INT ||
+ if (javaType == JAVATYPE_BOOLEAN || javaType == JAVATYPE_DOUBLE ||
+ javaType == JAVATYPE_FLOAT || javaType == JAVATYPE_INT ||
javaType == JAVATYPE_LONG) {
std::string capitalized_type = UnderscoresToCamelCase(
PrimitiveTypeName(javaType), /*cap_first_letter=*/true);
@@ -108,8 +106,10 @@
}
(*variables)["default"] = ImmutableDefaultValue(descriptor, name_resolver);
- (*variables)["default_init"] = IsDefaultValueJavaDefault(descriptor) ?
- "" : ("= " + ImmutableDefaultValue(descriptor, name_resolver));
+ (*variables)["default_init"] =
+ IsDefaultValueJavaDefault(descriptor)
+ ? ""
+ : ("= " + ImmutableDefaultValue(descriptor, name_resolver));
(*variables)["capitalized_type"] =
GetCapitalizedType(descriptor, /* immutable = */ true);
(*variables)["tag"] =
@@ -126,8 +126,8 @@
}
// TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
// by the proto compiler
- (*variables)["deprecation"] = descriptor->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ (*variables)["deprecation"] =
+ descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
int fixed_size = FixedSize(GetType(descriptor));
if (fixed_size != -1) {
(*variables)["fixed_size"] = StrCat(fixed_size);
@@ -184,14 +184,14 @@
// ===================================================================
-ImmutablePrimitiveFieldGenerator::
-ImmutablePrimitiveFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
- builderBitIndex_(builderBitIndex), context_(context),
- name_resolver_(context->GetNameResolver()) {
+ImmutablePrimitiveFieldGenerator::ImmutablePrimitiveFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : descriptor_(descriptor),
+ messageBitIndex_(messageBitIndex),
+ builderBitIndex_(builderBitIndex),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
SetPrimitiveVariables(descriptor, messageBitIndex, builderBitIndex,
context->GetFieldGeneratorInfo(descriptor),
name_resolver_, &variables_);
@@ -207,129 +207,130 @@
return GetNumBitsForMessage();
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void ImmutablePrimitiveFieldGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$boolean has$capitalized_name$();\n");
+ "$deprecation$boolean has$capitalized_name$();\n");
}
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$();\n");
+ printer->Print(variables_, "$deprecation$$type$ get$capitalized_name$();\n");
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private $field_type$ $name$_;\n");
+void ImmutablePrimitiveFieldGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_, "private $field_type$ $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return $name$_;\n"
- "}\n");
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private $field_type$ $name$_ $default_init$;\n");
+void ImmutablePrimitiveFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_, "private $field_type$ $name$_ $default_init$;\n");
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_builder$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_builder$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return $name$_;\n"
- "}\n");
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value) {\n"
- "$null_check$"
- " $set_has_field_bit_builder$\n"
- " $name$_ = value;\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$$}$($type$ value) {\n"
+ "$null_check$"
+ " $set_has_field_bit_builder$\n"
+ " $name$_ = value;\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " $clear_has_field_bit_builder$\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " $clear_has_field_bit_builder$\n");
printer->Annotate("{", "}", descriptor_);
JavaType type = GetJavaType(descriptor_);
if (type == JAVATYPE_STRING || type == JAVATYPE_BYTES) {
// The default value is not a simple literal so we want to avoid executing
// it multiple times. Instead, get the default out of the default instance.
- printer->Print(variables_,
- " $name$_ = getDefaultInstance().get$capitalized_name$();\n");
+ printer->Print(
+ variables_,
+ " $name$_ = getDefaultInstance().get$capitalized_name$();\n");
} else {
- printer->Print(variables_,
- " $name$_ = $default$;\n");
+ printer->Print(variables_, " $name$_ = $default$;\n");
}
printer->Print(variables_,
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+void ImmutablePrimitiveFieldGenerator::GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const {
// noop for primitives
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void ImmutablePrimitiveFieldGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
if (!IsDefaultValueJavaDefault(descriptor_)) {
printer->Print(variables_, "$name$_ = $default$;\n");
}
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateBuilderClearCode(io::Printer* printer) const {
+void ImmutablePrimitiveFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "$name$_ = $default$;\n"
- "$clear_has_field_bit_builder$\n");
+ "$name$_ = $default$;\n"
+ "$clear_has_field_bit_builder$\n");
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void ImmutablePrimitiveFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
printer->Print(variables_,
- "if (other.has$capitalized_name$()) {\n"
- " set$capitalized_name$(other.get$capitalized_name$());\n"
- "}\n");
+ "if (other.has$capitalized_name$()) {\n"
+ " set$capitalized_name$(other.get$capitalized_name$());\n"
+ "}\n");
} else {
printer->Print(variables_,
- "if (other.get$capitalized_name$() != $default$) {\n"
- " set$capitalized_name$(other.get$capitalized_name$());\n"
- "}\n");
+ "if (other.get$capitalized_name$() != $default$) {\n"
+ " set$capitalized_name$(other.get$capitalized_name$());\n"
+ "}\n");
}
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
+void ImmutablePrimitiveFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
if (IsDefaultValueJavaDefault(descriptor_)) {
printer->Print(variables_,
@@ -349,65 +350,68 @@
}
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void ImmutablePrimitiveFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "$set_has_field_bit_message$\n"
- "$name$_ = input.read$capitalized_type$();\n");
+ "$set_has_field_bit_message$\n"
+ "$name$_ = input.read$capitalized_type$();\n");
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
+void ImmutablePrimitiveFieldGenerator::GenerateParsingDoneCode(
+ io::Printer* printer) const {
// noop for primitives.
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
+void ImmutablePrimitiveFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " output.write$capitalized_type$($number$, $name$_);\n"
- "}\n");
+ "if ($is_field_present_message$) {\n"
+ " output.write$capitalized_type$($number$, $name$_);\n"
+ "}\n");
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
+void ImmutablePrimitiveFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .compute$capitalized_type$Size($number$, $name$_);\n"
- "}\n");
+ "if ($is_field_present_message$) {\n"
+ " size += com.google.protobuf.CodedOutputStream\n"
+ " .compute$capitalized_type$Size($number$, $name$_);\n"
+ "}\n");
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
+void ImmutablePrimitiveFieldGenerator::GenerateEqualsCode(
+ io::Printer* printer) const {
switch (GetJavaType(descriptor_)) {
case JAVATYPE_INT:
case JAVATYPE_LONG:
case JAVATYPE_BOOLEAN:
printer->Print(variables_,
- "if (get$capitalized_name$()\n"
- " != other.get$capitalized_name$()) return false;\n");
+ "if (get$capitalized_name$()\n"
+ " != other.get$capitalized_name$()) return false;\n");
break;
case JAVATYPE_FLOAT:
- printer->Print(variables_,
- "if (java.lang.Float.floatToIntBits(get$capitalized_name$())\n"
- " != java.lang.Float.floatToIntBits(\n"
- " other.get$capitalized_name$())) return false;\n");
+ printer->Print(
+ variables_,
+ "if (java.lang.Float.floatToIntBits(get$capitalized_name$())\n"
+ " != java.lang.Float.floatToIntBits(\n"
+ " other.get$capitalized_name$())) return false;\n");
break;
case JAVATYPE_DOUBLE:
- printer->Print(variables_,
- "if (java.lang.Double.doubleToLongBits(get$capitalized_name$())\n"
- " != java.lang.Double.doubleToLongBits(\n"
- " other.get$capitalized_name$())) return false;\n");
+ printer->Print(
+ variables_,
+ "if (java.lang.Double.doubleToLongBits(get$capitalized_name$())\n"
+ " != java.lang.Double.doubleToLongBits(\n"
+ " other.get$capitalized_name$())) return false;\n");
break;
case JAVATYPE_STRING:
case JAVATYPE_BYTES:
- printer->Print(variables_,
- "if (!get$capitalized_name$()\n"
- " .equals(other.get$capitalized_name$())) return false;\n");
+ printer->Print(
+ variables_,
+ "if (!get$capitalized_name$()\n"
+ " .equals(other.get$capitalized_name$())) return false;\n");
break;
case JAVATYPE_ENUM:
@@ -418,44 +422,47 @@
}
}
-void ImmutablePrimitiveFieldGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n");
+void ImmutablePrimitiveFieldGenerator::GenerateHashCode(
+ io::Printer* printer) const {
+ printer->Print(variables_, "hash = (37 * hash) + $constant_name$;\n");
switch (GetJavaType(descriptor_)) {
case JAVATYPE_INT:
printer->Print(variables_,
- "hash = (53 * hash) + get$capitalized_name$();\n");
+ "hash = (53 * hash) + get$capitalized_name$();\n");
break;
case JAVATYPE_LONG:
- printer->Print(variables_,
- "hash = (53 * hash) + com.google.protobuf.Internal.hashLong(\n"
- " get$capitalized_name$());\n");
+ printer->Print(
+ variables_,
+ "hash = (53 * hash) + com.google.protobuf.Internal.hashLong(\n"
+ " get$capitalized_name$());\n");
break;
case JAVATYPE_BOOLEAN:
- printer->Print(variables_,
- "hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(\n"
- " get$capitalized_name$());\n");
+ printer->Print(
+ variables_,
+ "hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(\n"
+ " get$capitalized_name$());\n");
break;
case JAVATYPE_FLOAT:
printer->Print(variables_,
- "hash = (53 * hash) + java.lang.Float.floatToIntBits(\n"
- " get$capitalized_name$());\n");
+ "hash = (53 * hash) + java.lang.Float.floatToIntBits(\n"
+ " get$capitalized_name$());\n");
break;
case JAVATYPE_DOUBLE:
- printer->Print(variables_,
- "hash = (53 * hash) + com.google.protobuf.Internal.hashLong(\n"
- " java.lang.Double.doubleToLongBits(get$capitalized_name$()));\n");
+ printer->Print(
+ variables_,
+ "hash = (53 * hash) + com.google.protobuf.Internal.hashLong(\n"
+ " java.lang.Double.doubleToLongBits(get$capitalized_name$()));\n");
break;
case JAVATYPE_STRING:
case JAVATYPE_BYTES:
- printer->Print(variables_,
- "hash = (53 * hash) + get$capitalized_name$().hashCode();\n");
+ printer->Print(
+ variables_,
+ "hash = (53 * hash) + get$capitalized_name$().hashCode();\n");
break;
case JAVATYPE_ENUM:
@@ -472,165 +479,166 @@
// ===================================================================
-ImmutablePrimitiveOneofFieldGenerator::
-ImmutablePrimitiveOneofFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : ImmutablePrimitiveFieldGenerator(
- descriptor, messageBitIndex, builderBitIndex, context) {
+ImmutablePrimitiveOneofFieldGenerator::ImmutablePrimitiveOneofFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : ImmutablePrimitiveFieldGenerator(descriptor, messageBitIndex,
+ builderBitIndex, context) {
const OneofGeneratorInfo* info =
context->GetOneofGeneratorInfo(descriptor->containing_oneof());
SetCommonOneofVariables(descriptor, info, &variables_);
}
ImmutablePrimitiveOneofFieldGenerator::
-~ImmutablePrimitiveOneofFieldGenerator() {}
+ ~ImmutablePrimitiveOneofFieldGenerator() {}
-void ImmutablePrimitiveOneofFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutablePrimitiveOneofFieldGenerator::GenerateMembers(
+ io::Printer* printer) const {
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " return ($boxed_type$) $oneof_name$_;\n"
- " }\n"
- " return $default$;\n"
- "}\n");
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " return ($boxed_type$) $oneof_name$_;\n"
+ " }\n"
+ " return $default$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-
-void ImmutablePrimitiveOneofFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutablePrimitiveOneofFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " return ($boxed_type$) $oneof_name$_;\n"
- " }\n"
- " return $default$;\n"
- "}\n");
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " return ($boxed_type$) $oneof_name$_;\n"
+ " }\n"
+ " return $default$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value) {\n"
- "$null_check$"
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = value;\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$$}$($type$ value) {\n"
+ "$null_check$"
+ " $set_oneof_case_message$;\n"
+ " $oneof_name$_ = value;\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " $clear_oneof_case_message$;\n"
- " $oneof_name$_ = null;\n"
- " $on_changed$\n"
- " }\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " $clear_oneof_case_message$;\n"
+ " $oneof_name$_ = null;\n"
+ " $on_changed$\n"
+ " }\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutablePrimitiveOneofFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
+void ImmutablePrimitiveOneofFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " result.$oneof_name$_ = $oneof_name$_;\n"
- "}\n");
+ "if ($has_oneof_case_message$) {\n"
+ " result.$oneof_name$_ = $oneof_name$_;\n"
+ "}\n");
}
-void ImmutablePrimitiveOneofFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void ImmutablePrimitiveOneofFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "set$capitalized_name$(other.get$capitalized_name$());\n");
+ "set$capitalized_name$(other.get$capitalized_name$());\n");
}
-void ImmutablePrimitiveOneofFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void ImmutablePrimitiveOneofFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "$set_oneof_case_message$;\n"
- "$oneof_name$_ = input.read$capitalized_type$();\n");
+ "$set_oneof_case_message$;\n"
+ "$oneof_name$_ = input.read$capitalized_type$();\n");
}
-void ImmutablePrimitiveOneofFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
+void ImmutablePrimitiveOneofFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " output.write$capitalized_type$(\n");
+ "if ($has_oneof_case_message$) {\n"
+ " output.write$capitalized_type$(\n");
// $type$ and $boxed_type$ is the same for bytes fields so we don't need to
// do redundant casts.
if (GetJavaType(descriptor_) == JAVATYPE_BYTES) {
- printer->Print(variables_,
- " $number$, ($type$) $oneof_name$_);\n");
+ printer->Print(variables_, " $number$, ($type$) $oneof_name$_);\n");
} else {
- printer->Print(variables_,
- " $number$, ($type$)(($boxed_type$) $oneof_name$_));\n");
+ printer->Print(
+ variables_,
+ " $number$, ($type$)(($boxed_type$) $oneof_name$_));\n");
}
- printer->Print(
- "}\n");
+ printer->Print("}\n");
}
-void ImmutablePrimitiveOneofFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
+void ImmutablePrimitiveOneofFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .compute$capitalized_type$Size(\n");
+ "if ($has_oneof_case_message$) {\n"
+ " size += com.google.protobuf.CodedOutputStream\n"
+ " .compute$capitalized_type$Size(\n");
// $type$ and $boxed_type$ is the same for bytes fields so we don't need to
// do redundant casts.
if (GetJavaType(descriptor_) == JAVATYPE_BYTES) {
- printer->Print(variables_,
- " $number$, ($type$) $oneof_name$_);\n");
+ printer->Print(variables_, " $number$, ($type$) $oneof_name$_);\n");
} else {
- printer->Print(variables_,
- " $number$, ($type$)(($boxed_type$) $oneof_name$_));\n");
+ printer->Print(
+ variables_,
+ " $number$, ($type$)(($boxed_type$) $oneof_name$_));\n");
}
- printer->Print(
- "}\n");
+ printer->Print("}\n");
}
// ===================================================================
RepeatedImmutablePrimitiveFieldGenerator::
-RepeatedImmutablePrimitiveFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
- builderBitIndex_(builderBitIndex), context_(context),
- name_resolver_(context->GetNameResolver()) {
+ RepeatedImmutablePrimitiveFieldGenerator(const FieldDescriptor* descriptor,
+ int messageBitIndex,
+ int builderBitIndex,
+ Context* context)
+ : descriptor_(descriptor),
+ messageBitIndex_(messageBitIndex),
+ builderBitIndex_(builderBitIndex),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
SetPrimitiveVariables(descriptor, messageBitIndex, builderBitIndex,
context->GetFieldGeneratorInfo(descriptor),
name_resolver_, &variables_);
}
RepeatedImmutablePrimitiveFieldGenerator::
-~RepeatedImmutablePrimitiveFieldGenerator() {}
+ ~RepeatedImmutablePrimitiveFieldGenerator() {}
int RepeatedImmutablePrimitiveFieldGenerator::GetNumBitsForMessage() const {
return 0;
@@ -640,53 +648,54 @@
return 1;
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.util.List<$boxed_type$> get$capitalized_name$List();\n");
+ "$deprecation$java.util.List<$boxed_type$> "
+ "get$capitalized_name$List();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Count();\n");
+ "$deprecation$int get$capitalized_name$Count();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$(int index);\n");
+ "$deprecation$$type$ get$capitalized_name$(int index);\n");
}
-
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private $field_list_type$ $name$_;\n");
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_, "private $field_list_type$ $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public java.util.List<$boxed_type$>\n"
- " ${$get$capitalized_name$List$}$() {\n"
- " return $name$_;\n" // note: unmodifiable list
- "}\n");
+ "$deprecation$public java.util.List<$boxed_type$>\n"
+ " ${$get$capitalized_name$List$}$() {\n"
+ " return $name$_;\n" // note: unmodifiable list
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return $name$_.size();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return $name$_.size();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
- " return $repeated_get$(index);\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
+ " return $repeated_get$(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
if (descriptor_->is_packed()) {
printer->Print(variables_,
- "private int $name$MemoizedSerializedSize = -1;\n");
+ "private int $name$MemoizedSerializedSize = -1;\n");
}
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
// One field is the list and the bit field keeps track of whether the
// list is immutable. If it's immutable, the invariant is that it must
// either an instance of Collections.emptyList() or it's an ArrayList
@@ -697,244 +706,254 @@
// just that the list cannot be modified via the reference but that the
// list can never be modified.
printer->Print(variables_,
- "private $field_list_type$ $name$_ = $empty_list$;\n");
+ "private $field_list_type$ $name$_ = $empty_list$;\n");
printer->Print(variables_,
- "private void ensure$capitalized_name$IsMutable() {\n"
- " if (!$get_mutable_bit_builder$) {\n"
- " $name$_ = $mutable_copy_list$;\n"
- " $set_mutable_bit_builder$;\n"
- " }\n"
- "}\n");
+ "private void ensure$capitalized_name$IsMutable() {\n"
+ " if (!$get_mutable_bit_builder$) {\n"
+ " $name$_ = $mutable_copy_list$;\n"
+ " $set_mutable_bit_builder$;\n"
+ " }\n"
+ "}\n");
- // Note: We return an unmodifiable list because otherwise the caller
- // could hold on to the returned list and modify it after the message
- // has been built, thus mutating the message which is supposed to be
- // immutable.
+ // Note: We return an unmodifiable list because otherwise the caller
+ // could hold on to the returned list and modify it after the message
+ // has been built, thus mutating the message which is supposed to be
+ // immutable.
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public java.util.List<$boxed_type$>\n"
- " ${$get$capitalized_name$List$}$() {\n"
- " return $get_mutable_bit_builder$ ?\n"
- " java.util.Collections.unmodifiableList($name$_) : $name$_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public java.util.List<$boxed_type$>\n"
+ " ${$get$capitalized_name$List$}$() {\n"
+ " return $get_mutable_bit_builder$ ?\n"
+ " java.util.Collections.unmodifiableList($name$_) : $name$_;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return $name$_.size();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
+ " return $repeated_get$(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return $name$_.size();\n"
- "}\n");
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " int index, $type$ value) {\n"
+ "$null_check$"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $repeated_set$(index, value);\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
- " return $repeated_get$(index);\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$add$capitalized_name$$}$($type$ value) {\n"
+ "$null_check$"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $repeated_add$(value);\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " int index, $type$ value) {\n"
- "$null_check$"
- " ensure$capitalized_name$IsMutable();\n"
- " $repeated_set$(index, value);\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
+ " java.lang.Iterable<? extends $boxed_type$> values) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " com.google.protobuf.AbstractMessageLite.Builder.addAll(\n"
+ " values, $name$_);\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$$}$($type$ value) {\n"
- "$null_check$"
- " ensure$capitalized_name$IsMutable();\n"
- " $repeated_add$(value);\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
- " java.lang.Iterable<? extends $boxed_type$> values) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " com.google.protobuf.AbstractMessageLite.Builder.addAll(\n"
- " values, $name$_);\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " $name$_ = $empty_list$;\n"
- " $clear_mutable_bit_builder$;\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " $name$_ = $empty_list$;\n"
+ " $clear_mutable_bit_builder$;\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+ GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
// noop for primitives
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
printer->Print(variables_, "$name$_ = $empty_list$;\n");
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateBuilderClearCode(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "$name$_ = $empty_list$;\n"
- "$clear_mutable_bit_builder$;\n");
+ "$name$_ = $empty_list$;\n"
+ "$clear_mutable_bit_builder$;\n");
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
// The code below does two optimizations:
// 1. If the other list is empty, there's nothing to do. This ensures we
// don't allocate a new array if we already have an immutable one.
// 2. If the other list is non-empty and our current list is empty, we can
// reuse the other list which is guaranteed to be immutable.
printer->Print(variables_,
- "if (!other.$name$_.isEmpty()) {\n"
- " if ($name$_.isEmpty()) {\n"
- " $name$_ = other.$name$_;\n"
- " $clear_mutable_bit_builder$;\n"
- " } else {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.addAll(other.$name$_);\n"
- " }\n"
- " $on_changed$\n"
- "}\n");
+ "if (!other.$name$_.isEmpty()) {\n"
+ " if ($name$_.isEmpty()) {\n"
+ " $name$_ = other.$name$_;\n"
+ " $clear_mutable_bit_builder$;\n"
+ " } else {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.addAll(other.$name$_);\n"
+ " }\n"
+ " $on_changed$\n"
+ "}\n");
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
// The code below ensures that the result has an immutable list. If our
// list is immutable, we can just reuse it. If not, we make it immutable.
printer->Print(variables_,
- "if ($get_mutable_bit_builder$) {\n"
- " $name_make_immutable$;\n"
- " $clear_mutable_bit_builder$;\n"
- "}\n"
- "result.$name$_ = $name$_;\n");
+ "if ($get_mutable_bit_builder$) {\n"
+ " $name_make_immutable$;\n"
+ " $clear_mutable_bit_builder$;\n"
+ "}\n"
+ "result.$name$_ = $name$_;\n");
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = $create_list$;\n"
- " $set_mutable_bit_parser$;\n"
- "}\n"
- "$repeated_add$(input.read$capitalized_type$());\n");
+ "if (!$get_mutable_bit_parser$) {\n"
+ " $name$_ = $create_list$;\n"
+ " $set_mutable_bit_parser$;\n"
+ "}\n"
+ "$repeated_add$(input.read$capitalized_type$());\n");
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateParsingCodeFromPacked(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateParsingCodeFromPacked(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "int length = input.readRawVarint32();\n"
+ "int limit = input.pushLimit(length);\n"
+ "if (!$get_mutable_bit_parser$ && input.getBytesUntilLimit() > 0) {\n"
+ " $name$_ = $create_list$;\n"
+ " $set_mutable_bit_parser$;\n"
+ "}\n"
+ "while (input.getBytesUntilLimit() > 0) {\n"
+ " $repeated_add$(input.read$capitalized_type$());\n"
+ "}\n"
+ "input.popLimit(limit);\n");
+}
+
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateParsingDoneCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "int length = input.readRawVarint32();\n"
- "int limit = input.pushLimit(length);\n"
- "if (!$get_mutable_bit_parser$ && input.getBytesUntilLimit() > 0) {\n"
- " $name$_ = $create_list$;\n"
- " $set_mutable_bit_parser$;\n"
- "}\n"
- "while (input.getBytesUntilLimit() > 0) {\n"
- " $repeated_add$(input.read$capitalized_type$());\n"
- "}\n"
- "input.popLimit(limit);\n");
+ "if ($get_mutable_bit_parser$) {\n"
+ " $name_make_immutable$; // C\n"
+ "}\n");
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($get_mutable_bit_parser$) {\n"
- " $name_make_immutable$; // C\n"
- "}\n");
-}
-
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
if (descriptor_->is_packed()) {
// We invoke getSerializedSize in writeTo for messages that have packed
// fields in ImmutableMessageGenerator::GenerateMessageSerializationMethods.
// That makes it safe to rely on the memoized size here.
printer->Print(variables_,
- "if (get$capitalized_name$List().size() > 0) {\n"
- " output.writeUInt32NoTag($tag$);\n"
- " output.writeUInt32NoTag($name$MemoizedSerializedSize);\n"
- "}\n"
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " output.write$capitalized_type$NoTag($repeated_get$(i));\n"
- "}\n");
+ "if (get$capitalized_name$List().size() > 0) {\n"
+ " output.writeUInt32NoTag($tag$);\n"
+ " output.writeUInt32NoTag($name$MemoizedSerializedSize);\n"
+ "}\n"
+ "for (int i = 0; i < $name$_.size(); i++) {\n"
+ " output.write$capitalized_type$NoTag($repeated_get$(i));\n"
+ "}\n");
} else {
- printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " output.write$capitalized_type$($number$, $repeated_get$(i));\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "for (int i = 0; i < $name$_.size(); i++) {\n"
+ " output.write$capitalized_type$($number$, $repeated_get$(i));\n"
+ "}\n");
}
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "{\n"
- " int dataSize = 0;\n");
+ "{\n"
+ " int dataSize = 0;\n");
printer->Indent();
if (FixedSize(GetType(descriptor_)) == -1) {
- printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " dataSize += com.google.protobuf.CodedOutputStream\n"
- " .compute$capitalized_type$SizeNoTag($repeated_get$(i));\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "for (int i = 0; i < $name$_.size(); i++) {\n"
+ " dataSize += com.google.protobuf.CodedOutputStream\n"
+ " .compute$capitalized_type$SizeNoTag($repeated_get$(i));\n"
+ "}\n");
} else {
- printer->Print(variables_,
- "dataSize = $fixed_size$ * get$capitalized_name$List().size();\n");
+ printer->Print(
+ variables_,
+ "dataSize = $fixed_size$ * get$capitalized_name$List().size();\n");
}
- printer->Print(
- "size += dataSize;\n");
+ printer->Print("size += dataSize;\n");
if (descriptor_->is_packed()) {
printer->Print(variables_,
- "if (!get$capitalized_name$List().isEmpty()) {\n"
- " size += $tag_size$;\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .computeInt32SizeNoTag(dataSize);\n"
- "}\n");
+ "if (!get$capitalized_name$List().isEmpty()) {\n"
+ " size += $tag_size$;\n"
+ " size += com.google.protobuf.CodedOutputStream\n"
+ " .computeInt32SizeNoTag(dataSize);\n"
+ "}\n");
} else {
- printer->Print(variables_,
- "size += $tag_size$ * get$capitalized_name$List().size();\n");
+ printer->Print(
+ variables_,
+ "size += $tag_size$ * get$capitalized_name$List().size();\n");
}
// cache the data size for packed fields.
if (descriptor_->is_packed()) {
- printer->Print(variables_,
- "$name$MemoizedSerializedSize = dataSize;\n");
+ printer->Print(variables_, "$name$MemoizedSerializedSize = dataSize;\n");
}
printer->Outdent();
printer->Print("}\n");
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (!get$capitalized_name$List()\n"
- " .equals(other.get$capitalized_name$List())) return false;\n");
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateEqualsCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if (!get$capitalized_name$List()\n"
+ " .equals(other.get$capitalized_name$List())) return false;\n");
}
-void RepeatedImmutablePrimitiveFieldGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (get$capitalized_name$Count() > 0) {\n"
- " hash = (37 * hash) + $constant_name$;\n"
- " hash = (53 * hash) + get$capitalized_name$List().hashCode();\n"
- "}\n");
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateHashCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if (get$capitalized_name$Count() > 0) {\n"
+ " hash = (37 * hash) + $constant_name$;\n"
+ " hash = (53 * hash) + get$capitalized_name$List().hashCode();\n"
+ "}\n");
}
std::string RepeatedImmutablePrimitiveFieldGenerator::GetBoxedType() const {
diff --git a/src/google/protobuf/compiler/java/java_primitive_field_lite.cc b/src/google/protobuf/compiler/java/java_primitive_field_lite.cc
index be5f0f1..7ca3073 100644
--- a/src/google/protobuf/compiler/java/java_primitive_field_lite.cc
+++ b/src/google/protobuf/compiler/java/java_primitive_field_lite.cc
@@ -134,8 +134,8 @@
}
// TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
// by the proto compiler
- (*variables)["deprecation"] = descriptor->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ (*variables)["deprecation"] =
+ descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
int fixed_size = FixedSize(GetType(descriptor));
if (fixed_size != -1) {
(*variables)["fixed_size"] = StrCat(fixed_size);
@@ -196,20 +196,19 @@
return SupportFieldPresence(descriptor_->file()) ? 1 : 0;
}
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void ImmutablePrimitiveFieldLiteGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$boolean has$capitalized_name$();\n");
+ "$deprecation$boolean has$capitalized_name$();\n");
}
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$();\n");
+ printer->Print(variables_, "$deprecation$$type$ get$capitalized_name$();\n");
}
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutablePrimitiveFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
if (IsByteStringWithCustomDefaultValue(descriptor_)) {
// allocate this once statically since we know ByteStrings are immutable
// values that can be reused.
@@ -217,100 +216,107 @@
variables_,
"private static final $field_type$ $bytes_default$ = $default$;\n");
}
- printer->Print(variables_,
- "private $field_type$ $name$_;\n");
+ printer->Print(variables_, "private $field_type$ $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return $name$_;\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$($type$ value) {\n"
- "$null_check$"
- " $set_has_field_bit_message$\n"
- " $name$_ = value;\n"
- "}\n");
+ "private void set$capitalized_name$($type$ value) {\n"
+ "$null_check$"
+ " $set_has_field_bit_message$\n"
+ " $name$_ = value;\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void clear$capitalized_name$() {\n"
- " $clear_has_field_bit_message$\n");
+ "private void clear$capitalized_name$() {\n"
+ " $clear_has_field_bit_message$\n");
JavaType type = GetJavaType(descriptor_);
if (type == JAVATYPE_STRING || type == JAVATYPE_BYTES) {
// The default value is not a simple literal so we want to avoid executing
// it multiple times. Instead, get the default out of the default instance.
- printer->Print(variables_,
- " $name$_ = getDefaultInstance().get$capitalized_name$();\n");
+ printer->Print(
+ variables_,
+ " $name$_ = getDefaultInstance().get$capitalized_name$();\n");
} else {
- printer->Print(variables_,
- " $name$_ = $default$;\n");
+ printer->Print(variables_, " $name$_ = $default$;\n");
}
- printer->Print(variables_,
- "}\n");
+ printer->Print(variables_, "}\n");
}
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutablePrimitiveFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return instance.has$capitalized_name$();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return instance.has$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return instance.get$capitalized_name$();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return instance.get$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$$}$($type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " copyOnWrite();\n"
+ " instance.clear$capitalized_name$();\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
- // noop for primitives
+void ImmutablePrimitiveFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
+ if (SupportFieldPresence(descriptor_->file())) {
+ WriteIntToUtf16CharSequence(messageBitIndex_, output);
+ }
+ printer->Print(variables_, "\"$name$_\",\n");
}
-
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void ImmutablePrimitiveFieldLiteGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
if (IsByteStringWithCustomDefaultValue(descriptor_)) {
printer->Print(variables_, "$name$_ = $bytes_default$;\n");
} else if (!IsDefaultValueJavaDefault(descriptor_)) {
@@ -318,154 +324,6 @@
}
}
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateBuilderClearCode(io::Printer* printer) const {
- // noop for primitives
-}
-
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
- if (SupportFieldPresence(descriptor_->file())) {
- printer->Print(variables_,
- "$name$_ = visitor.visit$visit_type$(\n"
- " has$capitalized_name$(), $name$_,\n"
- " other.has$capitalized_name$(), other.$name$_);\n");
- } else {
- printer->Print(variables_,
- "$name$_ = visitor.visit$visit_type$($name$_ != $default$, $name$_,\n"
- " other.$name$_ != $default$, other.$name$_);\n");
- }
-}
-
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
- // noop for primitives
-}
-
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const {
- // noop for scalars
-}
-
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$set_has_field_bit_message$\n"
- "$name$_ = input.read$capitalized_type$();\n");
-}
-
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- // noop for primitives.
-}
-
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " output.write$capitalized_type$($number$, $name$_);\n"
- "}\n");
-}
-
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .compute$capitalized_type$Size($number$, $name$_);\n"
- "}\n");
-}
-
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- switch (GetJavaType(descriptor_)) {
- case JAVATYPE_INT:
- case JAVATYPE_LONG:
- case JAVATYPE_BOOLEAN:
- printer->Print(variables_,
- "result = result && (get$capitalized_name$()\n"
- " == other.get$capitalized_name$());\n");
- break;
-
- case JAVATYPE_FLOAT:
- printer->Print(variables_,
- "result = result && (\n"
- " java.lang.Float.floatToIntBits(get$capitalized_name$())\n"
- " == java.lang.Float.floatToIntBits(\n"
- " other.get$capitalized_name$()));\n");
- break;
-
- case JAVATYPE_DOUBLE:
- printer->Print(variables_,
- "result = result && (\n"
- " java.lang.Double.doubleToLongBits(get$capitalized_name$())\n"
- " == java.lang.Double.doubleToLongBits(\n"
- " other.get$capitalized_name$()));\n");
- break;
-
- case JAVATYPE_STRING:
- case JAVATYPE_BYTES:
- printer->Print(variables_,
- "result = result && get$capitalized_name$()\n"
- " .equals(other.get$capitalized_name$());\n");
- break;
-
- case JAVATYPE_ENUM:
- case JAVATYPE_MESSAGE:
- default:
- GOOGLE_LOG(FATAL) << "Can't get here.";
- break;
- }
-}
-
-void ImmutablePrimitiveFieldLiteGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n");
- switch (GetJavaType(descriptor_)) {
- case JAVATYPE_INT:
- printer->Print(variables_,
- "hash = (53 * hash) + get$capitalized_name$();\n");
- break;
-
- case JAVATYPE_LONG:
- printer->Print(variables_,
- "hash = (53 * hash) + com.google.protobuf.Internal.hashLong(\n"
- " get$capitalized_name$());\n");
- break;
-
- case JAVATYPE_BOOLEAN:
- printer->Print(variables_,
- "hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(\n"
- " get$capitalized_name$());\n");
- break;
-
- case JAVATYPE_FLOAT:
- printer->Print(variables_,
- "hash = (53 * hash) + java.lang.Float.floatToIntBits(\n"
- " get$capitalized_name$());\n");
- break;
-
- case JAVATYPE_DOUBLE:
- printer->Print(variables_,
- "hash = (53 * hash) + com.google.protobuf.Internal.hashLong(\n"
- " java.lang.Double.doubleToLongBits(get$capitalized_name$()));\n");
- break;
-
- case JAVATYPE_STRING:
- case JAVATYPE_BYTES:
- printer->Print(variables_,
- "hash = (53 * hash) + get$capitalized_name$().hashCode();\n");
- break;
-
- case JAVATYPE_ENUM:
- case JAVATYPE_MESSAGE:
- default:
- GOOGLE_LOG(FATAL) << "Can't get here.";
- break;
- }
-}
-
std::string ImmutablePrimitiveFieldLiteGenerator::GetBoxedType() const {
return BoxedPrimitiveTypeName(GetJavaType(descriptor_));
}
@@ -484,128 +342,101 @@
}
ImmutablePrimitiveOneofFieldLiteGenerator::
-~ImmutablePrimitiveOneofFieldLiteGenerator() {}
+ ~ImmutablePrimitiveOneofFieldLiteGenerator() {}
-void ImmutablePrimitiveOneofFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutablePrimitiveOneofFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " return ($boxed_type$) $oneof_name$_;\n"
- " }\n"
- " return $default$;\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " return ($boxed_type$) $oneof_name$_;\n"
+ " }\n"
+ " return $default$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$($type$ value) {\n"
- "$null_check$"
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = value;\n"
- "}\n");
+ "private void set$capitalized_name$($type$ value) {\n"
+ "$null_check$"
+ " $set_oneof_case_message$;\n"
+ " $oneof_name$_ = value;\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void clear$capitalized_name$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " $clear_oneof_case_message$;\n"
- " $oneof_name$_ = null;\n"
- " }\n"
- "}\n");
+ "private void clear$capitalized_name$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " $clear_oneof_case_message$;\n"
+ " $oneof_name$_ = null;\n"
+ " }\n"
+ "}\n");
}
+void ImmutablePrimitiveOneofFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
+ WriteIntToUtf16CharSequence(descriptor_->containing_oneof()->index(), output);
+}
-void ImmutablePrimitiveOneofFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutablePrimitiveOneofFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return instance.has$capitalized_name$();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return instance.has$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
- " return instance.get$capitalized_name$();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$() {\n"
+ " return instance.get$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$($type$ value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder "
+ "${$set$capitalized_name$$}$($type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " copyOnWrite();\n"
+ " instance.clear$capitalized_name$();\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutablePrimitiveOneofFieldLiteGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
- // noop for primitives
-}
-
-void ImmutablePrimitiveOneofFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$oneof_name$_ = visitor.visitOneof$visit_type$(\n"
- " $has_oneof_case_message$, $oneof_name$_, other.$oneof_name$_);\n");
-}
-
-void ImmutablePrimitiveOneofFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$set_oneof_case_message$;\n"
- "$oneof_name$_ = input.read$capitalized_type$();\n");
-}
-
-void ImmutablePrimitiveOneofFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " output.write$capitalized_type$(\n"
- " $number$, ($type$)(($boxed_type$) $oneof_name$_));\n"
- "}\n");
-}
-
-void ImmutablePrimitiveOneofFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .compute$capitalized_type$Size(\n"
- " $number$, ($type$)(($boxed_type$) $oneof_name$_));\n"
- "}\n");
-}
-
// ===================================================================
RepeatedImmutablePrimitiveFieldLiteGenerator::
@@ -622,326 +453,176 @@
}
RepeatedImmutablePrimitiveFieldLiteGenerator::
-~RepeatedImmutablePrimitiveFieldLiteGenerator() {}
+ ~RepeatedImmutablePrimitiveFieldLiteGenerator() {}
int RepeatedImmutablePrimitiveFieldLiteGenerator::GetNumBitsForMessage() const {
return 0;
}
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldLiteGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.util.List<$boxed_type$> get$capitalized_name$List();\n");
+ "$deprecation$java.util.List<$boxed_type$> "
+ "get$capitalized_name$List();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Count();\n");
+ "$deprecation$int get$capitalized_name$Count();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$$type$ get$capitalized_name$(int index);\n");
+ "$deprecation$$type$ get$capitalized_name$(int index);\n");
}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private $field_list_type$ $name$_;\n");
+void RepeatedImmutablePrimitiveFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_, "private $field_list_type$ $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.util.List<$boxed_type$>\n"
- " ${$get$capitalized_name$List$}$() {\n"
- " return $name$_;\n" // note: unmodifiable list
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public java.util.List<$boxed_type$>\n"
+ " ${$get$capitalized_name$List$}$() {\n"
+ " return $name$_;\n" // note: unmodifiable list
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return $name$_.size();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return $name$_.size();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
- " return $repeated_get$(index);\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
+ " return $repeated_get$(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
if (!EnableExperimentalRuntimeForLite() && descriptor_->is_packed() &&
context_->HasGeneratedMethods(descriptor_->containing_type())) {
printer->Print(variables_,
- "private int $name$MemoizedSerializedSize = -1;\n");
- }
-
- printer->Print(variables_,
- "private void ensure$capitalized_name$IsMutable() {\n"
- " if (!$is_mutable$) {\n"
- " $name$_ =\n"
- " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
- " }\n"
- "}\n");
-
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void set$capitalized_name$(\n"
- " int index, $type$ value) {\n"
- "$null_check$"
- " ensure$capitalized_name$IsMutable();\n"
- " $repeated_set$(index, value);\n"
- "}\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void add$capitalized_name$($type$ value) {\n"
- "$null_check$"
- " ensure$capitalized_name$IsMutable();\n"
- " $repeated_add$(value);\n"
- "}\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void addAll$capitalized_name$(\n"
- " java.lang.Iterable<? extends $boxed_type$> values) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " com.google.protobuf.AbstractMessageLite.addAll(\n"
- " values, $name$_);\n"
- "}\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void clear$capitalized_name$() {\n"
- " $name$_ = $empty_list$;\n"
- "}\n");
-}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.util.List<$boxed_type$>\n"
- " ${$get$capitalized_name$List$}$() {\n"
- " return java.util.Collections.unmodifiableList(\n"
- " instance.get$capitalized_name$List());\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return instance.get$capitalized_name$Count();\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
- " return instance.get$capitalized_name$(index);\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " int index, $type$ value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(index, value);\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$$}$($type$ value) {\n"
- " copyOnWrite();\n"
- " instance.add$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
- " java.lang.Iterable<? extends $boxed_type$> values) {\n"
- " copyOnWrite();\n"
- " instance.addAll$capitalized_name$(values);\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
-}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
- // noop for primitives
-}
-
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
- printer->Print(variables_, "$name$_ = $empty_list$;\n");
-}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateBuilderClearCode(io::Printer* printer) const {
- // noop for primitives
-}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$name$_= visitor.$visit_type_list$($name$_, other.$name$_);\n");
-}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
- // noop for primitives
-}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$name$_.makeImmutable();\n");
-}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- // TODO(dweis): Scan the input buffer to count, then initialize
- // appropriately.
- // TODO(dweis): Scan the input buffer to count and ensure capacity.
- printer->Print(variables_,
- "if (!$is_mutable$) {\n"
- " $name$_ =\n"
- " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
- "}\n"
- "$repeated_add$(input.read$capitalized_type$());\n");
-}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateParsingCodeFromPacked(io::Printer* printer) const {
- printer->Print(variables_,
- "int length = input.readRawVarint32();\n"
- "int limit = input.pushLimit(length);\n"
- "if (!$is_mutable$ && input.getBytesUntilLimit() > 0) {\n");
-
- int fixed_size = FixedSize(GetType(descriptor_));
- if (fixed_size == -1) {
- // TODO(dweis): Scan the input buffer to count, then initialize
- // appropriately.
- printer->Print(variables_,
- " $name$_ =\n"
- " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n");
- } else {
- printer->Print(variables_,
- " final int currentSize = $name$_.size();\n"
- " $name$_ = $name$_.mutableCopyWithCapacity(\n"
- " currentSize + (length/$fixed_size$));\n");
- }
-
- // TODO(dweis): Scan the input buffer to count and ensure capacity.
- printer->Print(variables_,
- "}\n"
- "while (input.getBytesUntilLimit() > 0) {\n"
- " $repeated_add$(input.read$capitalized_type$());\n"
- "}\n"
- "input.popLimit(limit);\n");
-}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_mutable$) {\n"
- " $make_name_unmodifiable$;\n"
- "}\n");
-}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- GOOGLE_CHECK(!EnableExperimentalRuntimeForLite());
-
- if (descriptor_->is_packed()) {
- // We invoke getSerializedSize in writeTo for messages that have packed
- // fields in ImmutableMessageGenerator::GenerateMessageSerializationMethods.
- // That makes it safe to rely on the memoized size here.
- printer->Print(variables_,
- "if (get$capitalized_name$List().size() > 0) {\n"
- " output.writeUInt32NoTag($tag$);\n"
- " output.writeUInt32NoTag($name$MemoizedSerializedSize);\n"
- "}\n"
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " output.write$capitalized_type$NoTag($repeated_get$(i));\n"
- "}\n");
- } else {
- printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " output.write$capitalized_type$($number$, $repeated_get$(i));\n"
- "}\n");
- }
-}
-
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- GOOGLE_CHECK(!EnableExperimentalRuntimeForLite());
-
- printer->Print(variables_,
- "{\n"
- " int dataSize = 0;\n");
- printer->Indent();
-
- if (FixedSize(GetType(descriptor_)) == -1) {
- printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " dataSize += com.google.protobuf.CodedOutputStream\n"
- " .compute$capitalized_type$SizeNoTag($repeated_get$(i));\n"
- "}\n");
- } else {
- printer->Print(variables_,
- "dataSize = $fixed_size$ * get$capitalized_name$List().size();\n");
+ "private int $name$MemoizedSerializedSize = -1;\n");
}
printer->Print(
- "size += dataSize;\n");
-
- if (descriptor_->is_packed()) {
- printer->Print(variables_,
- "if (!get$capitalized_name$List().isEmpty()) {\n"
- " size += $tag_size$;\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .computeInt32SizeNoTag(dataSize);\n"
+ variables_,
+ "private void ensure$capitalized_name$IsMutable() {\n"
+ " if (!$is_mutable$) {\n"
+ " $name$_ =\n"
+ " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
+ " }\n"
"}\n");
- } else {
- printer->Print(variables_,
- "size += $tag_size$ * get$capitalized_name$List().size();\n");
- }
- // cache the data size for packed fields.
- if (descriptor_->is_packed()) {
- printer->Print(variables_,
- "$name$MemoizedSerializedSize = dataSize;\n");
- }
-
- printer->Outdent();
- printer->Print("}\n");
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "private void set$capitalized_name$(\n"
+ " int index, $type$ value) {\n"
+ "$null_check$"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $repeated_set$(index, value);\n"
+ "}\n");
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "private void add$capitalized_name$($type$ value) {\n"
+ "$null_check$"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $repeated_add$(value);\n"
+ "}\n");
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "private void addAll$capitalized_name$(\n"
+ " java.lang.Iterable<? extends $boxed_type$> values) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " com.google.protobuf.AbstractMessageLite.addAll(\n"
+ " values, $name$_);\n"
+ "}\n");
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "private void clear$capitalized_name$() {\n"
+ " $name$_ = $empty_list$;\n"
+ "}\n");
}
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
+ WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "result = result && get$capitalized_name$List()\n"
- " .equals(other.get$capitalized_name$List());\n");
+ "@java.lang.Override\n"
+ "$deprecation$public java.util.List<$boxed_type$>\n"
+ " ${$get$capitalized_name$List$}$() {\n"
+ " return java.util.Collections.unmodifiableList(\n"
+ " instance.get$capitalized_name$List());\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return instance.get$capitalized_name$Count();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public $type$ ${$get$capitalized_name$$}$(int index) {\n"
+ " return instance.get$capitalized_name$(index);\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " int index, $type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(index, value);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder "
+ "${$add$capitalized_name$$}$($type$ value) {\n"
+ " copyOnWrite();\n"
+ " instance.add$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
+ " java.lang.Iterable<? extends $boxed_type$> values) {\n"
+ " copyOnWrite();\n"
+ " instance.addAll$capitalized_name$(values);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " copyOnWrite();\n"
+ " instance.clear$capitalized_name$();\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
}
-void RepeatedImmutablePrimitiveFieldLiteGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (get$capitalized_name$Count() > 0) {\n"
- " hash = (37 * hash) + $constant_name$;\n"
- " hash = (53 * hash) + get$capitalized_name$List().hashCode();\n"
- "}\n");
+void RepeatedImmutablePrimitiveFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
+ printer->Print(variables_, "\"$name$_\",\n");
+}
+
+void RepeatedImmutablePrimitiveFieldLiteGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
+ printer->Print(variables_, "$name$_ = $empty_list$;\n");
}
std::string RepeatedImmutablePrimitiveFieldLiteGenerator::GetBoxedType() const {
diff --git a/src/google/protobuf/compiler/java/java_primitive_field_lite.h b/src/google/protobuf/compiler/java/java_primitive_field_lite.h
index 6c05521..61d1e4c 100644
--- a/src/google/protobuf/compiler/java/java_primitive_field_lite.h
+++ b/src/google/protobuf/compiler/java/java_primitive_field_lite.h
@@ -69,18 +69,8 @@
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateBuilderClearCode(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
std::string GetBoxedType() const;
@@ -105,12 +95,9 @@
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImmutablePrimitiveOneofFieldLiteGenerator);
@@ -129,19 +116,8 @@
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateBuilderClearCode(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingCodeFromPacked(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
std::string GetBoxedType() const;
diff --git a/src/google/protobuf/compiler/java/java_service.cc b/src/google/protobuf/compiler/java/java_service.cc
index c598330..17d8e70 100644
--- a/src/google/protobuf/compiler/java/java_service.cc
+++ b/src/google/protobuf/compiler/java/java_service.cc
@@ -48,15 +48,16 @@
namespace java {
ServiceGenerator::ServiceGenerator(const ServiceDescriptor* descriptor)
- : descriptor_(descriptor) {}
+ : descriptor_(descriptor) {}
ServiceGenerator::~ServiceGenerator() {}
// ===================================================================
ImmutableServiceGenerator::ImmutableServiceGenerator(
const ServiceDescriptor* descriptor, Context* context)
- : ServiceGenerator(descriptor), context_(context),
- name_resolver_(context->GetNameResolver()) {}
+ : ServiceGenerator(descriptor),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {}
ImmutableServiceGenerator::~ImmutableServiceGenerator() {}
@@ -66,15 +67,13 @@
MaybePrintGeneratedAnnotation(context_, printer, descriptor_,
/* immutable = */ true);
printer->Print(
- "public $static$ abstract class $classname$\n"
- " implements com.google.protobuf.Service {\n",
- "static", is_own_file ? "" : "static",
- "classname", descriptor_->name());
+ "public $static$ abstract class $classname$\n"
+ " implements com.google.protobuf.Service {\n",
+ "static", is_own_file ? "" : "static", "classname", descriptor_->name());
printer->Indent();
- printer->Print(
- "protected $classname$() {}\n\n",
- "classname", descriptor_->name());
+ printer->Print("protected $classname$() {}\n\n", "classname",
+ descriptor_->name());
GenerateInterface(printer);
@@ -103,9 +102,9 @@
// Add an insertion point.
printer->Print(
- "\n"
- "// @@protoc_insertion_point(class_scope:$full_name$)\n",
- "full_name", descriptor_->full_name());
+ "\n"
+ "// @@protoc_insertion_point(class_scope:$full_name$)\n",
+ "full_name", descriptor_->full_name());
printer->Outdent();
printer->Print("}\n\n");
@@ -114,10 +113,10 @@
void ImmutableServiceGenerator::GenerateGetDescriptorForType(
io::Printer* printer) {
printer->Print(
- "public final com.google.protobuf.Descriptors.ServiceDescriptor\n"
- " getDescriptorForType() {\n"
- " return getDescriptor();\n"
- "}\n");
+ "public final com.google.protobuf.Descriptors.ServiceDescriptor\n"
+ " getDescriptorForType() {\n"
+ " return getDescriptor();\n"
+ "}\n");
}
void ImmutableServiceGenerator::GenerateInterface(io::Printer* printer) {
@@ -131,10 +130,10 @@
void ImmutableServiceGenerator::GenerateNewReflectiveServiceMethod(
io::Printer* printer) {
printer->Print(
- "public static com.google.protobuf.Service newReflectiveService(\n"
- " final Interface impl) {\n"
- " return new $classname$() {\n",
- "classname", descriptor_->name());
+ "public static com.google.protobuf.Service newReflectiveService(\n"
+ " final Interface impl) {\n"
+ " return new $classname$() {\n",
+ "classname", descriptor_->name());
printer->Indent();
printer->Indent();
@@ -143,10 +142,10 @@
printer->Print("@java.lang.Override\n");
GenerateMethodSignature(printer, method, IS_CONCRETE);
printer->Print(
- " {\n"
- " impl.$method$(controller, request, done);\n"
- "}\n\n",
- "method", UnderscoresToCamelCase(method));
+ " {\n"
+ " impl.$method$(controller, request, done);\n"
+ "}\n\n",
+ "method", UnderscoresToCamelCase(method));
}
printer->Outdent();
@@ -158,9 +157,9 @@
void ImmutableServiceGenerator::GenerateNewReflectiveBlockingServiceMethod(
io::Printer* printer) {
printer->Print(
- "public static com.google.protobuf.BlockingService\n"
- " newReflectiveBlockingService(final BlockingInterface impl) {\n"
- " return new com.google.protobuf.BlockingService() {\n");
+ "public static com.google.protobuf.BlockingService\n"
+ " newReflectiveBlockingService(final BlockingInterface impl) {\n"
+ " return new com.google.protobuf.BlockingService() {\n");
printer->Indent();
printer->Indent();
@@ -192,19 +191,19 @@
void ImmutableServiceGenerator::GenerateCallMethod(io::Printer* printer) {
printer->Print(
- "\n"
- "public final void callMethod(\n"
- " com.google.protobuf.Descriptors.MethodDescriptor method,\n"
- " com.google.protobuf.RpcController controller,\n"
- " com.google.protobuf.Message request,\n"
- " com.google.protobuf.RpcCallback<\n"
- " com.google.protobuf.Message> done) {\n"
- " if (method.getService() != getDescriptor()) {\n"
- " throw new java.lang.IllegalArgumentException(\n"
- " \"Service.callMethod() given method descriptor for wrong \" +\n"
- " \"service type.\");\n"
- " }\n"
- " switch(method.getIndex()) {\n");
+ "\n"
+ "public final void callMethod(\n"
+ " com.google.protobuf.Descriptors.MethodDescriptor method,\n"
+ " com.google.protobuf.RpcController controller,\n"
+ " com.google.protobuf.Message request,\n"
+ " com.google.protobuf.RpcCallback<\n"
+ " com.google.protobuf.Message> done) {\n"
+ " if (method.getService() != getDescriptor()) {\n"
+ " throw new java.lang.IllegalArgumentException(\n"
+ " \"Service.callMethod() given method descriptor for wrong \" +\n"
+ " \"service type.\");\n"
+ " }\n"
+ " switch(method.getIndex()) {\n");
printer->Indent();
printer->Indent();
@@ -213,45 +212,45 @@
std::map<std::string, std::string> vars;
vars["index"] = StrCat(i);
vars["method"] = UnderscoresToCamelCase(method);
- vars["input"] = name_resolver_->GetImmutableClassName(
- method->input_type());
+ vars["input"] = name_resolver_->GetImmutableClassName(method->input_type());
vars["output"] = GetOutput(method);
- printer->Print(vars,
- "case $index$:\n"
- " this.$method$(controller, ($input$)request,\n"
- " com.google.protobuf.RpcUtil.<$output$>specializeCallback(\n"
- " done));\n"
- " return;\n");
+ printer->Print(
+ vars,
+ "case $index$:\n"
+ " this.$method$(controller, ($input$)request,\n"
+ " com.google.protobuf.RpcUtil.<$output$>specializeCallback(\n"
+ " done));\n"
+ " return;\n");
}
printer->Print(
- "default:\n"
- " throw new java.lang.AssertionError(\"Can't get here.\");\n");
+ "default:\n"
+ " throw new java.lang.AssertionError(\"Can't get here.\");\n");
printer->Outdent();
printer->Outdent();
printer->Print(
- " }\n"
- "}\n"
- "\n");
+ " }\n"
+ "}\n"
+ "\n");
}
void ImmutableServiceGenerator::GenerateCallBlockingMethod(
io::Printer* printer) {
printer->Print(
- "\n"
- "public final com.google.protobuf.Message callBlockingMethod(\n"
- " com.google.protobuf.Descriptors.MethodDescriptor method,\n"
- " com.google.protobuf.RpcController controller,\n"
- " com.google.protobuf.Message request)\n"
- " throws com.google.protobuf.ServiceException {\n"
- " if (method.getService() != getDescriptor()) {\n"
- " throw new java.lang.IllegalArgumentException(\n"
- " \"Service.callBlockingMethod() given method descriptor for \" +\n"
- " \"wrong service type.\");\n"
- " }\n"
- " switch(method.getIndex()) {\n");
+ "\n"
+ "public final com.google.protobuf.Message callBlockingMethod(\n"
+ " com.google.protobuf.Descriptors.MethodDescriptor method,\n"
+ " com.google.protobuf.RpcController controller,\n"
+ " com.google.protobuf.Message request)\n"
+ " throws com.google.protobuf.ServiceException {\n"
+ " if (method.getService() != getDescriptor()) {\n"
+ " throw new java.lang.IllegalArgumentException(\n"
+ " \"Service.callBlockingMethod() given method descriptor for \" +\n"
+ " \"wrong service type.\");\n"
+ " }\n"
+ " switch(method.getIndex()) {\n");
printer->Indent();
printer->Indent();
@@ -260,44 +259,43 @@
std::map<std::string, std::string> vars;
vars["index"] = StrCat(i);
vars["method"] = UnderscoresToCamelCase(method);
- vars["input"] = name_resolver_->GetImmutableClassName(
- method->input_type());
+ vars["input"] = name_resolver_->GetImmutableClassName(method->input_type());
vars["output"] = GetOutput(method);
printer->Print(vars,
- "case $index$:\n"
- " return impl.$method$(controller, ($input$)request);\n");
+ "case $index$:\n"
+ " return impl.$method$(controller, ($input$)request);\n");
}
printer->Print(
- "default:\n"
- " throw new java.lang.AssertionError(\"Can't get here.\");\n");
+ "default:\n"
+ " throw new java.lang.AssertionError(\"Can't get here.\");\n");
printer->Outdent();
printer->Outdent();
printer->Print(
- " }\n"
- "}\n"
- "\n");
+ " }\n"
+ "}\n"
+ "\n");
}
void ImmutableServiceGenerator::GenerateGetPrototype(RequestOrResponse which,
- io::Printer* printer) {
+ io::Printer* printer) {
/*
* TODO(cpovirk): The exception message says "Service.foo" when it may be
* "BlockingService.foo." Consider fixing.
*/
printer->Print(
- "public final com.google.protobuf.Message\n"
- " get$request_or_response$Prototype(\n"
- " com.google.protobuf.Descriptors.MethodDescriptor method) {\n"
- " if (method.getService() != getDescriptor()) {\n"
- " throw new java.lang.IllegalArgumentException(\n"
- " \"Service.get$request_or_response$Prototype() given method \" +\n"
- " \"descriptor for wrong service type.\");\n"
- " }\n"
- " switch(method.getIndex()) {\n",
- "request_or_response", (which == REQUEST) ? "Request" : "Response");
+ "public final com.google.protobuf.Message\n"
+ " get$request_or_response$Prototype(\n"
+ " com.google.protobuf.Descriptors.MethodDescriptor method) {\n"
+ " if (method.getService() != getDescriptor()) {\n"
+ " throw new java.lang.IllegalArgumentException(\n"
+ " \"Service.get$request_or_response$Prototype() given method \" +\n"
+ " \"descriptor for wrong service type.\");\n"
+ " }\n"
+ " switch(method.getIndex()) {\n",
+ "request_or_response", (which == REQUEST) ? "Request" : "Response");
printer->Indent();
printer->Indent();
@@ -310,45 +308,46 @@
? name_resolver_->GetImmutableClassName(method->input_type())
: GetOutput(method);
printer->Print(vars,
- "case $index$:\n"
- " return $type$.getDefaultInstance();\n");
+ "case $index$:\n"
+ " return $type$.getDefaultInstance();\n");
}
printer->Print(
- "default:\n"
- " throw new java.lang.AssertionError(\"Can't get here.\");\n");
+ "default:\n"
+ " throw new java.lang.AssertionError(\"Can't get here.\");\n");
printer->Outdent();
printer->Outdent();
printer->Print(
- " }\n"
- "}\n"
- "\n");
+ " }\n"
+ "}\n"
+ "\n");
}
void ImmutableServiceGenerator::GenerateStub(io::Printer* printer) {
printer->Print(
- "public static Stub newStub(\n"
- " com.google.protobuf.RpcChannel channel) {\n"
- " return new Stub(channel);\n"
- "}\n"
- "\n"
- "public static final class Stub extends $classname$ implements Interface {"
- "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "public static Stub newStub(\n"
+ " com.google.protobuf.RpcChannel channel) {\n"
+ " return new Stub(channel);\n"
+ "}\n"
+ "\n"
+ "public static final class Stub extends $classname$ implements Interface "
+ "{"
+ "\n",
+ "classname", name_resolver_->GetImmutableClassName(descriptor_));
printer->Indent();
printer->Print(
- "private Stub(com.google.protobuf.RpcChannel channel) {\n"
- " this.channel = channel;\n"
- "}\n"
- "\n"
- "private final com.google.protobuf.RpcChannel channel;\n"
- "\n"
- "public com.google.protobuf.RpcChannel getChannel() {\n"
- " return channel;\n"
- "}\n");
+ "private Stub(com.google.protobuf.RpcChannel channel) {\n"
+ " this.channel = channel;\n"
+ "}\n"
+ "\n"
+ "private final com.google.protobuf.RpcChannel channel;\n"
+ "\n"
+ "public com.google.protobuf.RpcChannel getChannel() {\n"
+ " return channel;\n"
+ "}\n");
for (int i = 0; i < descriptor_->method_count(); i++) {
const MethodDescriptor* method = descriptor_->method(i);
@@ -361,15 +360,15 @@
vars["index"] = StrCat(i);
vars["output"] = GetOutput(method);
printer->Print(vars,
- "channel.callMethod(\n"
- " getDescriptor().getMethods().get($index$),\n"
- " controller,\n"
- " request,\n"
- " $output$.getDefaultInstance(),\n"
- " com.google.protobuf.RpcUtil.generalizeCallback(\n"
- " done,\n"
- " $output$.class,\n"
- " $output$.getDefaultInstance()));\n");
+ "channel.callMethod(\n"
+ " getDescriptor().getMethods().get($index$),\n"
+ " controller,\n"
+ " request,\n"
+ " $output$.getDefaultInstance(),\n"
+ " com.google.protobuf.RpcUtil.generalizeCallback(\n"
+ " done,\n"
+ " $output$.class,\n"
+ " $output$.getDefaultInstance()));\n");
printer->Outdent();
printer->Print("}\n");
@@ -377,20 +376,19 @@
printer->Outdent();
printer->Print(
- "}\n"
- "\n");
+ "}\n"
+ "\n");
}
void ImmutableServiceGenerator::GenerateBlockingStub(io::Printer* printer) {
printer->Print(
- "public static BlockingInterface newBlockingStub(\n"
- " com.google.protobuf.BlockingRpcChannel channel) {\n"
- " return new BlockingStub(channel);\n"
- "}\n"
- "\n");
+ "public static BlockingInterface newBlockingStub(\n"
+ " com.google.protobuf.BlockingRpcChannel channel) {\n"
+ " return new BlockingStub(channel);\n"
+ "}\n"
+ "\n");
- printer->Print(
- "public interface BlockingInterface {");
+ printer->Print("public interface BlockingInterface {");
printer->Indent();
for (int i = 0; i < descriptor_->method_count(); i++) {
@@ -401,19 +399,20 @@
printer->Outdent();
printer->Print(
- "}\n"
- "\n");
+ "}\n"
+ "\n");
printer->Print(
- "private static final class BlockingStub implements BlockingInterface {\n");
+ "private static final class BlockingStub implements BlockingInterface "
+ "{\n");
printer->Indent();
printer->Print(
- "private BlockingStub(com.google.protobuf.BlockingRpcChannel channel) {\n"
- " this.channel = channel;\n"
- "}\n"
- "\n"
- "private final com.google.protobuf.BlockingRpcChannel channel;\n");
+ "private BlockingStub(com.google.protobuf.BlockingRpcChannel channel) {\n"
+ " this.channel = channel;\n"
+ "}\n"
+ "\n"
+ "private final com.google.protobuf.BlockingRpcChannel channel;\n");
for (int i = 0; i < descriptor_->method_count(); i++) {
const MethodDescriptor* method = descriptor_->method(i);
@@ -425,50 +424,49 @@
vars["index"] = StrCat(i);
vars["output"] = GetOutput(method);
printer->Print(vars,
- "return ($output$) channel.callBlockingMethod(\n"
- " getDescriptor().getMethods().get($index$),\n"
- " controller,\n"
- " request,\n"
- " $output$.getDefaultInstance());\n");
+ "return ($output$) channel.callBlockingMethod(\n"
+ " getDescriptor().getMethods().get($index$),\n"
+ " controller,\n"
+ " request,\n"
+ " $output$.getDefaultInstance());\n");
printer->Outdent();
printer->Print(
- "}\n"
- "\n");
+ "}\n"
+ "\n");
}
printer->Outdent();
printer->Print("}\n");
}
-void ImmutableServiceGenerator::GenerateMethodSignature(io::Printer* printer,
- const MethodDescriptor* method,
- IsAbstract is_abstract) {
+void ImmutableServiceGenerator::GenerateMethodSignature(
+ io::Printer* printer, const MethodDescriptor* method,
+ IsAbstract is_abstract) {
std::map<std::string, std::string> vars;
vars["name"] = UnderscoresToCamelCase(method);
vars["input"] = name_resolver_->GetImmutableClassName(method->input_type());
vars["output"] = GetOutput(method);
vars["abstract"] = (is_abstract == IS_ABSTRACT) ? "abstract" : "";
printer->Print(vars,
- "public $abstract$ void $name$(\n"
- " com.google.protobuf.RpcController controller,\n"
- " $input$ request,\n"
- " com.google.protobuf.RpcCallback<$output$> done)");
+ "public $abstract$ void $name$(\n"
+ " com.google.protobuf.RpcController controller,\n"
+ " $input$ request,\n"
+ " com.google.protobuf.RpcCallback<$output$> done)");
}
void ImmutableServiceGenerator::GenerateBlockingMethodSignature(
- io::Printer* printer,
- const MethodDescriptor* method) {
+ io::Printer* printer, const MethodDescriptor* method) {
std::map<std::string, std::string> vars;
vars["method"] = UnderscoresToCamelCase(method);
vars["input"] = name_resolver_->GetImmutableClassName(method->input_type());
vars["output"] = GetOutput(method);
printer->Print(vars,
- "\n"
- "public $output$ $method$(\n"
- " com.google.protobuf.RpcController controller,\n"
- " $input$ request)\n"
- " throws com.google.protobuf.ServiceException");
+ "\n"
+ "public $output$ $method$(\n"
+ " com.google.protobuf.RpcController controller,\n"
+ " $input$ request)\n"
+ " throws com.google.protobuf.ServiceException");
}
} // namespace java
diff --git a/src/google/protobuf/compiler/java/java_service.h b/src/google/protobuf/compiler/java/java_service.h
index 24b0cca..1c82c16 100644
--- a/src/google/protobuf/compiler/java/java_service.h
+++ b/src/google/protobuf/compiler/java/java_service.h
@@ -83,7 +83,6 @@
virtual void Generate(io::Printer* printer);
private:
-
// Generate the getDescriptorForType() method.
void GenerateGetDescriptorForType(io::Printer* printer);
diff --git a/src/google/protobuf/compiler/java/java_shared_code_generator.cc b/src/google/protobuf/compiler/java/java_shared_code_generator.cc
index a7931f0..f673e68 100644
--- a/src/google/protobuf/compiler/java/java_shared_code_generator.cc
+++ b/src/google/protobuf/compiler/java/java_shared_code_generator.cc
@@ -52,8 +52,7 @@
const Options& options)
: name_resolver_(new ClassNameResolver), file_(file), options_(options) {}
-SharedCodeGenerator::~SharedCodeGenerator() {
-}
+SharedCodeGenerator::~SharedCodeGenerator() {}
void SharedCodeGenerator::Generate(
GeneratorContext* context, std::vector<std::string>* file_list,
@@ -82,9 +81,9 @@
"filename", file_->name());
if (!java_package.empty()) {
printer->Print(
- "package $package$;\n"
- "\n",
- "package", java_package);
+ "package $package$;\n"
+ "\n",
+ "package", java_package);
}
PrintGeneratedAnnotation(printer.get(), '$',
options_.annotate_code ? info_relative_path : "");
@@ -101,8 +100,8 @@
printer->Outdent();
printer->Outdent();
printer->Print(
- " }\n"
- "}\n");
+ " }\n"
+ "}\n");
if (options_.annotate_code) {
std::unique_ptr<io::ZeroCopyOutputStream> info_output(
@@ -133,8 +132,7 @@
std::string file_data;
file_proto.SerializeToString(&file_data);
- printer->Print(
- "java.lang.String[] descriptorData = {\n");
+ printer->Print("java.lang.String[] descriptorData = {\n");
printer->Indent();
// Limit the number of bytes per line.
@@ -152,8 +150,8 @@
printer->Print(" +\n");
}
}
- printer->Print("\"$data$\"",
- "data", CEscape(file_data.substr(i, kBytesPerLine)));
+ printer->Print("\"$data$\"", "data",
+ CEscape(file_data.substr(i, kBytesPerLine)));
}
printer->Outdent();
@@ -179,20 +177,18 @@
// -----------------------------------------------------------------
// Invoke internalBuildGeneratedFileFrom() to build the file.
printer->Print(
- "descriptor = com.google.protobuf.Descriptors.FileDescriptor\n"
- " .internalBuildGeneratedFileFrom(descriptorData,\n");
+ "descriptor = com.google.protobuf.Descriptors.FileDescriptor\n"
+ " .internalBuildGeneratedFileFrom(descriptorData,\n");
printer->Print(
- " new com.google.protobuf.Descriptors.FileDescriptor[] {\n");
+ " new com.google.protobuf.Descriptors.FileDescriptor[] {\n");
for (int i = 0; i < dependencies.size(); i++) {
const std::string& dependency = dependencies[i].second;
- printer->Print(
- " $dependency$.getDescriptor(),\n",
- "dependency", dependency);
+ printer->Print(" $dependency$.getDescriptor(),\n", "dependency",
+ dependency);
}
- printer->Print(
- " });\n");
+ printer->Print(" });\n");
}
} // namespace java
diff --git a/src/google/protobuf/compiler/java/java_shared_code_generator.h b/src/google/protobuf/compiler/java/java_shared_code_generator.h
index 2f09c3a..7c79abe 100644
--- a/src/google/protobuf/compiler/java/java_shared_code_generator.h
+++ b/src/google/protobuf/compiler/java/java_shared_code_generator.h
@@ -82,7 +82,6 @@
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SharedCodeGenerator);
};
-
} // namespace java
} // namespace compiler
} // namespace protobuf
diff --git a/src/google/protobuf/compiler/java/java_string_field.cc b/src/google/protobuf/compiler/java/java_string_field.cc
index a20d7ef..d68f178 100644
--- a/src/google/protobuf/compiler/java/java_string_field.cc
+++ b/src/google/protobuf/compiler/java/java_string_field.cc
@@ -79,17 +79,16 @@
" if (value == null) {\n"
" throw new NullPointerException();\n"
" }\n";
- (*variables)["writeString"] =
- "com.google.protobuf.GeneratedMessage" + GeneratedCodeVersionSuffix() +
- ".writeString";
- (*variables)["computeStringSize"] =
- "com.google.protobuf.GeneratedMessage" + GeneratedCodeVersionSuffix() +
- ".computeStringSize";
+ (*variables)["writeString"] = "com.google.protobuf.GeneratedMessage" +
+ GeneratedCodeVersionSuffix() + ".writeString";
+ (*variables)["computeStringSize"] = "com.google.protobuf.GeneratedMessage" +
+ GeneratedCodeVersionSuffix() +
+ ".computeStringSize";
// TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
// by the proto compiler
- (*variables)["deprecation"] = descriptor->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ (*variables)["deprecation"] =
+ descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
(*variables)["on_changed"] = "onChanged();";
if (SupportFieldPresence(descriptor->file())) {
@@ -137,14 +136,14 @@
// ===================================================================
-ImmutableStringFieldGenerator::
-ImmutableStringFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
- builderBitIndex_(builderBitIndex), context_(context),
- name_resolver_(context->GetNameResolver()) {
+ImmutableStringFieldGenerator::ImmutableStringFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : descriptor_(descriptor),
+ messageBitIndex_(messageBitIndex),
+ builderBitIndex_(builderBitIndex),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
SetPrimitiveVariables(descriptor, messageBitIndex, builderBitIndex,
context->GetFieldGeneratorInfo(descriptor),
name_resolver_, &variables_);
@@ -192,275 +191,275 @@
// For single fields, the logic for this is done inside the generated code. For
// repeated fields, the logic is done in LazyStringArrayList and
// UnmodifiableLazyStringList.
-void ImmutableStringFieldGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$boolean has$capitalized_name$();\n");
+ "$deprecation$boolean has$capitalized_name$();\n");
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.lang.String get$capitalized_name$();\n");
+ "$deprecation$java.lang.String get$capitalized_name$();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$com.google.protobuf.ByteString\n"
- " get$capitalized_name$Bytes();\n");
+ "$deprecation$com.google.protobuf.ByteString\n"
+ " get$capitalized_name$Bytes();\n");
}
-void ImmutableStringFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private volatile java.lang.Object $name$_;\n");
+void ImmutableStringFieldGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_, "private volatile java.lang.Object $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
- " java.lang.Object ref = $name$_;\n"
- " if (ref instanceof java.lang.String) {\n"
- " return (java.lang.String) ref;\n"
- " } else {\n"
- " com.google.protobuf.ByteString bs = \n"
- " (com.google.protobuf.ByteString) ref;\n"
+ printer->Print(
+ variables_,
+ "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
+ " java.lang.Object ref = $name$_;\n"
+ " if (ref instanceof java.lang.String) {\n"
+ " return (java.lang.String) ref;\n"
+ " } else {\n"
+ " com.google.protobuf.ByteString bs = \n"
+ " (com.google.protobuf.ByteString) ref;\n"
" java.lang.String s = bs.toStringUtf8();\n");
printer->Annotate("{", "}", descriptor_);
if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- " $name$_ = s;\n");
+ printer->Print(variables_, " $name$_ = s;\n");
} else {
printer->Print(variables_,
- " if (bs.isValidUtf8()) {\n"
- " $name$_ = s;\n"
- " }\n");
+ " if (bs.isValidUtf8()) {\n"
+ " $name$_ = s;\n"
+ " }\n");
}
printer->Print(variables_,
- " return s;\n"
- " }\n"
- "}\n");
+ " return s;\n"
+ " }\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$() {\n"
- " java.lang.Object ref = $name$_;\n"
- " if (ref instanceof java.lang.String) {\n"
- " com.google.protobuf.ByteString b = \n"
- " com.google.protobuf.ByteString.copyFromUtf8(\n"
- " (java.lang.String) ref);\n"
- " $name$_ = b;\n"
- " return b;\n"
- " } else {\n"
- " return (com.google.protobuf.ByteString) ref;\n"
- " }\n"
- "}\n");
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$() {\n"
+ " java.lang.Object ref = $name$_;\n"
+ " if (ref instanceof java.lang.String) {\n"
+ " com.google.protobuf.ByteString b = \n"
+ " com.google.protobuf.ByteString.copyFromUtf8(\n"
+ " (java.lang.String) ref);\n"
+ " $name$_ = b;\n"
+ " return b;\n"
+ " } else {\n"
+ " return (com.google.protobuf.ByteString) ref;\n"
+ " }\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutableStringFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
printer->Print(variables_,
- "private java.lang.Object $name$_ $default_init$;\n");
+ "private java.lang.Object $name$_ $default_init$;\n");
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_builder$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_builder$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
- " java.lang.Object ref = $name$_;\n"
- " if (!(ref instanceof java.lang.String)) {\n"
- " com.google.protobuf.ByteString bs =\n"
- " (com.google.protobuf.ByteString) ref;\n"
- " java.lang.String s = bs.toStringUtf8();\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
+ " java.lang.Object ref = $name$_;\n"
+ " if (!(ref instanceof java.lang.String)) {\n"
+ " com.google.protobuf.ByteString bs =\n"
+ " (com.google.protobuf.ByteString) ref;\n"
+ " java.lang.String s = bs.toStringUtf8();\n");
printer->Annotate("{", "}", descriptor_);
if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- " $name$_ = s;\n");
+ printer->Print(variables_, " $name$_ = s;\n");
} else {
printer->Print(variables_,
- " if (bs.isValidUtf8()) {\n"
- " $name$_ = s;\n"
- " }\n");
+ " if (bs.isValidUtf8()) {\n"
+ " $name$_ = s;\n"
+ " }\n");
}
printer->Print(variables_,
- " return s;\n"
- " } else {\n"
- " return (java.lang.String) ref;\n"
- " }\n"
- "}\n");
+ " return s;\n"
+ " } else {\n"
+ " return (java.lang.String) ref;\n"
+ " }\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$() {\n"
- " java.lang.Object ref = $name$_;\n"
- " if (ref instanceof String) {\n"
- " com.google.protobuf.ByteString b = \n"
- " com.google.protobuf.ByteString.copyFromUtf8(\n"
- " (java.lang.String) ref);\n"
- " $name$_ = b;\n"
- " return b;\n"
- " } else {\n"
- " return (com.google.protobuf.ByteString) ref;\n"
- " }\n"
- "}\n");
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$() {\n"
+ " java.lang.Object ref = $name$_;\n"
+ " if (ref instanceof String) {\n"
+ " com.google.protobuf.ByteString b = \n"
+ " com.google.protobuf.ByteString.copyFromUtf8(\n"
+ " (java.lang.String) ref);\n"
+ " $name$_ = b;\n"
+ " return b;\n"
+ " } else {\n"
+ " return (com.google.protobuf.ByteString) ref;\n"
+ " }\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " java.lang.String value) {\n"
- "$null_check$"
- " $set_has_field_bit_builder$\n"
- " $name$_ = value;\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " java.lang.String value) {\n"
+ "$null_check$"
+ " $set_has_field_bit_builder$\n"
+ " $name$_ = value;\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " $clear_has_field_bit_builder$\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " $clear_has_field_bit_builder$\n");
printer->Annotate("{", "}", descriptor_);
// The default value is not a simple literal so we want to avoid executing
// it multiple times. Instead, get the default out of the default instance.
printer->Print(variables_,
- " $name$_ = getDefaultInstance().get$capitalized_name$();\n");
+ " $name$_ = getDefaultInstance().get$capitalized_name$();\n");
printer->Print(variables_,
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$Bytes$}$(\n"
- " com.google.protobuf.ByteString value) {\n"
- "$null_check$");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$set$capitalized_name$Bytes$}$(\n"
+ " com.google.protobuf.ByteString value) {\n"
+ "$null_check$");
printer->Annotate("{", "}", descriptor_);
if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- " checkByteStringIsUtf8(value);\n");
+ printer->Print(variables_, " checkByteStringIsUtf8(value);\n");
}
printer->Print(variables_,
- " $set_has_field_bit_builder$\n"
- " $name$_ = value;\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ " $set_has_field_bit_builder$\n"
+ " $name$_ = value;\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
}
-void ImmutableStringFieldGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const {
// noop for primitives
}
-void ImmutableStringFieldGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
printer->Print(variables_, "$name$_ = $default$;\n");
}
-void ImmutableStringFieldGenerator::
-GenerateBuilderClearCode(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "$name$_ = $default$;\n"
- "$clear_has_field_bit_builder$\n");
+ "$name$_ = $default$;\n"
+ "$clear_has_field_bit_builder$\n");
}
-void ImmutableStringFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
// Allow a slight breach of abstraction here in order to avoid forcing
// all string fields to Strings when copying fields from a Message.
printer->Print(variables_,
- "if (other.has$capitalized_name$()) {\n"
- " $set_has_field_bit_builder$\n"
- " $name$_ = other.$name$_;\n"
- " $on_changed$\n"
- "}\n");
+ "if (other.has$capitalized_name$()) {\n"
+ " $set_has_field_bit_builder$\n"
+ " $name$_ = other.$name$_;\n"
+ " $on_changed$\n"
+ "}\n");
} else {
printer->Print(variables_,
- "if (!other.get$capitalized_name$().isEmpty()) {\n"
- " $name$_ = other.$name$_;\n"
- " $on_changed$\n"
- "}\n");
+ "if (!other.get$capitalized_name$().isEmpty()) {\n"
+ " $name$_ = other.$name$_;\n"
+ " $on_changed$\n"
+ "}\n");
}
}
-void ImmutableStringFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
printer->Print(variables_,
- "if ($get_has_field_bit_from_local$) {\n"
- " $set_has_field_bit_to_local$;\n"
- "}\n");
+ "if ($get_has_field_bit_from_local$) {\n"
+ " $set_has_field_bit_to_local$;\n"
+ "}\n");
}
- printer->Print(variables_,
- "result.$name$_ = $name$_;\n");
+ printer->Print(variables_, "result.$name$_ = $name$_;\n");
}
-void ImmutableStringFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
if (CheckUtf8(descriptor_)) {
printer->Print(variables_,
- "java.lang.String s = input.readStringRequireUtf8();\n"
- "$set_has_field_bit_message$\n"
- "$name$_ = s;\n");
+ "java.lang.String s = input.readStringRequireUtf8();\n"
+ "$set_has_field_bit_message$\n"
+ "$name$_ = s;\n");
} else {
printer->Print(variables_,
- "com.google.protobuf.ByteString bs = input.readBytes();\n"
- "$set_has_field_bit_message$\n"
- "$name$_ = bs;\n");
+ "com.google.protobuf.ByteString bs = input.readBytes();\n"
+ "$set_has_field_bit_message$\n"
+ "$name$_ = bs;\n");
}
}
-void ImmutableStringFieldGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateParsingDoneCode(
+ io::Printer* printer) const {
// noop for strings.
}
-void ImmutableStringFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " $writeString$(output, $number$, $name$_);\n"
- "}\n");
+ "if ($is_field_present_message$) {\n"
+ " $writeString$(output, $number$, $name$_);\n"
+ "}\n");
}
-void ImmutableStringFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " size += $computeStringSize$($number$, $name$_);\n"
- "}\n");
+ "if ($is_field_present_message$) {\n"
+ " size += $computeStringSize$($number$, $name$_);\n"
+ "}\n");
}
-void ImmutableStringFieldGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateEqualsCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if (!get$capitalized_name$()\n"
- " .equals(other.get$capitalized_name$())) return false;\n");
+ "if (!get$capitalized_name$()\n"
+ " .equals(other.get$capitalized_name$())) return false;\n");
}
-void ImmutableStringFieldGenerator::
-GenerateHashCode(io::Printer* printer) const {
+void ImmutableStringFieldGenerator::GenerateHashCode(
+ io::Printer* printer) const {
+ printer->Print(variables_, "hash = (37 * hash) + $constant_name$;\n");
printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n");
- printer->Print(variables_,
- "hash = (53 * hash) + get$capitalized_name$().hashCode();\n");
+ "hash = (53 * hash) + get$capitalized_name$().hashCode();\n");
}
std::string ImmutableStringFieldGenerator::GetBoxedType() const {
@@ -469,257 +468,258 @@
// ===================================================================
-ImmutableStringOneofFieldGenerator::
-ImmutableStringOneofFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : ImmutableStringFieldGenerator(
- descriptor, messageBitIndex, builderBitIndex, context) {
+ImmutableStringOneofFieldGenerator::ImmutableStringOneofFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : ImmutableStringFieldGenerator(descriptor, messageBitIndex,
+ builderBitIndex, context) {
const OneofGeneratorInfo* info =
context->GetOneofGeneratorInfo(descriptor->containing_oneof());
SetCommonOneofVariables(descriptor, info, &variables_);
}
-ImmutableStringOneofFieldGenerator::
-~ImmutableStringOneofFieldGenerator() {}
+ImmutableStringOneofFieldGenerator::~ImmutableStringOneofFieldGenerator() {}
-void ImmutableStringOneofFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutableStringOneofFieldGenerator::GenerateMembers(
+ io::Printer* printer) const {
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- }
-
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
- " java.lang.Object ref $default_init$;\n"
- " if ($has_oneof_case_message$) {\n"
- " ref = $oneof_name$_;\n"
- " }\n"
- " if (ref instanceof java.lang.String) {\n"
- " return (java.lang.String) ref;\n"
- " } else {\n"
- " com.google.protobuf.ByteString bs = \n"
- " (com.google.protobuf.ByteString) ref;\n"
- " java.lang.String s = bs.toStringUtf8();\n");
- printer->Annotate("{", "}", descriptor_);
- if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- " if ($has_oneof_case_message$) {\n"
- " $oneof_name$_ = s;\n"
- " }\n");
- } else {
- printer->Print(variables_,
- " if (bs.isValidUtf8() && ($has_oneof_case_message$)) {\n"
- " $oneof_name$_ = s;\n"
- " }\n");
- }
- printer->Print(variables_,
- " return s;\n"
- " }\n"
- "}\n");
- WriteFieldDocComment(printer, descriptor_);
-
- printer->Print(variables_,
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$() {\n"
- " java.lang.Object ref $default_init$;\n"
- " if ($has_oneof_case_message$) {\n"
- " ref = $oneof_name$_;\n"
- " }\n"
- " if (ref instanceof java.lang.String) {\n"
- " com.google.protobuf.ByteString b = \n"
- " com.google.protobuf.ByteString.copyFromUtf8(\n"
- " (java.lang.String) ref);\n"
- " if ($has_oneof_case_message$) {\n"
- " $oneof_name$_ = b;\n"
- " }\n"
- " return b;\n"
- " } else {\n"
- " return (com.google.protobuf.ByteString) ref;\n"
- " }\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
-}
-
-void ImmutableStringOneofFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
- if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
- " java.lang.Object ref $default_init$;\n"
- " if ($has_oneof_case_message$) {\n"
- " ref = $oneof_name$_;\n"
- " }\n"
- " if (!(ref instanceof java.lang.String)) {\n"
- " com.google.protobuf.ByteString bs =\n"
- " (com.google.protobuf.ByteString) ref;\n"
- " java.lang.String s = bs.toStringUtf8();\n"
- " if ($has_oneof_case_message$) {\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
+ " java.lang.Object ref $default_init$;\n"
+ " if ($has_oneof_case_message$) {\n"
+ " ref = $oneof_name$_;\n"
+ " }\n"
+ " if (ref instanceof java.lang.String) {\n"
+ " return (java.lang.String) ref;\n"
+ " } else {\n"
+ " com.google.protobuf.ByteString bs = \n"
+ " (com.google.protobuf.ByteString) ref;\n"
+ " java.lang.String s = bs.toStringUtf8();\n");
printer->Annotate("{", "}", descriptor_);
if (CheckUtf8(descriptor_)) {
printer->Print(variables_,
- " $oneof_name$_ = s;\n");
+ " if ($has_oneof_case_message$) {\n"
+ " $oneof_name$_ = s;\n"
+ " }\n");
} else {
printer->Print(variables_,
- " if (bs.isValidUtf8()) {\n"
- " $oneof_name$_ = s;\n"
- " }\n");
+ " if (bs.isValidUtf8() && ($has_oneof_case_message$)) {\n"
+ " $oneof_name$_ = s;\n"
+ " }\n");
}
printer->Print(variables_,
- " }\n"
- " return s;\n"
- " } else {\n"
- " return (java.lang.String) ref;\n"
- " }\n"
- "}\n");
+ " return s;\n"
+ " }\n"
+ "}\n");
+ WriteFieldDocComment(printer, descriptor_);
- WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$() {\n"
- " java.lang.Object ref $default_init$;\n"
- " if ($has_oneof_case_message$) {\n"
- " ref = $oneof_name$_;\n"
- " }\n"
- " if (ref instanceof String) {\n"
- " com.google.protobuf.ByteString b = \n"
- " com.google.protobuf.ByteString.copyFromUtf8(\n"
- " (java.lang.String) ref);\n"
- " if ($has_oneof_case_message$) {\n"
- " $oneof_name$_ = b;\n"
- " }\n"
- " return b;\n"
- " } else {\n"
- " return (com.google.protobuf.ByteString) ref;\n"
- " }\n"
- "}\n");
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$() {\n"
+ " java.lang.Object ref $default_init$;\n"
+ " if ($has_oneof_case_message$) {\n"
+ " ref = $oneof_name$_;\n"
+ " }\n"
+ " if (ref instanceof java.lang.String) {\n"
+ " com.google.protobuf.ByteString b = \n"
+ " com.google.protobuf.ByteString.copyFromUtf8(\n"
+ " (java.lang.String) ref);\n"
+ " if ($has_oneof_case_message$) {\n"
+ " $oneof_name$_ = b;\n"
+ " }\n"
+ " return b;\n"
+ " } else {\n"
+ " return (com.google.protobuf.ByteString) ref;\n"
+ " }\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
-
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " java.lang.String value) {\n"
- "$null_check$"
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = value;\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " $clear_oneof_case_message$;\n"
- " $oneof_name$_ = null;\n"
- " $on_changed$\n"
- " }\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
-
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$Bytes$}$(\n"
- " com.google.protobuf.ByteString value) {\n"
- "$null_check$");
- printer->Annotate("{", "}", descriptor_);
- if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- " checkByteStringIsUtf8(value);\n");
- }
- printer->Print(variables_,
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = value;\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
}
-void ImmutableStringOneofFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void ImmutableStringOneofFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
+ if (SupportFieldPresence(descriptor_->file())) {
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ }
+
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
+ " java.lang.Object ref $default_init$;\n"
+ " if ($has_oneof_case_message$) {\n"
+ " ref = $oneof_name$_;\n"
+ " }\n"
+ " if (!(ref instanceof java.lang.String)) {\n"
+ " com.google.protobuf.ByteString bs =\n"
+ " (com.google.protobuf.ByteString) ref;\n"
+ " java.lang.String s = bs.toStringUtf8();\n"
+ " if ($has_oneof_case_message$) {\n");
+ printer->Annotate("{", "}", descriptor_);
+ if (CheckUtf8(descriptor_)) {
+ printer->Print(variables_, " $oneof_name$_ = s;\n");
+ } else {
+ printer->Print(variables_,
+ " if (bs.isValidUtf8()) {\n"
+ " $oneof_name$_ = s;\n"
+ " }\n");
+ }
+ printer->Print(variables_,
+ " }\n"
+ " return s;\n"
+ " } else {\n"
+ " return (java.lang.String) ref;\n"
+ " }\n"
+ "}\n");
+
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$() {\n"
+ " java.lang.Object ref $default_init$;\n"
+ " if ($has_oneof_case_message$) {\n"
+ " ref = $oneof_name$_;\n"
+ " }\n"
+ " if (ref instanceof String) {\n"
+ " com.google.protobuf.ByteString b = \n"
+ " com.google.protobuf.ByteString.copyFromUtf8(\n"
+ " (java.lang.String) ref);\n"
+ " if ($has_oneof_case_message$) {\n"
+ " $oneof_name$_ = b;\n"
+ " }\n"
+ " return b;\n"
+ " } else {\n"
+ " return (com.google.protobuf.ByteString) ref;\n"
+ " }\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " java.lang.String value) {\n"
+ "$null_check$"
+ " $set_oneof_case_message$;\n"
+ " $oneof_name$_ = value;\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " $clear_oneof_case_message$;\n"
+ " $oneof_name$_ = null;\n"
+ " $on_changed$\n"
+ " }\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$set$capitalized_name$Bytes$}$(\n"
+ " com.google.protobuf.ByteString value) {\n"
+ "$null_check$");
+ printer->Annotate("{", "}", descriptor_);
+ if (CheckUtf8(descriptor_)) {
+ printer->Print(variables_, " checkByteStringIsUtf8(value);\n");
+ }
+ printer->Print(variables_,
+ " $set_oneof_case_message$;\n"
+ " $oneof_name$_ = value;\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
+}
+
+void ImmutableStringOneofFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
// Allow a slight breach of abstraction here in order to avoid forcing
// all string fields to Strings when copying fields from a Message.
printer->Print(variables_,
- "$set_oneof_case_message$;\n"
- "$oneof_name$_ = other.$oneof_name$_;\n"
- "$on_changed$\n");
+ "$set_oneof_case_message$;\n"
+ "$oneof_name$_ = other.$oneof_name$_;\n"
+ "$on_changed$\n");
}
-void ImmutableStringOneofFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
+void ImmutableStringOneofFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " result.$oneof_name$_ = $oneof_name$_;\n"
- "}\n");
+ "if ($has_oneof_case_message$) {\n"
+ " result.$oneof_name$_ = $oneof_name$_;\n"
+ "}\n");
}
-void ImmutableStringOneofFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void ImmutableStringOneofFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
if (CheckUtf8(descriptor_)) {
printer->Print(variables_,
- "java.lang.String s = input.readStringRequireUtf8();\n"
- "$set_oneof_case_message$;\n"
- "$oneof_name$_ = s;\n");
+ "java.lang.String s = input.readStringRequireUtf8();\n"
+ "$set_oneof_case_message$;\n"
+ "$oneof_name$_ = s;\n");
} else {
printer->Print(variables_,
- "com.google.protobuf.ByteString bs = input.readBytes();\n"
- "$set_oneof_case_message$;\n"
- "$oneof_name$_ = bs;\n");
+ "com.google.protobuf.ByteString bs = input.readBytes();\n"
+ "$set_oneof_case_message$;\n"
+ "$oneof_name$_ = bs;\n");
}
}
-void ImmutableStringOneofFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
+void ImmutableStringOneofFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " $writeString$(output, $number$, $oneof_name$_);\n"
- "}\n");
+ "if ($has_oneof_case_message$) {\n"
+ " $writeString$(output, $number$, $oneof_name$_);\n"
+ "}\n");
}
-void ImmutableStringOneofFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
+void ImmutableStringOneofFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " size += $computeStringSize$($number$, $oneof_name$_);\n"
- "}\n");
+ "if ($has_oneof_case_message$) {\n"
+ " size += $computeStringSize$($number$, $oneof_name$_);\n"
+ "}\n");
}
// ===================================================================
-RepeatedImmutableStringFieldGenerator::
-RepeatedImmutableStringFieldGenerator(const FieldDescriptor* descriptor,
- int messageBitIndex,
- int builderBitIndex,
- Context* context)
- : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
- builderBitIndex_(builderBitIndex), context_(context),
- name_resolver_(context->GetNameResolver()) {
+RepeatedImmutableStringFieldGenerator::RepeatedImmutableStringFieldGenerator(
+ const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+ Context* context)
+ : descriptor_(descriptor),
+ messageBitIndex_(messageBitIndex),
+ builderBitIndex_(builderBitIndex),
+ context_(context),
+ name_resolver_(context->GetNameResolver()) {
SetPrimitiveVariables(descriptor, messageBitIndex, builderBitIndex,
context->GetFieldGeneratorInfo(descriptor),
name_resolver_, &variables_);
}
RepeatedImmutableStringFieldGenerator::
-~RepeatedImmutableStringFieldGenerator() {}
+ ~RepeatedImmutableStringFieldGenerator() {}
int RepeatedImmutableStringFieldGenerator::GetNumBitsForMessage() const {
return 0;
@@ -729,67 +729,69 @@
return 1;
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void RepeatedImmutableStringFieldGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ // NOTE: the same method in the implementation class actually returns
+ // com.google.protobuf.ProtocolStringList (a subclass of List). It's
+ // changed between protobuf 2.5.0 release and protobuf 2.6.1 release.
+ // To retain binary compatibility with both 2.5.0 and 2.6.1 generated
+ // code, we make this interface method return List so both methods
+ // with different return types exist in the compiled byte code.
+ "$deprecation$java.util.List<java.lang.String>\n"
+ " get$capitalized_name$List();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- // NOTE: the same method in the implementation class actually returns
- // com.google.protobuf.ProtocolStringList (a subclass of List). It's
- // changed between protobuf 2.5.0 release and protobuf 2.6.1 release.
- // To retain binary compatibility with both 2.5.0 and 2.6.1 generated
- // code, we make this interface method return List so both methods
- // with different return types exist in the compiled byte code.
- "$deprecation$java.util.List<java.lang.String>\n"
- " get$capitalized_name$List();\n");
+ "$deprecation$int get$capitalized_name$Count();\n");
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$java.lang.String get$capitalized_name$(int index);\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Count();\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$java.lang.String get$capitalized_name$(int index);\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$com.google.protobuf.ByteString\n"
- " get$capitalized_name$Bytes(int index);\n");
+ "$deprecation$com.google.protobuf.ByteString\n"
+ " get$capitalized_name$Bytes(int index);\n");
}
-
-void RepeatedImmutableStringFieldGenerator::
-GenerateMembers(io::Printer* printer) const {
+void RepeatedImmutableStringFieldGenerator::GenerateMembers(
+ io::Printer* printer) const {
printer->Print(variables_,
- "private com.google.protobuf.LazyStringList $name$_;\n");
+ "private com.google.protobuf.LazyStringList $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public com.google.protobuf.ProtocolStringList\n"
- " ${$get$capitalized_name$List$}$() {\n"
- " return $name$_;\n" // note: unmodifiable list
- "}\n");
+ "$deprecation$public com.google.protobuf.ProtocolStringList\n"
+ " ${$get$capitalized_name$List$}$() {\n"
+ " return $name$_;\n" // note: unmodifiable list
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return $name$_.size();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return $name$_.size();\n"
- "}\n");
+ "$deprecation$public java.lang.String "
+ "${$get$capitalized_name$$}$(int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public java.lang.String "
- "${$get$capitalized_name$$}$(int index) {\n"
- " return $name$_.get(index);\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$(int index) {\n"
- " return $name$_.getByteString(index);\n"
- "}\n");
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$(int index) {\n"
+ " return $name$_.getByteString(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void RepeatedImmutableStringFieldGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
// One field is the list and the bit field keeps track of whether the
// list is immutable. If it's immutable, the invariant is that it must
// either an instance of Collections.emptyList() or it's an ArrayList
@@ -799,234 +801,237 @@
// memory allocations. Note, immutable is a strong guarantee here -- not
// just that the list cannot be modified via the reference but that the
// list can never be modified.
- printer->Print(variables_,
- "private com.google.protobuf.LazyStringList $name$_ = $empty_list$;\n");
+ printer->Print(
+ variables_,
+ "private com.google.protobuf.LazyStringList $name$_ = $empty_list$;\n");
- printer->Print(variables_,
- "private void ensure$capitalized_name$IsMutable() {\n"
- " if (!$get_mutable_bit_builder$) {\n"
- " $name$_ = new com.google.protobuf.LazyStringArrayList($name$_);\n"
- " $set_mutable_bit_builder$;\n"
- " }\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "private void ensure$capitalized_name$IsMutable() {\n"
+ " if (!$get_mutable_bit_builder$) {\n"
+ " $name$_ = new com.google.protobuf.LazyStringArrayList($name$_);\n"
+ " $set_mutable_bit_builder$;\n"
+ " }\n"
+ "}\n");
- // Note: We return an unmodifiable list because otherwise the caller
- // could hold on to the returned list and modify it after the message
- // has been built, thus mutating the message which is supposed to be
- // immutable.
+ // Note: We return an unmodifiable list because otherwise the caller
+ // could hold on to the returned list and modify it after the message
+ // has been built, thus mutating the message which is supposed to be
+ // immutable.
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public com.google.protobuf.ProtocolStringList\n"
- " ${$get$capitalized_name$List$}$() {\n"
- " return $name$_.getUnmodifiableView();\n"
- "}\n");
+ "$deprecation$public com.google.protobuf.ProtocolStringList\n"
+ " ${$get$capitalized_name$List$}$() {\n"
+ " return $name$_.getUnmodifiableView();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return $name$_.size();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return $name$_.size();\n"
- "}\n");
+ "$deprecation$public java.lang.String "
+ "${$get$capitalized_name$$}$(int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public java.lang.String "
- "${$get$capitalized_name$$}$(int index) {\n"
- " return $name$_.get(index);\n"
- "}\n");
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$(int index) {\n"
+ " return $name$_.getByteString(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$(int index) {\n"
- " return $name$_.getByteString(index);\n"
- "}\n");
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " int index, java.lang.String value) {\n"
+ "$null_check$"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.set(index, value);\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " int index, java.lang.String value) {\n"
- "$null_check$"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.set(index, value);\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
+ " java.lang.String value) {\n"
+ "$null_check$"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.add(value);\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
- " java.lang.String value) {\n"
- "$null_check$"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.add(value);\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
+ " java.lang.Iterable<java.lang.String> values) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " com.google.protobuf.AbstractMessageLite.Builder.addAll(\n"
+ " values, $name$_);\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
- " java.lang.Iterable<java.lang.String> values) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " com.google.protobuf.AbstractMessageLite.Builder.addAll(\n"
- " values, $name$_);\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " $name$_ = $empty_list$;\n"
- " $clear_mutable_bit_builder$;\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " $name$_ = $empty_list$;\n"
+ " $clear_mutable_bit_builder$;\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$Bytes$}$(\n"
- " com.google.protobuf.ByteString value) {\n"
- "$null_check$");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$add$capitalized_name$Bytes$}$(\n"
+ " com.google.protobuf.ByteString value) {\n"
+ "$null_check$");
printer->Annotate("{", "}", descriptor_);
if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- " checkByteStringIsUtf8(value);\n");
+ printer->Print(variables_, " checkByteStringIsUtf8(value);\n");
}
printer->Print(variables_,
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.add(value);\n"
- " $on_changed$\n"
- " return this;\n"
- "}\n");
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.add(value);\n"
+ " $on_changed$\n"
+ " return this;\n"
+ "}\n");
}
void RepeatedImmutableStringFieldGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+ GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
// noop for primitives
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void RepeatedImmutableStringFieldGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
printer->Print(variables_, "$name$_ = $empty_list$;\n");
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateBuilderClearCode(io::Printer* printer) const {
+void RepeatedImmutableStringFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "$name$_ = $empty_list$;\n"
- "$clear_mutable_bit_builder$;\n");
+ "$name$_ = $empty_list$;\n"
+ "$clear_mutable_bit_builder$;\n");
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateMergingCode(io::Printer* printer) const {
+void RepeatedImmutableStringFieldGenerator::GenerateMergingCode(
+ io::Printer* printer) const {
// The code below does two optimizations:
// 1. If the other list is empty, there's nothing to do. This ensures we
// don't allocate a new array if we already have an immutable one.
// 2. If the other list is non-empty and our current list is empty, we can
// reuse the other list which is guaranteed to be immutable.
printer->Print(variables_,
- "if (!other.$name$_.isEmpty()) {\n"
- " if ($name$_.isEmpty()) {\n"
- " $name$_ = other.$name$_;\n"
- " $clear_mutable_bit_builder$;\n"
- " } else {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.addAll(other.$name$_);\n"
- " }\n"
- " $on_changed$\n"
- "}\n");
+ "if (!other.$name$_.isEmpty()) {\n"
+ " if ($name$_.isEmpty()) {\n"
+ " $name$_ = other.$name$_;\n"
+ " $clear_mutable_bit_builder$;\n"
+ " } else {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.addAll(other.$name$_);\n"
+ " }\n"
+ " $on_changed$\n"
+ "}\n");
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateBuildingCode(io::Printer* printer) const {
+void RepeatedImmutableStringFieldGenerator::GenerateBuildingCode(
+ io::Printer* printer) const {
// The code below ensures that the result has an immutable list. If our
// list is immutable, we can just reuse it. If not, we make it immutable.
printer->Print(variables_,
- "if ($get_mutable_bit_builder$) {\n"
- " $name$_ = $name$_.getUnmodifiableView();\n"
- " $clear_mutable_bit_builder$;\n"
- "}\n"
- "result.$name$_ = $name$_;\n");
+ "if ($get_mutable_bit_builder$) {\n"
+ " $name$_ = $name$_.getUnmodifiableView();\n"
+ " $clear_mutable_bit_builder$;\n"
+ "}\n"
+ "result.$name$_ = $name$_;\n");
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateParsingCode(io::Printer* printer) const {
+void RepeatedImmutableStringFieldGenerator::GenerateParsingCode(
+ io::Printer* printer) const {
if (CheckUtf8(descriptor_)) {
printer->Print(variables_,
- "java.lang.String s = input.readStringRequireUtf8();\n");
+ "java.lang.String s = input.readStringRequireUtf8();\n");
} else {
printer->Print(variables_,
- "com.google.protobuf.ByteString bs = input.readBytes();\n");
+ "com.google.protobuf.ByteString bs = input.readBytes();\n");
}
printer->Print(variables_,
- "if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = new com.google.protobuf.LazyStringArrayList();\n"
- " $set_mutable_bit_parser$;\n"
- "}\n");
+ "if (!$get_mutable_bit_parser$) {\n"
+ " $name$_ = new com.google.protobuf.LazyStringArrayList();\n"
+ " $set_mutable_bit_parser$;\n"
+ "}\n");
if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- "$name$_.add(s);\n");
+ printer->Print(variables_, "$name$_.add(s);\n");
} else {
- printer->Print(variables_,
- "$name$_.add(bs);\n");
+ printer->Print(variables_, "$name$_.add(bs);\n");
}
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
+void RepeatedImmutableStringFieldGenerator::GenerateParsingDoneCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "if ($get_mutable_bit_parser$) {\n"
- " $name$_ = $name$_.getUnmodifiableView();\n"
- "}\n");
+ "if ($get_mutable_bit_parser$) {\n"
+ " $name$_ = $name$_.getUnmodifiableView();\n"
+ "}\n");
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
+void RepeatedImmutableStringFieldGenerator::GenerateSerializationCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " $writeString$(output, $number$, $name$_.getRaw(i));\n"
- "}\n");
+ "for (int i = 0; i < $name$_.size(); i++) {\n"
+ " $writeString$(output, $number$, $name$_.getRaw(i));\n"
+ "}\n");
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
+void RepeatedImmutableStringFieldGenerator::GenerateSerializedSizeCode(
+ io::Printer* printer) const {
printer->Print(variables_,
- "{\n"
- " int dataSize = 0;\n");
+ "{\n"
+ " int dataSize = 0;\n");
printer->Indent();
printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " dataSize += computeStringSizeNoTag($name$_.getRaw(i));\n"
- "}\n");
+ "for (int i = 0; i < $name$_.size(); i++) {\n"
+ " dataSize += computeStringSizeNoTag($name$_.getRaw(i));\n"
+ "}\n");
- printer->Print(
- "size += dataSize;\n");
+ printer->Print("size += dataSize;\n");
printer->Print(variables_,
- "size += $tag_size$ * get$capitalized_name$List().size();\n");
+ "size += $tag_size$ * get$capitalized_name$List().size();\n");
printer->Outdent();
printer->Print("}\n");
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (!get$capitalized_name$List()\n"
- " .equals(other.get$capitalized_name$List())) return false;\n");
+void RepeatedImmutableStringFieldGenerator::GenerateEqualsCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if (!get$capitalized_name$List()\n"
+ " .equals(other.get$capitalized_name$List())) return false;\n");
}
-void RepeatedImmutableStringFieldGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (get$capitalized_name$Count() > 0) {\n"
- " hash = (37 * hash) + $constant_name$;\n"
- " hash = (53 * hash) + get$capitalized_name$List().hashCode();\n"
- "}\n");
+void RepeatedImmutableStringFieldGenerator::GenerateHashCode(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "if (get$capitalized_name$Count() > 0) {\n"
+ " hash = (37 * hash) + $constant_name$;\n"
+ " hash = (53 * hash) + get$capitalized_name$List().hashCode();\n"
+ "}\n");
}
std::string RepeatedImmutableStringFieldGenerator::GetBoxedType() const {
diff --git a/src/google/protobuf/compiler/java/java_string_field_lite.cc b/src/google/protobuf/compiler/java/java_string_field_lite.cc
index c158872..5c94cb3 100644
--- a/src/google/protobuf/compiler/java/java_string_field_lite.cc
+++ b/src/google/protobuf/compiler/java/java_string_field_lite.cc
@@ -83,8 +83,8 @@
// TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
// by the proto compiler
- (*variables)["deprecation"] = descriptor->options().deprecated()
- ? "@java.lang.Deprecated " : "";
+ (*variables)["deprecation"] =
+ descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
(*variables)["required"] = descriptor->is_required() ? "true" : "false";
if (SupportFieldPresence(descriptor->file())) {
@@ -161,234 +161,164 @@
// TODO(dweis): Consider dropping all of the *Bytes() methods. They really
// shouldn't be necessary or used on devices.
-void ImmutableStringFieldLiteGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void ImmutableStringFieldLiteGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$boolean has$capitalized_name$();\n");
+ "$deprecation$boolean has$capitalized_name$();\n");
}
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.lang.String get$capitalized_name$();\n");
+ "$deprecation$java.lang.String get$capitalized_name$();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$com.google.protobuf.ByteString\n"
- " get$capitalized_name$Bytes();\n");
+ "$deprecation$com.google.protobuf.ByteString\n"
+ " get$capitalized_name$Bytes();\n");
}
-void ImmutableStringFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private java.lang.String $name$_;\n");
+void ImmutableStringFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(variables_, "private java.lang.String $name$_;\n");
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $get_has_field_bit_message$;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $get_has_field_bit_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
- " return $name$_;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
+ " return $name$_;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$() {\n"
- " return com.google.protobuf.ByteString.copyFromUtf8($name$_);\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$() {\n"
+ " return com.google.protobuf.ByteString.copyFromUtf8($name$_);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$(\n"
- " java.lang.String value) {\n"
- "$null_check$"
- " $set_has_field_bit_message$\n"
- " $name$_ = value;\n"
- "}\n");
+ "private void set$capitalized_name$(\n"
+ " java.lang.String value) {\n"
+ "$null_check$"
+ " $set_has_field_bit_message$\n"
+ " $name$_ = value;\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void clear$capitalized_name$() {\n"
- " $clear_has_field_bit_message$\n"
- // The default value is not a simple literal so we want to avoid executing
- // it multiple times. Instead, get the default out of the default instance.
- " $name$_ = getDefaultInstance().get$capitalized_name$();\n"
- "}\n");
+ "private void clear$capitalized_name$() {\n"
+ " $clear_has_field_bit_message$\n"
+ // The default value is not a simple literal so we want to
+ // avoid executing it multiple times. Instead, get the default
+ // out of the default instance.
+ " $name$_ = getDefaultInstance().get$capitalized_name$();\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$Bytes(\n"
- " com.google.protobuf.ByteString value) {\n"
- "$null_check$");
+ "private void set$capitalized_name$Bytes(\n"
+ " com.google.protobuf.ByteString value) {\n"
+ "$null_check$");
if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- " checkByteStringIsUtf8(value);\n");
+ printer->Print(variables_, " checkByteStringIsUtf8(value);\n");
}
printer->Print(variables_,
- " $set_has_field_bit_message$\n"
- " $name$_ = value.toStringUtf8();\n"
- "}\n");
+ " $set_has_field_bit_message$\n"
+ " $name$_ = value.toStringUtf8();\n"
+ "}\n");
}
-void ImmutableStringFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void ImmutableStringFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return instance.has$capitalized_name$();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return instance.has$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
- " return instance.get$capitalized_name$();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
+ " return instance.get$capitalized_name$();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$() {\n"
- " return instance.get$capitalized_name$Bytes();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$() {\n"
+ " return instance.get$capitalized_name$Bytes();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " java.lang.String value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " java.lang.String value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " copyOnWrite();\n"
+ " instance.clear$capitalized_name$();\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$Bytes$}$(\n"
- " com.google.protobuf.ByteString value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$Bytes(value);\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$set$capitalized_name$Bytes$}$(\n"
+ " com.google.protobuf.ByteString value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$Bytes(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
-void ImmutableStringFieldLiteGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
- // noop for strings
-}
-
-
-void ImmutableStringFieldLiteGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
- printer->Print(variables_, "$name$_ = $default$;\n");
-}
-
-void ImmutableStringFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
+void ImmutableStringFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
if (SupportFieldPresence(descriptor_->file())) {
- printer->Print(variables_,
- "$name$_ = visitor.visitString(\n"
- " has$capitalized_name$(), $name$_,\n"
- " other.has$capitalized_name$(), other.$name$_);\n");
- } else {
- printer->Print(variables_,
- "$name$_ = visitor.visitString(!$name$_.isEmpty(), $name$_,\n"
- " !other.$name$_.isEmpty(), other.$name$_);\n");
+ WriteIntToUtf16CharSequence(messageBitIndex_, output);
}
+ printer->Print(variables_, "\"$name$_\",\n");
}
-void ImmutableStringFieldLiteGenerator::
-GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const {
- // noop for scalars
-}
-
-void ImmutableStringFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- "java.lang.String s = input.readStringRequireUtf8();\n"
- "$set_has_field_bit_message$\n"
- "$name$_ = s;\n");
- } else {
- // Lite runtime should attempt to reduce allocations by attempting to
- // construct the string directly from the input stream buffer. This avoids
- // spurious intermediary ByteString allocations, cutting overall allocations
- // in half.
- printer->Print(variables_,
- "java.lang.String s = input.readString();\n"
- "$set_has_field_bit_message$\n"
- "$name$_ = s;\n");
- }
-}
-
-void ImmutableStringFieldLiteGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- // noop for strings
-}
-
-void ImmutableStringFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- // Lite runtime should reduce allocations by serializing the string directly.
- // This avoids spurious intermediary ByteString allocations, cutting overall
- // allocations in half.
- printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " output.writeString($number$, get$capitalized_name$());\n"
- "}\n");
-}
-
-void ImmutableStringFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- // Lite runtime should reduce allocations by computing on the string directly.
- // This avoids spurious intermediary ByteString allocations, cutting overall
- // allocations in half.
- printer->Print(variables_,
- "if ($is_field_present_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .computeStringSize($number$, get$capitalized_name$());\n"
- "}\n");
-}
-
-void ImmutableStringFieldLiteGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(variables_,
- "result = result && get$capitalized_name$()\n"
- " .equals(other.get$capitalized_name$());\n");
-}
-
-void ImmutableStringFieldLiteGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "hash = (37 * hash) + $constant_name$;\n");
- printer->Print(variables_,
- "hash = (53 * hash) + get$capitalized_name$().hashCode();\n");
+void ImmutableStringFieldLiteGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
+ printer->Print(variables_, "$name$_ = $default$;\n");
}
std::string ImmutableStringFieldLiteGenerator::GetBoxedType() const {
@@ -406,188 +336,151 @@
}
ImmutableStringOneofFieldLiteGenerator::
-~ImmutableStringOneofFieldLiteGenerator() {}
+ ~ImmutableStringOneofFieldLiteGenerator() {}
-void ImmutableStringOneofFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
+void ImmutableStringOneofFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
PrintExtraFieldInfo(variables_, printer);
if (SupportFieldPresence(descriptor_->file())) {
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return $has_oneof_case_message$;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- }
-
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
- " java.lang.String ref $default_init$;\n"
- " if ($has_oneof_case_message$) {\n"
- " ref = (java.lang.String) $oneof_name$_;\n"
- " }\n"
- " return ref;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
-
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$() {\n"
- " java.lang.String ref $default_init$;\n"
- " if ($has_oneof_case_message$) {\n"
- " ref = (java.lang.String) $oneof_name$_;\n"
- " }\n"
- " return com.google.protobuf.ByteString.copyFromUtf8(ref);\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
-
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void ${$set$capitalized_name$$}$(\n"
- " java.lang.String value) {\n"
- "$null_check$"
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = value;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void ${$clear$capitalized_name$$}$() {\n"
- " if ($has_oneof_case_message$) {\n"
- " $clear_oneof_case_message$;\n"
- " $oneof_name$_ = null;\n"
- " }\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
-
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "private void ${$set$capitalized_name$Bytes$}$(\n"
- " com.google.protobuf.ByteString value) {\n"
- "$null_check$");
- printer->Annotate("{", "}", descriptor_);
- if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- " checkByteStringIsUtf8(value);\n");
- }
- printer->Print(variables_,
- " $set_oneof_case_message$;\n"
- " $oneof_name$_ = value.toStringUtf8();\n"
- "}\n");
-}
-
-
-void ImmutableStringOneofFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
- if (SupportFieldPresence(descriptor_->file())) {
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
- " return instance.has$capitalized_name$();\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return $has_oneof_case_message$;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
+ " java.lang.String ref $default_init$;\n"
+ " if ($has_oneof_case_message$) {\n"
+ " ref = (java.lang.String) $oneof_name$_;\n"
+ " }\n"
+ " return ref;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
- " return instance.get$capitalized_name$();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$() {\n"
+ " java.lang.String ref $default_init$;\n"
+ " if ($has_oneof_case_message$) {\n"
+ " ref = (java.lang.String) $oneof_name$_;\n"
+ " }\n"
+ " return com.google.protobuf.ByteString.copyFromUtf8(ref);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$() {\n"
- " return instance.get$capitalized_name$Bytes();\n"
- "}\n");
+ "private void ${$set$capitalized_name$$}$(\n"
+ " java.lang.String value) {\n"
+ "$null_check$"
+ " $set_oneof_case_message$;\n"
+ " $oneof_name$_ = value;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "private void ${$clear$capitalized_name$$}$() {\n"
+ " if ($has_oneof_case_message$) {\n"
+ " $clear_oneof_case_message$;\n"
+ " $oneof_name$_ = null;\n"
+ " }\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " java.lang.String value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
+ "private void ${$set$capitalized_name$Bytes$}$(\n"
+ " com.google.protobuf.ByteString value) {\n"
+ "$null_check$");
printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
-
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$Bytes$}$(\n"
- " com.google.protobuf.ByteString value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$Bytes(value);\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
-}
-
-void ImmutableStringOneofFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$oneof_name$_ = visitor.visitOneofString(\n"
- " $has_oneof_case_message$, $oneof_name$_, other.$oneof_name$_);\n");
-}
-
-void ImmutableStringOneofFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- "java.lang.String s = input.readStringRequireUtf8();\n"
- "$set_oneof_case_message$;\n"
- "$oneof_name$_ = s;\n");
- } else {
- // Lite runtime should attempt to reduce allocations by attempting to
- // construct the string directly from the input stream buffer. This avoids
- // spurious intermediary ByteString allocations, cutting overall allocations
- // in half.
- printer->Print(variables_,
- "java.lang.String s = input.readString();\n"
- "$set_oneof_case_message$;\n"
- "$oneof_name$_ = s;\n");
+ printer->Print(variables_, " checkByteStringIsUtf8(value);\n");
}
+ printer->Print(variables_,
+ " $set_oneof_case_message$;\n"
+ " $oneof_name$_ = value.toStringUtf8();\n"
+ "}\n");
}
-void ImmutableStringOneofFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- // Lite runtime should reduce allocations by serializing the string directly.
- // This avoids spurious intermediary ByteString allocations, cutting overall
- // allocations in half.
- printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " output.writeString($number$, get$capitalized_name$());\n"
- "}\n");
+void ImmutableStringOneofFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
+ WriteIntToUtf16CharSequence(descriptor_->containing_oneof()->index(), output);
}
-void ImmutableStringOneofFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- // Lite runtime should reduce allocations by computing on the string directly.
- // This avoids spurious intermediary ByteString allocations, cutting overall
- // allocations in half.
+void ImmutableStringOneofFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
+ if (SupportFieldPresence(descriptor_->file())) {
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public boolean ${$has$capitalized_name$$}$() {\n"
+ " return instance.has$capitalized_name$();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ }
+
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public java.lang.String ${$get$capitalized_name$$}$() {\n"
+ " return instance.get$capitalized_name$();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+
+ WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "if ($has_oneof_case_message$) {\n"
- " size += com.google.protobuf.CodedOutputStream\n"
- " .computeStringSize($number$, get$capitalized_name$());\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$() {\n"
+ " return instance.get$capitalized_name$Bytes();\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(variables_,
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " java.lang.String value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " copyOnWrite();\n"
+ " instance.clear$capitalized_name$();\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$set$capitalized_name$Bytes$}$(\n"
+ " com.google.protobuf.ByteString value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$Bytes(value);\n"
+ " return this;\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
}
// ===================================================================
@@ -606,311 +499,227 @@
}
RepeatedImmutableStringFieldLiteGenerator::
-~RepeatedImmutableStringFieldLiteGenerator() {}
+ ~RepeatedImmutableStringFieldLiteGenerator() {}
int RepeatedImmutableStringFieldLiteGenerator::GetNumBitsForMessage() const {
return 0;
}
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateInterfaceMembers(io::Printer* printer) const {
+void RepeatedImmutableStringFieldLiteGenerator::GenerateInterfaceMembers(
+ io::Printer* printer) const {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.util.List<java.lang.String>\n"
- " get$capitalized_name$List();\n");
+ "$deprecation$java.util.List<java.lang.String>\n"
+ " get$capitalized_name$List();\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$int get$capitalized_name$Count();\n");
+ "$deprecation$int get$capitalized_name$Count();\n");
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "$deprecation$java.lang.String get$capitalized_name$(int index);\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$java.lang.String get$capitalized_name$(int index);\n");
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$com.google.protobuf.ByteString\n"
- " get$capitalized_name$Bytes(int index);\n");
+ "$deprecation$com.google.protobuf.ByteString\n"
+ " get$capitalized_name$Bytes(int index);\n");
}
-
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateMembers(io::Printer* printer) const {
- printer->Print(variables_,
- "private com.google.protobuf.Internal.ProtobufList<java.lang.String> "
- "$name$_;\n");
+void RepeatedImmutableStringFieldLiteGenerator::GenerateMembers(
+ io::Printer* printer) const {
+ printer->Print(
+ variables_,
+ "private com.google.protobuf.Internal.ProtobufList<java.lang.String> "
+ "$name$_;\n");
PrintExtraFieldInfo(variables_, printer);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.util.List<java.lang.String> "
- "${$get$capitalized_name$List$}$() {\n"
- " return $name$_;\n" // note: unmodifiable list
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public java.util.List<java.lang.String> "
+ "${$get$capitalized_name$List$}$() {\n"
+ " return $name$_;\n" // note: unmodifiable list
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return $name$_.size();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return $name$_.size();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public java.lang.String "
+ "${$get$capitalized_name$$}$(int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.lang.String "
- "${$get$capitalized_name$$}$(int index) {\n"
- " return $name$_.get(index);\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$(int index) {\n"
- " return com.google.protobuf.ByteString.copyFromUtf8(\n"
- " $name$_.get(index));\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$(int index) {\n"
+ " return com.google.protobuf.ByteString.copyFromUtf8(\n"
+ " $name$_.get(index));\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
- printer->Print(variables_,
- "private void ensure$capitalized_name$IsMutable() {\n"
- " if (!$is_mutable$) {\n"
- " $name$_ =\n"
- " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
- " }\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "private void ensure$capitalized_name$IsMutable() {\n"
+ " if (!$is_mutable$) {\n"
+ " $name$_ =\n"
+ " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
+ " }\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void set$capitalized_name$(\n"
- " int index, java.lang.String value) {\n"
- "$null_check$"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.set(index, value);\n"
- "}\n");
+ "private void set$capitalized_name$(\n"
+ " int index, java.lang.String value) {\n"
+ "$null_check$"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.set(index, value);\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void add$capitalized_name$(\n"
- " java.lang.String value) {\n"
- "$null_check$"
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.add(value);\n"
- "}\n");
+ "private void add$capitalized_name$(\n"
+ " java.lang.String value) {\n"
+ "$null_check$"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.add(value);\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void addAll$capitalized_name$(\n"
- " java.lang.Iterable<java.lang.String> values) {\n"
- " ensure$capitalized_name$IsMutable();\n"
- " com.google.protobuf.AbstractMessageLite.addAll(\n"
- " values, $name$_);\n"
- "}\n");
+ "private void addAll$capitalized_name$(\n"
+ " java.lang.Iterable<java.lang.String> values) {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " com.google.protobuf.AbstractMessageLite.addAll(\n"
+ " values, $name$_);\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void clear$capitalized_name$() {\n"
- " $name$_ = $empty_list$;\n"
- "}\n");
+ "private void clear$capitalized_name$() {\n"
+ " $name$_ = $empty_list$;\n"
+ "}\n");
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "private void add$capitalized_name$Bytes(\n"
- " com.google.protobuf.ByteString value) {\n"
- "$null_check$");
+ "private void add$capitalized_name$Bytes(\n"
+ " com.google.protobuf.ByteString value) {\n"
+ "$null_check$");
if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- " checkByteStringIsUtf8(value);\n");
+ printer->Print(variables_, " checkByteStringIsUtf8(value);\n");
}
printer->Print(variables_,
- " ensure$capitalized_name$IsMutable();\n"
- " $name$_.add(value.toStringUtf8());\n"
- "}\n");
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.add(value.toStringUtf8());\n"
+ "}\n");
}
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateBuilderMembers(io::Printer* printer) const {
+void RepeatedImmutableStringFieldLiteGenerator::GenerateBuilderMembers(
+ io::Printer* printer) const {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.util.List<java.lang.String>\n"
- " ${$get$capitalized_name$List$}$() {\n"
- " return java.util.Collections.unmodifiableList(\n"
- " instance.get$capitalized_name$List());\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public java.util.List<java.lang.String>\n"
+ " ${$get$capitalized_name$List$}$() {\n"
+ " return java.util.Collections.unmodifiableList(\n"
+ " instance.get$capitalized_name$List());\n"
+ "}\n");
+ printer->Annotate("{", "}", descriptor_);
+ WriteFieldDocComment(printer, descriptor_);
+ printer->Print(
+ variables_,
+ "@java.lang.Override\n"
+ "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
+ " return instance.get$capitalized_name$Count();\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public int ${$get$capitalized_name$Count$}$() {\n"
- " return instance.get$capitalized_name$Count();\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public java.lang.String "
+ "${$get$capitalized_name$$}$(int index) {\n"
+ " return instance.get$capitalized_name$(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public java.lang.String "
- "${$get$capitalized_name$$}$(int index) {\n"
- " return instance.get$capitalized_name$(index);\n"
- "}\n");
+ "@java.lang.Override\n"
+ "$deprecation$public com.google.protobuf.ByteString\n"
+ " ${$get$capitalized_name$Bytes$}$(int index) {\n"
+ " return instance.get$capitalized_name$Bytes(index);\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "@java.lang.Override\n"
- "$deprecation$public com.google.protobuf.ByteString\n"
- " ${$get$capitalized_name$Bytes$}$(int index) {\n"
- " return instance.get$capitalized_name$Bytes(index);\n"
- "}\n");
+ "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
+ " int index, java.lang.String value) {\n"
+ " copyOnWrite();\n"
+ " instance.set$capitalized_name$(index, value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$set$capitalized_name$$}$(\n"
- " int index, java.lang.String value) {\n"
- " copyOnWrite();\n"
- " instance.set$capitalized_name$(index, value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
+ " java.lang.String value) {\n"
+ " copyOnWrite();\n"
+ " instance.add$capitalized_name$(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$$}$(\n"
- " java.lang.String value) {\n"
- " copyOnWrite();\n"
- " instance.add$capitalized_name$(value);\n"
- " return this;\n"
- "}\n");
+ "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
+ " java.lang.Iterable<java.lang.String> values) {\n"
+ " copyOnWrite();\n"
+ " instance.addAll$capitalized_name$(values);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$addAll$capitalized_name$$}$(\n"
- " java.lang.Iterable<java.lang.String> values) {\n"
- " copyOnWrite();\n"
- " instance.addAll$capitalized_name$(values);\n"
- " return this;\n"
- "}\n");
- printer->Annotate("{", "}", descriptor_);
- WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
- " copyOnWrite();\n"
- " instance.clear$capitalized_name$();\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$clear$capitalized_name$$}$() {\n"
+ " copyOnWrite();\n"
+ " instance.clear$capitalized_name$();\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldDocComment(printer, descriptor_);
- printer->Print(variables_,
- "$deprecation$public Builder ${$add$capitalized_name$Bytes$}$(\n"
- " com.google.protobuf.ByteString value) {\n"
- " copyOnWrite();\n"
- " instance.add$capitalized_name$Bytes(value);\n"
- " return this;\n"
- "}\n");
+ printer->Print(
+ variables_,
+ "$deprecation$public Builder ${$add$capitalized_name$Bytes$}$(\n"
+ " com.google.protobuf.ByteString value) {\n"
+ " copyOnWrite();\n"
+ " instance.add$capitalized_name$Bytes(value);\n"
+ " return this;\n"
+ "}\n");
printer->Annotate("{", "}", descriptor_);
}
void RepeatedImmutableStringFieldLiteGenerator::
-GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
+ GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
// noop for strings
}
+void RepeatedImmutableStringFieldLiteGenerator::GenerateFieldInfo(
+ io::Printer* printer, std::vector<uint16>* output) const {
+ WriteIntToUtf16CharSequence(descriptor_->number(), output);
+ WriteIntToUtf16CharSequence(GetExperimentalJavaFieldType(descriptor_),
+ output);
+ printer->Print(variables_, "\"$name$_\",\n");
+}
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateInitializationCode(io::Printer* printer) const {
+void RepeatedImmutableStringFieldLiteGenerator::GenerateInitializationCode(
+ io::Printer* printer) const {
printer->Print(variables_, "$name$_ = $empty_list$;\n");
}
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateVisitCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$name$_= visitor.visitList($name$_, other.$name$_);\n");
-}
-
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const {
- printer->Print(variables_,
- "$name$_.makeImmutable();\n");
-}
-
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateParsingCode(io::Printer* printer) const {
- if (CheckUtf8(descriptor_)) {
- printer->Print(variables_,
- "java.lang.String s = input.readStringRequireUtf8();\n");
- } else {
- // Lite runtime should attempt to reduce allocations by attempting to
- // construct the string directly from the input stream buffer. This avoids
- // spurious intermediary ByteString allocations, cutting overall allocations
- // in half.
- printer->Print(variables_,
- "java.lang.String s = input.readString();\n");
- }
- printer->Print(variables_,
- "if (!$is_mutable$) {\n"
- " $name$_ =\n"
- " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n"
- "}\n");
- printer->Print(variables_,
- "$name$_.add(s);\n");
-}
-
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateParsingDoneCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if ($is_mutable$) {\n"
- " $name$_.makeImmutable();\n"
- "}\n");
-}
-
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateSerializationCode(io::Printer* printer) const {
- // Lite runtime should reduce allocations by serializing the string directly.
- // This avoids spurious intermediary ByteString allocations, cutting overall
- // allocations in half.
- printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " output.writeString($number$, $name$_.get(i));\n"
- "}\n");
-}
-
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateSerializedSizeCode(io::Printer* printer) const {
- // Lite runtime should reduce allocations by computing on the string directly.
- // This avoids spurious intermediary ByteString allocations, cutting overall
- // allocations in half.
- printer->Print(variables_,
- "{\n"
- " int dataSize = 0;\n");
- printer->Indent();
-
- printer->Print(variables_,
- "for (int i = 0; i < $name$_.size(); i++) {\n"
- " dataSize += com.google.protobuf.CodedOutputStream\n"
- " .computeStringSizeNoTag($name$_.get(i));\n"
- "}\n");
-
- printer->Print(
- "size += dataSize;\n");
-
-
- printer->Print(variables_,
- "size += $tag_size$ * get$capitalized_name$List().size();\n");
-
- printer->Outdent();
- printer->Print("}\n");
-}
-
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateEqualsCode(io::Printer* printer) const {
- printer->Print(variables_,
- "result = result && get$capitalized_name$List()\n"
- " .equals(other.get$capitalized_name$List());\n");
-}
-
-void RepeatedImmutableStringFieldLiteGenerator::
-GenerateHashCode(io::Printer* printer) const {
- printer->Print(variables_,
- "if (get$capitalized_name$Count() > 0) {\n"
- " hash = (37 * hash) + $constant_name$;\n"
- " hash = (53 * hash) + get$capitalized_name$List().hashCode();\n"
- "}\n");
-}
-
std::string RepeatedImmutableStringFieldLiteGenerator::GetBoxedType() const {
return "java.lang.String";
}
diff --git a/src/google/protobuf/compiler/java/java_string_field_lite.h b/src/google/protobuf/compiler/java/java_string_field_lite.h
index 89d5c1a..960f468 100644
--- a/src/google/protobuf/compiler/java/java_string_field_lite.h
+++ b/src/google/protobuf/compiler/java/java_string_field_lite.h
@@ -70,16 +70,8 @@
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateDynamicMethodMakeImmutableCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
std::string GetBoxedType() const;
@@ -104,11 +96,8 @@
private:
void GenerateMembers(io::Printer* printer) const;
void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateVisitCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
-
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImmutableStringOneofFieldLiteGenerator);
};
@@ -135,7 +124,8 @@
void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
void GenerateEqualsCode(io::Printer* printer) const;
void GenerateHashCode(io::Printer* printer) const;
-
+ void GenerateFieldInfo(io::Printer* printer,
+ std::vector<uint16>* output) const;
std::string GetBoxedType() const;
diff --git a/src/google/protobuf/compiler/js/js_generator.cc b/src/google/protobuf/compiler/js/js_generator.cc
index e00637e..7b12dde 100644
--- a/src/google/protobuf/compiler/js/js_generator.cc
+++ b/src/google/protobuf/compiler/js/js_generator.cc
@@ -60,64 +60,18 @@
// Sorted list of JavaScript keywords. These cannot be used as names. If they
// appear, we prefix them with "pb_".
const char* kKeyword[] = {
- "abstract",
- "boolean",
- "break",
- "byte",
- "case",
- "catch",
- "char",
- "class",
- "const",
- "continue",
- "debugger",
- "default",
- "delete",
- "do",
- "double",
- "else",
- "enum",
- "export",
- "extends",
- "false",
- "final",
- "finally",
- "float",
- "for",
- "function",
- "goto",
- "if",
- "implements",
- "import",
- "in",
- "instanceof",
- "int",
- "interface",
- "long",
- "native",
- "new",
- "null",
- "package",
- "private",
- "protected",
- "public",
- "return",
- "short",
- "static",
- "super",
- "switch",
- "synchronized",
- "this",
- "throw",
- "throws",
- "transient",
- "try",
- "typeof",
- "var",
- "void",
- "volatile",
- "while",
- "with",
+ "abstract", "boolean", "break", "byte", "case",
+ "catch", "char", "class", "const", "continue",
+ "debugger", "default", "delete", "do", "double",
+ "else", "enum", "export", "extends", "false",
+ "final", "finally", "float", "for", "function",
+ "goto", "if", "implements", "import", "in",
+ "instanceof", "int", "interface", "long", "native",
+ "new", "null", "package", "private", "protected",
+ "public", "return", "short", "static", "super",
+ "switch", "synchronized", "this", "throw", "throws",
+ "transient", "try", "typeof", "var", "void",
+ "volatile", "while", "with",
};
static const int kNumKeyword = sizeof(kKeyword) / sizeof(char*);
@@ -429,8 +383,8 @@
bool with_filename) {
std::string snake_name = StripProto(GetSnakeFilename(file->name()));
return options.output_dir + "/" + ToLower(GetNamespace(options, file)) +
- (with_filename ? ("_" + snake_name + "_extensions") : "") +
- options.GetFileNameExtension();
+ (with_filename ? ("_" + snake_name + "_extensions") : "") +
+ options.GetFileNameExtension();
}
// When we're generating one output file per SCC, this is the filename
// that all messages in the SCC should go in.
@@ -468,7 +422,7 @@
GetSnakeFilename(scc->GetRepresentative()->file()->name()));
(*long_name_dict)[scc->GetRepresentative()] =
StrCat(snake_name, "_long_sccs_",
- static_cast<uint64>((*long_name_dict).size()));
+ static_cast<uint64>((*long_name_dict).size()));
}
filename_base = (*long_name_dict)[scc->GetRepresentative()];
}
@@ -482,11 +436,9 @@
std::string GetEnumFileName(const GeneratorOptions& options,
const EnumDescriptor* desc, bool with_package) {
return options.output_dir + "/" +
- (with_package
- ? ToLower(GetNamespace(options, desc->file()) + "_")
- : "") +
- ToLower(desc->name()) +
- options.GetFileNameExtension();
+ (with_package ? ToLower(GetNamespace(options, desc->file()) + "_")
+ : "") +
+ ToLower(desc->name()) + options.GetFileNameExtension();
}
// Returns the message/response ID, if set.
@@ -513,9 +465,7 @@
// Do we ignore this message type?
-bool IgnoreMessage(const Descriptor* d) {
- return d->options().map_entry();
-}
+bool IgnoreMessage(const Descriptor* d) { return d->options().map_entry(); }
// Does JSPB ignore this entire oneof? True only if all fields are ignored.
bool IgnoreOneof(const OneofDescriptor* oneof) {
@@ -532,13 +482,12 @@
bool is_map, bool drop_list) {
std::string result;
if (field->type() == FieldDescriptor::TYPE_GROUP) {
- result = is_upper_camel ?
- ToUpperCamel(ParseUpperCamel(field->message_type()->name())) :
- ToLowerCamel(ParseUpperCamel(field->message_type()->name()));
+ result = is_upper_camel
+ ? ToUpperCamel(ParseUpperCamel(field->message_type()->name()))
+ : ToLowerCamel(ParseUpperCamel(field->message_type()->name()));
} else {
- result = is_upper_camel ?
- ToUpperCamel(ParseLowerUnderscore(field->name())) :
- ToLowerCamel(ParseLowerUnderscore(field->name()));
+ result = is_upper_camel ? ToUpperCamel(ParseLowerUnderscore(field->name()))
+ : ToLowerCamel(ParseLowerUnderscore(field->name()));
}
if (is_map || field->is_map()) {
// JSPB-style or proto3-style map.
@@ -670,13 +619,15 @@
*length = expected;
switch (expected) {
- case 1: return bytes[0];
- case 2: return ((bytes[0] & 0x1F) << 6) |
- ((bytes[1] & 0x3F) << 0);
- case 3: return ((bytes[0] & 0x0F) << 12) |
- ((bytes[1] & 0x3F) << 6) |
- ((bytes[2] & 0x3F) << 0);
- default: return 0;
+ case 1:
+ return bytes[0];
+ case 2:
+ return ((bytes[0] & 0x1F) << 6) | ((bytes[1] & 0x3F) << 0);
+ case 3:
+ return ((bytes[0] & 0x0F) << 12) | ((bytes[1] & 0x3F) << 6) |
+ ((bytes[2] & 0x3F) << 0);
+ default:
+ return 0;
}
}
@@ -703,18 +654,42 @@
decoded = have_bytes;
switch (codepoint) {
- case '\'': *out += "\\x27"; break;
- case '"': *out += "\\x22"; break;
- case '<': *out += "\\x3c"; break;
- case '=': *out += "\\x3d"; break;
- case '>': *out += "\\x3e"; break;
- case '&': *out += "\\x26"; break;
- case '\b': *out += "\\b"; break;
- case '\t': *out += "\\t"; break;
- case '\n': *out += "\\n"; break;
- case '\f': *out += "\\f"; break;
- case '\r': *out += "\\r"; break;
- case '\\': *out += "\\\\"; break;
+ case '\'':
+ *out += "\\x27";
+ break;
+ case '"':
+ *out += "\\x22";
+ break;
+ case '<':
+ *out += "\\x3c";
+ break;
+ case '=':
+ *out += "\\x3d";
+ break;
+ case '>':
+ *out += "\\x3e";
+ break;
+ case '&':
+ *out += "\\x26";
+ break;
+ case '\b':
+ *out += "\\b";
+ break;
+ case '\t':
+ *out += "\\t";
+ break;
+ case '\n':
+ *out += "\\n";
+ break;
+ case '\f':
+ *out += "\\f";
+ break;
+ case '\r':
+ *out += "\\r";
+ break;
+ case '\\':
+ *out += "\\\\";
+ break;
default:
// TODO(b/115551870): Once we're supporting codepoints outside the BMP,
// use a single Unicode codepoint escape if the output language is
@@ -739,18 +714,17 @@
std::string result;
for (size_t i = 0; i < in.size(); i += 3) {
- int value = (in[i] << 16) |
- (((i + 1) < in.size()) ? (in[i + 1] << 8) : 0) |
- (((i + 2) < in.size()) ? (in[i + 2] << 0) : 0);
+ int value = (in[i] << 16) | (((i + 1) < in.size()) ? (in[i + 1] << 8) : 0) |
+ (((i + 2) < in.size()) ? (in[i + 2] << 0) : 0);
result += kAlphabet[(value >> 18) & 0x3f];
result += kAlphabet[(value >> 12) & 0x3f];
if ((i + 1) < in.size()) {
- result += kAlphabet[(value >> 6) & 0x3f];
+ result += kAlphabet[(value >> 6) & 0x3f];
} else {
result += '=';
}
if ((i + 2) < in.size()) {
- result += kAlphabet[(value >> 0) & 0x3f];
+ result += kAlphabet[(value >> 0) & 0x3f];
} else {
result += '=';
}
@@ -1259,7 +1233,7 @@
std::string JSOneofArray(const GeneratorOptions& options,
const FieldDescriptor* field) {
return OneofFieldsArrayName(options, field->containing_type()) + "[" +
- JSOneofIndex(field->containing_oneof()) + "]";
+ JSOneofIndex(field->containing_oneof()) + "]";
}
std::string RelativeTypeName(const FieldDescriptor* field) {
@@ -1326,10 +1300,8 @@
} else {
value_type = ProtoTypeName(options, value_field);
}
- return StringPrintf("map<%s, %s> %s = %d;",
- key_type.c_str(),
- value_type.c_str(),
- field->name().c_str(),
+ return StringPrintf("map<%s, %s> %s = %d;", key_type.c_str(),
+ value_type.c_str(), field->name().c_str(),
field->number());
} else {
std::string qualifier =
@@ -1347,11 +1319,8 @@
type = ProtoTypeName(options, field);
name = field->name();
}
- return StringPrintf("%s %s %s = %d;",
- qualifier.c_str(),
- type.c_str(),
- name.c_str(),
- field->number());
+ return StringPrintf("%s %s %s = %d;", qualifier.c_str(), type.c_str(),
+ name.c_str(), field->number());
}
}
@@ -1366,9 +1335,7 @@
}
bool ShouldGenerateExtension(const FieldDescriptor* field) {
- return
- field->is_extension() &&
- !IgnoreField(field);
+ return field->is_extension() && !IgnoreField(field);
}
bool HasExtensions(const Descriptor* desc) {
@@ -1442,8 +1409,8 @@
int pivot = -1;
if (IsExtendable(desc) || (max_field_number >= kDefaultPivot)) {
- pivot = ((max_field_number + 1) < kDefaultPivot) ?
- (max_field_number + 1) : kDefaultPivot;
+ pivot = ((max_field_number + 1) < kDefaultPivot) ? (max_field_number + 1)
+ : kDefaultPivot;
}
return StrCat(pivot);
@@ -1618,23 +1585,20 @@
for (int i = 0; i < files_ordered.size(); i++) {
for (int j = 0; j < files_ordered[i]->message_type_count(); j++) {
const Descriptor* desc = files_ordered[i]->message_type(j);
- if (added.insert(analyzer->GetSCC(desc)).second && !dedup.AddFile(
- std::make_pair(
- GetMessagesFileName(options, analyzer->GetSCC(desc), false),
- GetMessagesFileName(options, analyzer->GetSCC(desc), true)),
- analyzer->GetSCC(desc),
- error)) {
+ if (added.insert(analyzer->GetSCC(desc)).second &&
+ !dedup.AddFile(
+ std::make_pair(
+ GetMessagesFileName(options, analyzer->GetSCC(desc), false),
+ GetMessagesFileName(options, analyzer->GetSCC(desc), true)),
+ analyzer->GetSCC(desc), error)) {
return false;
}
}
for (int j = 0; j < files_ordered[i]->enum_type_count(); j++) {
const EnumDescriptor* desc = files_ordered[i]->enum_type(j);
- if (!dedup.AddFile(
- std::make_pair(
- GetEnumFileName(options, desc, false),
- GetEnumFileName(options, desc, true)),
- desc,
- error)) {
+ if (!dedup.AddFile(std::make_pair(GetEnumFileName(options, desc, false),
+ GetEnumFileName(options, desc, true)),
+ desc, error)) {
return false;
}
}
@@ -1650,10 +1614,10 @@
if (has_extension) {
if (!dedup.AddFile(
- std::make_pair(
- GetExtensionFileName(options, files_ordered[i], false),
- GetExtensionFileName(options, files_ordered[i], true)),
- files_ordered[i], error)) {
+ std::make_pair(
+ GetExtensionFileName(options, files_ordered[i], false),
+ GetExtensionFileName(options, files_ordered[i], true)),
+ files_ordered[i], error)) {
return false;
}
}
@@ -1688,17 +1652,18 @@
void Generator::GenerateHeader(const GeneratorOptions& options,
io::Printer* printer) const {
- printer->Print("/**\n"
- " * @fileoverview\n"
- " * @enhanceable\n"
- " * @suppress {messageConventions} JS Compiler reports an "
- "error if a variable or\n"
- " * field starts with 'MSG_' and isn't a translatable "
- "message.\n"
- " * @public\n"
- " */\n"
- "// GENERATED CODE -- DO NOT EDIT!\n"
- "\n");
+ printer->Print(
+ "/**\n"
+ " * @fileoverview\n"
+ " * @enhanceable\n"
+ " * @suppress {messageConventions} JS Compiler reports an "
+ "error if a variable or\n"
+ " * field starts with 'MSG_' and isn't a translatable "
+ "message.\n"
+ " * @public\n"
+ " */\n"
+ "// GENERATED CODE -- DO NOT EDIT!\n"
+ "\n");
}
void Generator::FindProvidesForFile(const GeneratorOptions& options,
@@ -1736,12 +1701,10 @@
provided->insert(name);
for (int i = 0; i < desc->enum_type_count(); i++) {
- FindProvidesForEnum(options, printer, desc->enum_type(i),
- provided);
+ FindProvidesForEnum(options, printer, desc->enum_type(i), provided);
}
for (int i = 0; i < desc->nested_type_count(); i++) {
- FindProvidesForMessage(options, printer, desc->nested_type(i),
- provided);
+ FindProvidesForMessage(options, printer, desc->nested_type(i), provided);
}
}
@@ -1820,9 +1783,9 @@
}
GenerateRequiresImpl(options, printer, &required, &forwards, provided,
- /* require_jspb = */ have_message,
- /* require_extension = */ has_extension,
- /* require_map = */ has_map);
+ /* require_jspb = */ have_message,
+ /* require_extension = */ has_extension,
+ /* require_map = */ has_map);
}
void Generator::GenerateRequiresForLibrary(
@@ -1860,7 +1823,7 @@
continue;
}
if (extension->containing_type()->full_name() !=
- "google.protobuf.bridge.MessageSet") {
+ "google.protobuf.bridge.MessageSet") {
required.insert(GetMessagePath(options, extension->containing_type()));
}
FindRequiresForField(options, extension, &required, &forwards);
@@ -1919,8 +1882,7 @@
if (provided->find(*it) != provided->end()) {
continue;
}
- printer->Print("goog.require('$name$');\n",
- "name", *it);
+ printer->Print("goog.require('$name$');\n", "name", *it);
}
printer->Print("\n");
@@ -1929,8 +1891,7 @@
if (provided->find(*it) != provided->end()) {
continue;
}
- printer->Print("goog.forwardDeclare('$name$');\n",
- "name", *it);
+ printer->Print("goog.forwardDeclare('$name$');\n", "name", *it);
}
}
@@ -2010,8 +1971,8 @@
io::Printer* printer,
const FileDescriptor* file) const {
for (int i = 0; i < file->message_type_count(); i++) {
- GenerateClassConstructorAndDeclareExtensionFieldInfo(
- options, printer, file->message_type(i));
+ GenerateClassConstructorAndDeclareExtensionFieldInfo(options, printer,
+ file->message_type(i));
}
for (int i = 0; i < file->message_type_count(); i++) {
GenerateClass(options, printer, file->message_type(i));
@@ -2083,19 +2044,19 @@
" * @constructor\n"
" */\n"
"$classprefix$$classname$ = function(opt_data) {\n",
- "classprefix", GetMessagePathPrefix(options, desc),
- "classname", desc->name());
+ "classprefix", GetMessagePathPrefix(options, desc), "classname",
+ desc->name());
printer->Annotate("classname", desc);
std::string message_id = GetMessageId(desc);
printer->Print(
" jspb.Message.initialize(this, opt_data, $messageId$, $pivot$, "
"$rptfields$, $oneoffields$);\n",
- "messageId", !message_id.empty() ?
- ("'" + message_id + "'") :
- (IsResponse(desc) ? "''" : "0"),
- "pivot", GetPivot(desc),
- "rptfields", RepeatedFieldsArrayName(options, desc),
- "oneoffields", OneofFieldsArrayName(options, desc));
+ "messageId",
+ !message_id.empty() ? ("'" + message_id + "'")
+ : (IsResponse(desc) ? "''" : "0"),
+ "pivot", GetPivot(desc), "rptfields",
+ RepeatedFieldsArrayName(options, desc), "oneoffields",
+ OneofFieldsArrayName(options, desc));
printer->Print(
"};\n"
"goog.inherits($classname$, jspb.Message);\n"
@@ -2112,8 +2073,7 @@
}
void Generator::GenerateClassConstructorAndDeclareExtensionFieldInfo(
- const GeneratorOptions& options,
- io::Printer* printer,
+ const GeneratorOptions& options, io::Printer* printer,
const Descriptor* desc) const {
if (!NamespaceOnly(desc)) {
GenerateClassConstructor(options, printer, desc);
@@ -2141,9 +2101,9 @@
" */\n"
"$classname$$rptfieldarray$ = $rptfields$;\n"
"\n",
- "classname", GetMessagePath(options, desc),
- "rptfieldarray", kRepeatedFieldArrayName,
- "rptfields", RepeatedFieldNumberList(options, desc));
+ "classname", GetMessagePath(options, desc), "rptfieldarray",
+ kRepeatedFieldArrayName, "rptfields",
+ RepeatedFieldNumberList(options, desc));
}
if (HasOneofFields(desc)) {
@@ -2162,9 +2122,8 @@
" */\n"
"$classname$$oneofgrouparray$ = $oneofgroups$;\n"
"\n",
- "classname", GetMessagePath(options, desc),
- "oneofgrouparray", kOneofGroupArrayName,
- "oneofgroups", OneofGroupList(desc));
+ "classname", GetMessagePath(options, desc), "oneofgrouparray",
+ kOneofGroupArrayName, "oneofgroups", OneofGroupList(desc));
for (int i = 0; i < desc->oneof_decl_count(); i++) {
if (IgnoreOneof(desc->oneof_decl(i))) {
@@ -2186,8 +2145,7 @@
}
void Generator::GenerateOneofCaseDefinition(
- const GeneratorOptions& options,
- io::Printer* printer,
+ const GeneratorOptions& options, io::Printer* printer,
const OneofDescriptor* oneof) const {
printer->Print(
"/**\n"
@@ -2195,9 +2153,8 @@
" */\n"
"$classname$.$oneof$Case = {\n"
" $upcase$_NOT_SET: 0",
- "classname", GetMessagePath(options, oneof->containing_type()),
- "oneof", JSOneofName(oneof),
- "upcase", ToEnumCase(oneof->name()));
+ "classname", GetMessagePath(options, oneof->containing_type()), "oneof",
+ JSOneofName(oneof), "upcase", ToEnumCase(oneof->name()));
for (int i = 0; i < oneof->field_count(); i++) {
if (IgnoreField(oneof->field(i))) {
@@ -2207,8 +2164,8 @@
printer->Print(
",\n"
" $upcase$: $number$",
- "upcase", ToEnumCase(oneof->field(i)->name()),
- "number", JSFieldIndex(oneof->field(i)));
+ "upcase", ToEnumCase(oneof->field(i)->name()), "number",
+ JSFieldIndex(oneof->field(i)));
printer->Annotate("upcase", oneof->field(i));
}
@@ -2224,9 +2181,8 @@
"computeOneofCase(this, $class$.oneofGroups_[$oneofindex$]));\n"
"};\n"
"\n",
- "class", GetMessagePath(options, oneof->containing_type()),
- "oneof", JSOneofName(oneof),
- "oneofindex", JSOneofIndex(oneof));
+ "class", GetMessagePath(options, oneof->containing_type()), "oneof",
+ JSOneofName(oneof), "oneofindex", JSOneofIndex(oneof));
}
void Generator::GenerateClassToObject(const GeneratorOptions& options,
@@ -2315,7 +2271,7 @@
}
void Generator::GenerateFieldValueExpression(io::Printer* printer,
- const char *obj_reference,
+ const char* obj_reference,
const FieldDescriptor* field,
bool use_default) const {
const bool is_float_or_double =
@@ -2348,29 +2304,25 @@
// - getRepeatedFloatingPointField
if (is_float_or_double && !field->is_repeated() && !use_default) {
printer->Print(
- "jspb.Message.getOptionalFloatingPointField($obj$, "
- "$index$$default$)",
- "obj", obj_reference,
- "index", JSFieldIndex(field),
- "default", default_arg);
+ "jspb.Message.getOptionalFloatingPointField($obj$, "
+ "$index$$default$)",
+ "obj", obj_reference, "index", JSFieldIndex(field), "default",
+ default_arg);
} else {
printer->Print(
- "jspb.Message.get$cardinality$$type$Field$with_default$($obj$, "
- "$index$$default$)",
- "cardinality", cardinality,
- "type", type,
- "with_default", with_default,
- "obj", obj_reference,
- "index", JSFieldIndex(field),
- "default", default_arg);
+ "jspb.Message.get$cardinality$$type$Field$with_default$($obj$, "
+ "$index$$default$)",
+ "cardinality", cardinality, "type", type, "with_default", with_default,
+ "obj", obj_reference, "index", JSFieldIndex(field), "default",
+ default_arg);
}
}
void Generator::GenerateClassFieldToObject(const GeneratorOptions& options,
io::Printer* printer,
const FieldDescriptor* field) const {
- printer->Print("$fieldname$: ",
- "fieldname", JSObjectFieldName(options, field));
+ printer->Print("$fieldname$: ", "fieldname",
+ JSObjectFieldName(options, field));
if (field->is_map()) {
const FieldDescriptor* value_field = MapFieldValue(field);
@@ -2391,21 +2343,23 @@
// Message field.
if (field->is_repeated()) {
{
- printer->Print("jspb.Message.toObjectList(msg.get$getter$(),\n"
- " $type$.toObject, includeInstance)",
- "getter", JSGetterName(options, field),
- "type", SubmessageTypeRef(options, field));
+ printer->Print(
+ "jspb.Message.toObjectList(msg.get$getter$(),\n"
+ " $type$.toObject, includeInstance)",
+ "getter", JSGetterName(options, field), "type",
+ SubmessageTypeRef(options, field));
}
} else {
- printer->Print("(f = msg.get$getter$()) && "
- "$type$.toObject(includeInstance, f)",
- "getter", JSGetterName(options, field),
- "type", SubmessageTypeRef(options, field));
+ printer->Print(
+ "(f = msg.get$getter$()) && "
+ "$type$.toObject(includeInstance, f)",
+ "getter", JSGetterName(options, field), "type",
+ SubmessageTypeRef(options, field));
}
} else if (field->type() == FieldDescriptor::TYPE_BYTES) {
// For bytes fields we want to always return the B64 data.
- printer->Print("msg.get$getter$()",
- "getter", JSGetterName(options, field, BYTES_B64));
+ printer->Print("msg.get$getter$()", "getter",
+ JSGetterName(options, field, BYTES_B64));
} else {
bool use_default = field->has_default_value();
@@ -2450,15 +2404,14 @@
" * @record\n"
" */\n"
"$typeName$ = function() {};\n\n",
- "messageName", desc->name(),
- "typeName", type_name);
+ "messageName", desc->name(), "typeName", type_name);
for (int i = 0; i < desc->field_count(); i++) {
printer->Print(
"/** @type {$fieldType$|undefined} */\n"
"$typeName$.prototype.$fieldName$;\n\n",
- "typeName", type_name,
- "fieldName", JSObjectFieldName(options, desc->field(i)),
+ "typeName", type_name, "fieldName",
+ JSObjectFieldName(options, desc->field(i)),
// TODO(b/121097361): Add type checking for field values.
"fieldType", "?");
}
@@ -2467,8 +2420,7 @@
void Generator::GenerateClassFromObject(const GeneratorOptions& options,
io::Printer* printer,
const Descriptor* desc) const {
- printer->Print(
- "if (jspb.Message.GENERATE_FROM_OBJECT) {\n\n");
+ printer->Print("if (jspb.Message.GENERATE_FROM_OBJECT) {\n\n");
GenerateObjectTypedef(options, printer, desc);
@@ -2497,8 +2449,7 @@
}
void Generator::GenerateClassFieldFromObject(
- const GeneratorOptions& options,
- io::Printer* printer,
+ const GeneratorOptions& options, io::Printer* printer,
const FieldDescriptor* field) const {
if (field->is_map()) {
const FieldDescriptor* value_field = MapFieldValue(field);
@@ -2509,9 +2460,9 @@
" obj.$name$ && jspb.Message.setWrapperField(\n"
" msg, $index$, jspb.Map.fromObject(obj.$name$, $fieldclass$, "
"$fieldclass$.fromObject));\n",
- "name", JSObjectFieldName(options, field),
- "index", JSFieldIndex(field),
- "fieldclass", GetMessagePath(options, value_field->message_type()));
+ "name", JSObjectFieldName(options, field), "index",
+ JSFieldIndex(field), "fieldclass",
+ GetMessagePath(options, value_field->message_type()));
} else {
// `msg` is a newly-constructed message object that has not yet built any
// map containers wrapping underlying arrays, so we can simply directly
@@ -2519,8 +2470,8 @@
printer->Print(
" obj.$name$ && "
"jspb.Message.setField(msg, $index$, obj.$name$);\n",
- "name", JSObjectFieldName(options, field),
- "index", JSFieldIndex(field));
+ "name", JSObjectFieldName(options, field), "index",
+ JSFieldIndex(field));
}
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
// Message field (singular or repeated)
@@ -2531,25 +2482,24 @@
"jspb.Message.setRepeatedWrapperField(\n"
" msg, $index$, obj.$name$.map(\n"
" $fieldclass$.fromObject));\n",
- "name", JSObjectFieldName(options, field),
- "index", JSFieldIndex(field),
- "fieldclass", SubmessageTypeRef(options, field));
+ "name", JSObjectFieldName(options, field), "index",
+ JSFieldIndex(field), "fieldclass",
+ SubmessageTypeRef(options, field));
}
} else {
printer->Print(
" obj.$name$ && jspb.Message.setWrapperField(\n"
" msg, $index$, $fieldclass$.fromObject(obj.$name$));\n",
- "name", JSObjectFieldName(options, field),
- "index", JSFieldIndex(field),
- "fieldclass", SubmessageTypeRef(options, field));
+ "name", JSObjectFieldName(options, field), "index",
+ JSFieldIndex(field), "fieldclass", SubmessageTypeRef(options, field));
}
} else {
// Simple (primitive) field.
printer->Print(
" obj.$name$ != null && jspb.Message.setField(msg, $index$, "
"obj.$name$);\n",
- "name", JSObjectFieldName(options, field),
- "index", JSFieldIndex(field));
+ "name", JSObjectFieldName(options, field), "index",
+ JSFieldIndex(field));
}
}
@@ -2576,10 +2526,8 @@
}
}
-void GenerateBytesWrapper(const GeneratorOptions& options,
- io::Printer* printer,
- const FieldDescriptor* field,
- BytesMode bytes_mode) {
+void GenerateBytesWrapper(const GeneratorOptions& options, io::Printer* printer,
+ const FieldDescriptor* field, BytesMode bytes_mode) {
std::string type =
JSFieldTypeAnnotation(options, field,
/* is_setter_argument = */ false,
@@ -2598,14 +2546,13 @@
"};\n"
"\n"
"\n",
- "fielddef", FieldDefinition(options, field),
- "comment", FieldComments(field, bytes_mode),
- "type", type,
- "class", GetMessagePath(options, field->containing_type()),
- "name", JSGetterName(options, field, bytes_mode),
- "list", field->is_repeated() ? "List" : "",
- "suffix", JSByteGetterSuffix(bytes_mode),
- "defname", JSGetterName(options, field, BYTES_DEFAULT));
+ "fielddef", FieldDefinition(options, field), "comment",
+ FieldComments(field, bytes_mode), "type", type, "class",
+ GetMessagePath(options, field->containing_type()), "name",
+ JSGetterName(options, field, bytes_mode), "list",
+ field->is_repeated() ? "List" : "", "suffix",
+ JSByteGetterSuffix(bytes_mode), "defname",
+ JSGetterName(options, field, BYTES_DEFAULT));
}
void Generator::GenerateClassField(const GeneratorOptions& options,
@@ -2633,15 +2580,13 @@
" * empty, instead returning `undefined`\n"
" * @return {!jspb.Map<$keytype$,$valuetype$>}\n"
" */\n",
- "fielddef", FieldDefinition(options, field),
- "keytype", key_type,
+ "fielddef", FieldDefinition(options, field), "keytype", key_type,
"valuetype", value_type);
printer->Print(
"$class$.prototype.$gettername$ = function(opt_noLazyCreate) {\n"
" return /** @type {!jspb.Map<$keytype$,$valuetype$>} */ (\n",
"class", GetMessagePath(options, field->containing_type()),
- "gettername", "get" + JSGetterName(options, field),
- "keytype", key_type,
+ "gettername", "get" + JSGetterName(options, field), "keytype", key_type,
"valuetype", value_type);
printer->Annotate("gettername", field);
printer->Print(
@@ -2654,12 +2599,12 @@
" $messageType$",
"messageType", GetMessagePath(options, value_field->message_type()));
} else {
- printer->Print(",\n"
+ printer->Print(
+ ",\n"
" null");
}
- printer->Print(
- "));\n");
+ printer->Print("));\n");
printer->Print(
"};\n"
@@ -2675,12 +2620,12 @@
"$comment$"
" * @return {$type$}\n"
" */\n",
- "fielddef", FieldDefinition(options, field),
- "comment", FieldComments(field, BYTES_DEFAULT),
- "type", JSFieldTypeAnnotation(options, field,
- /* is_setter_argument = */ false,
- /* force_present = */ false,
- /* singular_if_not_packed = */ false));
+ "fielddef", FieldDefinition(options, field), "comment",
+ FieldComments(field, BYTES_DEFAULT), "type",
+ JSFieldTypeAnnotation(options, field,
+ /* is_setter_argument = */ false,
+ /* force_present = */ false,
+ /* singular_if_not_packed = */ false));
printer->Print(
"$class$.prototype.$gettername$ = function() {\n"
" return /** @type{$type$} */ (\n"
@@ -2690,16 +2635,15 @@
"\n"
"\n",
"class", GetMessagePath(options, field->containing_type()),
- "gettername", "get" + JSGetterName(options, field),
- "type", JSFieldTypeAnnotation(options, field,
- /* is_setter_argument = */ false,
- /* force_present = */ false,
- /* singular_if_not_packed = */ false),
- "rpt", (field->is_repeated() ? "Repeated" : ""),
- "index", JSFieldIndex(field),
- "wrapperclass", SubmessageTypeRef(options, field),
- "required", (field->label() == FieldDescriptor::LABEL_REQUIRED ?
- ", 1" : ""));
+ "gettername", "get" + JSGetterName(options, field), "type",
+ JSFieldTypeAnnotation(options, field,
+ /* is_setter_argument = */ false,
+ /* force_present = */ false,
+ /* singular_if_not_packed = */ false),
+ "rpt", (field->is_repeated() ? "Repeated" : ""), "index",
+ JSFieldIndex(field), "wrapperclass", SubmessageTypeRef(options, field),
+ "required",
+ (field->label() == FieldDescriptor::LABEL_REQUIRED ? ", 1" : ""));
printer->Annotate("gettername", field);
printer->Print(
"/** @param {$optionaltype$} value$returndoc$ */\n"
@@ -2710,11 +2654,11 @@
/* is_setter_argument = */ true,
/* force_present = */ false,
/* singular_if_not_packed = */ false),
- "returndoc", JSReturnDoc(options, field),
- "class", GetMessagePath(options, field->containing_type()),
- "settername", "set" + JSGetterName(options, field),
- "oneoftag", (field->containing_oneof() ? "Oneof" : ""),
- "repeatedtag", (field->is_repeated() ? "Repeated" : ""));
+ "returndoc", JSReturnDoc(options, field), "class",
+ GetMessagePath(options, field->containing_type()), "settername",
+ "set" + JSGetterName(options, field), "oneoftag",
+ (field->containing_oneof() ? "Oneof" : ""), "repeatedtag",
+ (field->is_repeated() ? "Repeated" : ""));
printer->Annotate("settername", field);
printer->Print(
@@ -2722,9 +2666,9 @@
"};\n"
"\n"
"\n",
- "index", JSFieldIndex(field),
- "oneofgroup", (field->containing_oneof() ?
- (", " + JSOneofArray(options, field)) : ""),
+ "index", JSFieldIndex(field), "oneofgroup",
+ (field->containing_oneof() ? (", " + JSOneofArray(options, field))
+ : ""),
"returnvalue", JSReturnClause(field));
if (field->is_repeated()) {
@@ -2741,8 +2685,9 @@
// at this point we "lie" to non-binary users and tell the return
// type is always base64 string, pending a LSC to migrate to typed getters.
BytesMode bytes_mode =
- field->type() == FieldDescriptor::TYPE_BYTES && !options.binary ?
- BYTES_B64 : BYTES_DEFAULT;
+ field->type() == FieldDescriptor::TYPE_BYTES && !options.binary
+ ? BYTES_B64
+ : BYTES_DEFAULT;
std::string typed_annotation =
JSFieldTypeAnnotation(options, field,
/* is_setter_argument = */ false,
@@ -2761,24 +2706,20 @@
"$comment$"
" * @return {$type$}\n"
" */\n",
- "fielddef", FieldDefinition(options, field),
- "comment", FieldComments(field, bytes_mode),
- "type", typed_annotation);
+ "fielddef", FieldDefinition(options, field), "comment",
+ FieldComments(field, bytes_mode), "type", typed_annotation);
}
- printer->Print(
- "$class$.prototype.$gettername$ = function() {\n",
- "class", GetMessagePath(options, field->containing_type()),
- "gettername", "get" + JSGetterName(options, field));
+ printer->Print("$class$.prototype.$gettername$ = function() {\n", "class",
+ GetMessagePath(options, field->containing_type()),
+ "gettername", "get" + JSGetterName(options, field));
printer->Annotate("gettername", field);
if (untyped) {
- printer->Print(
- " return ");
+ printer->Print(" return ");
} else {
- printer->Print(
- " return /** @type {$type$} */ (",
- "type", typed_annotation);
+ printer->Print(" return /** @type {$type$} */ (", "type",
+ typed_annotation);
}
bool use_default = !ReturnsNullWhenUnset(options, field);
@@ -2824,11 +2765,10 @@
} else {
printer->Print(
"/** @param {$optionaltype$} value$returndoc$ */\n", "optionaltype",
- JSFieldTypeAnnotation(
- options, field,
- /* is_setter_argument = */ true,
- /* force_present = */ false,
- /* singular_if_not_packed = */ false),
+ JSFieldTypeAnnotation(options, field,
+ /* is_setter_argument = */ true,
+ /* force_present = */ false,
+ /* singular_if_not_packed = */ false),
"returndoc", JSReturnDoc(options, field));
}
@@ -2881,7 +2821,6 @@
"returndoc", JSReturnDoc(options, field));
}
-
if (field->is_repeated()) {
GenerateRepeatedPrimitiveHelperMethods(options, printer, field, untyped);
}
@@ -2974,9 +2913,8 @@
"};\n"
"\n"
"\n",
- "class", GetMessagePath(options, field->containing_type()),
- "hasername", "has" + JSGetterName(options, field),
- "index", JSFieldIndex(field));
+ "class", GetMessagePath(options, field->containing_type()), "hasername",
+ "has" + JSGetterName(options, field), "index", JSFieldIndex(field));
printer->Annotate("hasername", field);
}
}
@@ -3133,15 +3071,13 @@
" var field = reader.getFieldNumber();\n"
" switch (field) {\n");
-
for (int i = 0; i < desc->field_count(); i++) {
if (!IgnoreField(desc->field(i))) {
GenerateClassDeserializeBinaryField(options, printer, desc->field(i));
}
}
- printer->Print(
- " default:\n");
+ printer->Print(" default:\n");
if (IsExtendable(desc)) {
printer->Print(
" jspb.Message.readBinaryExtension(msg, reader,\n"
@@ -3168,8 +3104,7 @@
}
void Generator::GenerateClassDeserializeBinaryField(
- const GeneratorOptions& options,
- io::Printer* printer,
+ const GeneratorOptions& options, io::Printer* printer,
const FieldDescriptor* field) const {
printer->Print(" case $num$:\n", "num", StrCat(field->number()));
@@ -3181,20 +3116,20 @@
" reader.readMessage(value, function(message, reader) {\n",
"name", JSGetterName(options, field));
- printer->Print(" jspb.Map.deserializeBinary(message, reader, "
- "$keyReaderFn$, $valueReaderFn$",
- "keyReaderFn", JSBinaryReaderMethodName(options, key_field),
- "valueReaderFn", JSBinaryReaderMethodName(options, value_field));
+ printer->Print(
+ " jspb.Map.deserializeBinary(message, reader, "
+ "$keyReaderFn$, $valueReaderFn$",
+ "keyReaderFn", JSBinaryReaderMethodName(options, key_field),
+ "valueReaderFn", JSBinaryReaderMethodName(options, value_field));
if (value_field->type() == FieldDescriptor::TYPE_MESSAGE) {
printer->Print(", $messageType$.deserializeBinaryFromReader",
- "messageType", GetMessagePath(options, value_field->message_type()));
+ "messageType",
+ GetMessagePath(options, value_field->message_type()));
} else {
printer->Print(", null");
}
- printer->Print(", $defaultKey$",
- "defaultKey", JSFieldDefault(key_field)
- );
+ printer->Print(", $defaultKey$", "defaultKey", JSFieldDefault(key_field));
printer->Print(");\n");
printer->Print(" });\n");
} else {
@@ -3213,9 +3148,9 @@
printer->Print(
" var value = /** @type {$fieldtype$} */ "
"(reader.read$reader$());\n",
- "fieldtype", JSFieldTypeAnnotation(options, field, false, true,
- /* singular_if_not_packed */ true,
- BYTES_U8),
+ "fieldtype",
+ JSFieldTypeAnnotation(options, field, false, true,
+ /* singular_if_not_packed */ true, BYTES_U8),
"reader",
JSBinaryReadWriteMethodName(field, /* is_writer = */ false));
}
@@ -3228,9 +3163,8 @@
// Singular fields, and packed repeated fields, receive a |value| either
// as the field's value or as the array of all the field's values; set
// this as the field's value directly.
- printer->Print(
- " msg.set$name$(value);\n",
- "name", JSGetterName(options, field));
+ printer->Print(" msg.set$name$(value);\n", "name",
+ JSGetterName(options, field));
}
}
@@ -3274,8 +3208,8 @@
printer->Print(
" jspb.Message.serializeBinaryExtensions(message, writer,\n"
" $extobj$Binary, $class$.prototype.getExtension);\n",
- "extobj", JSExtensionsObjectName(options, desc->file(), desc),
- "class", GetMessagePath(options, desc));
+ "extobj", JSExtensionsObjectName(options, desc->file(), desc), "class",
+ GetMessagePath(options, desc));
}
printer->Print(
@@ -3285,8 +3219,7 @@
}
void Generator::GenerateClassSerializeBinaryField(
- const GeneratorOptions& options,
- io::Printer* printer,
+ const GeneratorOptions& options, io::Printer* printer,
const FieldDescriptor* field) const {
if (HasFieldPresence(options, field) &&
field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
@@ -3299,12 +3232,11 @@
printer->Print(
" f = /** @type {$type$} */ "
"(jspb.Message.getField(message, $index$));\n",
- "index", JSFieldIndex(field),
- "type", typed_annotation);
+ "index", JSFieldIndex(field), "type", typed_annotation);
} else {
printer->Print(
- " f = message.get$name$($nolazy$);\n",
- "name", JSGetterName(options, field, BYTES_U8),
+ " f = message.get$name$($nolazy$);\n", "name",
+ JSGetterName(options, field, BYTES_U8),
// No lazy creation for maps containers -- fastpath the empty case.
"nolazy", field->is_map() ? "true" : "");
}
@@ -3312,15 +3244,12 @@
// Print an `if (condition)` statement that evaluates to true if the field
// goes on the wire.
if (field->is_map()) {
- printer->Print(
- " if (f && f.getLength() > 0) {\n");
+ printer->Print(" if (f && f.getLength() > 0) {\n");
} else if (field->is_repeated()) {
- printer->Print(
- " if (f.length > 0) {\n");
+ printer->Print(" if (f.length > 0) {\n");
} else {
if (HasFieldPresence(options, field)) {
- printer->Print(
- " if (f != null) {\n");
+ printer->Print(" if (f != null) {\n");
} else {
// No field presence: serialize onto the wire only if value is
// non-default. Defaults are documented here:
@@ -3345,16 +3274,13 @@
case FieldDescriptor::CPPTYPE_ENUM:
case FieldDescriptor::CPPTYPE_FLOAT:
case FieldDescriptor::CPPTYPE_DOUBLE:
- printer->Print(
- " if (f !== 0.0) {\n");
+ printer->Print(" if (f !== 0.0) {\n");
break;
case FieldDescriptor::CPPTYPE_BOOL:
- printer->Print(
- " if (f) {\n");
+ printer->Print(" if (f) {\n");
break;
case FieldDescriptor::CPPTYPE_STRING:
- printer->Print(
- " if (f.length > 0) {\n");
+ printer->Print(" if (f.length > 0) {\n");
break;
default:
assert(false);
@@ -3375,8 +3301,8 @@
JSBinaryWriterMethodName(options, value_field));
if (value_field->type() == FieldDescriptor::TYPE_MESSAGE) {
- printer->Print(", $messageType$.serializeBinaryToWriter",
- "messageType", GetMessagePath(options, value_field->message_type()));
+ printer->Print(", $messageType$.serializeBinaryToWriter", "messageType",
+ GetMessagePath(options, value_field->message_type()));
}
printer->Print(");\n");
@@ -3393,18 +3319,16 @@
printer->Print(
",\n"
" $submsg$.serializeBinaryToWriter\n",
- "submsg", SubmessageTypeRef(options, field));
+ "submsg", SubmessageTypeRef(options, field));
} else {
printer->Print("\n");
}
- printer->Print(
- " );\n");
+ printer->Print(" );\n");
}
// Close the `if`.
- printer->Print(
- " }\n");
+ printer->Print(" }\n");
}
void Generator::GenerateEnum(const GeneratorOptions& options,
@@ -3415,8 +3339,8 @@
" * @enum {number}\n"
" */\n"
"$enumprefix$$name$ = {\n",
- "enumprefix", GetEnumPathPrefix(options, enumdesc),
- "name", enumdesc->name());
+ "enumprefix", GetEnumPathPrefix(options, enumdesc), "name",
+ enumdesc->name());
printer->Annotate("name", enumdesc);
for (int i = 0; i < enumdesc->value_count(); i++) {
@@ -3450,14 +3374,12 @@
" * @type {!jspb.ExtensionFieldInfo<$extensionType$>}\n"
" */\n"
"$class$.$name$ = new jspb.ExtensionFieldInfo(\n",
- "nameInComment", extension_object_name,
- "name", extension_object_name,
- "class", extension_scope,
- "extensionType", JSFieldTypeAnnotation(
- options, field,
- /* is_setter_argument = */ false,
- /* force_present = */ true,
- /* singular_if_not_packed = */ false));
+ "nameInComment", extension_object_name, "name", extension_object_name,
+ "class", extension_scope, "extensionType",
+ JSFieldTypeAnnotation(options, field,
+ /* is_setter_argument = */ false,
+ /* force_present = */ true,
+ /* singular_if_not_packed = */ false));
printer->Annotate("name", field);
printer->Print(
" $index$,\n"
@@ -3619,8 +3541,7 @@
}
void Generator::GenerateFilesInDepOrder(
- const GeneratorOptions& options,
- io::Printer* printer,
+ const GeneratorOptions& options, io::Printer* printer,
const std::vector<const FileDescriptor*>& files) const {
// Build a std::set over all files so that the DFS can detect when it recurses
// into a dep not specified in the user's command line.
@@ -3633,10 +3554,8 @@
}
void Generator::GenerateFileAndDeps(
- const GeneratorOptions& options,
- io::Printer* printer,
- const FileDescriptor* root,
- std::set<const FileDescriptor*>* all_files,
+ const GeneratorOptions& options, io::Printer* printer,
+ const FileDescriptor* root, std::set<const FileDescriptor*>* all_files,
std::set<const FileDescriptor*>* generated) const {
// Skip if already generated.
if (generated->find(root) != generated->end()) {
@@ -3659,7 +3578,7 @@
}
bool Generator::GenerateFile(const FileDescriptor* file,
- const GeneratorOptions &options,
+ const GeneratorOptions& options,
GeneratorContext* context,
bool use_short_name) const {
std::string filename =
@@ -3672,10 +3591,8 @@
GeneratedCodeInfo annotations;
io::AnnotationProtoCollector<GeneratedCodeInfo> annotation_collector(
&annotations);
- io::Printer printer(
- output.get(), '$', options.annotate_code ?
- &annotation_collector : nullptr);
-
+ io::Printer printer(output.get(), '$',
+ options.annotate_code ? &annotation_collector : nullptr);
GenerateFile(options, &printer, file);
@@ -3753,8 +3670,8 @@
// if provided is empty, do not export anything
if (options.import_style == GeneratorOptions::kImportCommonJs &&
!provided.empty()) {
- printer->Print("goog.object.extend(exports, $package$);\n",
- "package", GetNamespace(options, file));
+ printer->Print("goog.object.extend(exports, $package$);\n", "package",
+ GetNamespace(options, file));
} else if (options.import_style == GeneratorOptions::kImportCommonJsStrict) {
printer->Print("goog.object.extend(exports, proto);\n", "package",
GetNamespace(options, file));
@@ -3823,8 +3740,8 @@
std::set<const Descriptor*> have_printed;
SCCAnalyzer<DepsGenerator> analyzer;
std::map<const void*, std::string> allowed_map;
- if (!GenerateJspbAllowedMap(
- options, files, &allowed_map, &analyzer, error)) {
+ if (!GenerateJspbAllowedMap(options, files, &allowed_map, &analyzer,
+ error)) {
return false;
}
@@ -3852,7 +3769,12 @@
std::unique_ptr<io::ZeroCopyOutputStream> output(
context->Open(filename));
GOOGLE_CHECK(output.get());
- io::Printer printer(output.get(), '$');
+ GeneratedCodeInfo annotations;
+ io::AnnotationProtoCollector<GeneratedCodeInfo> annotation_collector(
+ &annotations);
+ io::Printer printer(
+ output.get(), '$',
+ options.annotate_code ? &annotation_collector : nullptr);
GenerateHeader(options, &printer);
@@ -3885,6 +3807,9 @@
if (printer.failed()) {
return false;
}
+ if (options.annotate_code) {
+ EmbedCodeAnnotations(annotations, &printer);
+ }
}
for (int j = 0; j < file->enum_type_count(); j++) {
const EnumDescriptor* enumdesc = file->enum_type(j);
@@ -3897,7 +3822,12 @@
std::unique_ptr<io::ZeroCopyOutputStream> output(
context->Open(filename));
GOOGLE_CHECK(output.get());
- io::Printer printer(output.get(), '$');
+ GeneratedCodeInfo annotations;
+ io::AnnotationProtoCollector<GeneratedCodeInfo> annotation_collector(
+ &annotations);
+ io::Printer printer(
+ output.get(), '$',
+ options.annotate_code ? &annotation_collector : nullptr);
GenerateHeader(options, &printer);
@@ -3911,6 +3841,9 @@
if (printer.failed()) {
return false;
}
+ if (options.annotate_code) {
+ EmbedCodeAnnotations(annotations, &printer);
+ }
}
// File-level extensions (message-level extensions are generated under
// the enclosing message).
@@ -3921,7 +3854,12 @@
std::unique_ptr<io::ZeroCopyOutputStream> output(
context->Open(filename));
GOOGLE_CHECK(output.get());
- io::Printer printer(output.get(), '$');
+ GeneratedCodeInfo annotations;
+ io::AnnotationProtoCollector<GeneratedCodeInfo> annotation_collector(
+ &annotations);
+ io::Printer printer(
+ output.get(), '$',
+ options.annotate_code ? &annotation_collector : nullptr);
GenerateHeader(options, &printer);
@@ -3944,14 +3882,16 @@
GenerateExtension(options, &printer, files[i]->extension(j));
}
}
+ if (options.annotate_code) {
+ EmbedCodeAnnotations(annotations, &printer);
+ }
}
}
if (!generated) {
std::string filename = options.output_dir + "/" +
"empty_no_content_void_file" +
options.GetFileNameExtension();
- std::unique_ptr<io::ZeroCopyOutputStream> output(
- context->Open(filename));
+ std::unique_ptr<io::ZeroCopyOutputStream> output(context->Open(filename));
}
} else /* options.output_mode() == kOneOutputFilePerInputFile */ {
// Generate one output file per input (.proto) file.
diff --git a/src/google/protobuf/compiler/js/js_generator.h b/src/google/protobuf/compiler/js/js_generator.h
index e99622f..b1c1878 100644
--- a/src/google/protobuf/compiler/js/js_generator.h
+++ b/src/google/protobuf/compiler/js/js_generator.h
@@ -33,8 +33,8 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_JS_GENERATOR_H__
#define GOOGLE_PROTOBUF_COMPILER_JS_GENERATOR_H__
-#include <string>
#include <set>
+#include <string>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
@@ -52,7 +52,9 @@
class OneofDescriptor;
class FileDescriptor;
-namespace io { class Printer; }
+namespace io {
+class Printer;
+}
namespace compiler {
namespace js {
@@ -123,8 +125,11 @@
std::string extension;
// Create a separate output file for each input file?
bool one_output_file_per_input_file;
- // If true, we should build .meta files that contain annotations for
- // generated code. See GeneratedCodeInfo in descriptor.proto.
+ // If true, we should append annotations as commen on the last line for
+ // generated .js file. Annotations used by tools like https://kythe.io
+ // to provide cross-references between .js and .proto files. Annotations
+ // are enced as base64 proto of GeneratedCodeInfo message (see
+ // descriptor.proto).
bool annotate_code;
};
@@ -215,12 +220,9 @@
// Generate all things in a proto file into one file.
// If use_short_name is true, the generated file's name will only be short
// name that without directory, otherwise filename equals file->name()
- bool GenerateFile(const FileDescriptor* file,
- const GeneratorOptions &options,
- GeneratorContext* context,
- bool use_short_name) const;
- void GenerateFile(const GeneratorOptions& options,
- io::Printer* printer,
+ bool GenerateFile(const FileDescriptor* file, const GeneratorOptions& options,
+ GeneratorContext* context, bool use_short_name) const;
+ void GenerateFile(const GeneratorOptions& options, io::Printer* printer,
const FileDescriptor* file) const;
// Generate definitions for all message classes and enums in all files,
@@ -230,8 +232,7 @@
const std::vector<const FileDescriptor*>& file) const;
// Helper for above.
void GenerateFileAndDeps(const GeneratorOptions& options,
- io::Printer* printer,
- const FileDescriptor* root,
+ io::Printer* printer, const FileDescriptor* root,
std::set<const FileDescriptor*>* all_files,
std::set<const FileDescriptor*>* generated) const;
@@ -246,8 +247,7 @@
bool use_default) const;
// Generate definition for one class.
- void GenerateClass(const GeneratorOptions& options,
- io::Printer* printer,
+ void GenerateClass(const GeneratorOptions& options, io::Printer* printer,
const Descriptor* desc) const;
void GenerateClassConstructor(const GeneratorOptions& options,
io::Printer* printer,
@@ -256,11 +256,9 @@
io::Printer* printer,
const Descriptor* desc) const;
void GenerateClassConstructorAndDeclareExtensionFieldInfo(
- const GeneratorOptions& options,
- io::Printer* printer,
+ const GeneratorOptions& options, io::Printer* printer,
const Descriptor* desc) const;
- void GenerateClassXid(const GeneratorOptions& options,
- io::Printer* printer,
+ void GenerateClassXid(const GeneratorOptions& options, io::Printer* printer,
const Descriptor* desc) const;
void GenerateOneofCaseDefinition(const GeneratorOptions& options,
io::Printer* printer,
@@ -280,17 +278,14 @@
void GenerateClassFieldFromObject(const GeneratorOptions& options,
io::Printer* printer,
const FieldDescriptor* field) const;
- void GenerateClassClone(const GeneratorOptions& options,
- io::Printer* printer,
+ void GenerateClassClone(const GeneratorOptions& options, io::Printer* printer,
const Descriptor* desc) const;
void GenerateClassRegistration(const GeneratorOptions& options,
io::Printer* printer,
const Descriptor* desc) const;
void GenerateClassFields(const GeneratorOptions& options,
- io::Printer* printer,
- const Descriptor* desc) const;
- void GenerateClassField(const GeneratorOptions& options,
- io::Printer* printer,
+ io::Printer* printer, const Descriptor* desc) const;
+ void GenerateClassField(const GeneratorOptions& options, io::Printer* printer,
const FieldDescriptor* desc) const;
void GenerateClassExtensionFieldInfo(const GeneratorOptions& options,
io::Printer* printer,
@@ -312,13 +307,11 @@
const FieldDescriptor* field) const;
// Generate definition for one enum.
- void GenerateEnum(const GeneratorOptions& options,
- io::Printer* printer,
+ void GenerateEnum(const GeneratorOptions& options, io::Printer* printer,
const EnumDescriptor* enumdesc) const;
// Generate an extension definition.
- void GenerateExtension(const GeneratorOptions& options,
- io::Printer* printer,
+ void GenerateExtension(const GeneratorOptions& options, io::Printer* printer,
const FieldDescriptor* field) const;
// Generate addFoo() method for repeated primitive fields.
diff --git a/src/google/protobuf/compiler/mock_code_generator.cc b/src/google/protobuf/compiler/mock_code_generator.cc
index 46326e2..0776064 100644
--- a/src/google/protobuf/compiler/mock_code_generator.cc
+++ b/src/google/protobuf/compiler/mock_code_generator.cc
@@ -114,16 +114,16 @@
}
EXPECT_EQ(lines.size(), 3 + insertion_list.size() * 2);
- EXPECT_EQ(GetOutputFileContent(name, parameter, file,
- first_parsed_file_name, first_message_name),
+ EXPECT_EQ(GetOutputFileContent(name, parameter, file, first_parsed_file_name,
+ first_message_name),
lines[0]);
EXPECT_EQ(kFirstInsertionPoint, lines[1 + insertion_list.size()]);
EXPECT_EQ(kSecondInsertionPoint, lines[2 + insertion_list.size() * 2]);
for (size_t i = 0; i < insertion_list.size(); i++) {
- EXPECT_EQ(GetOutputFileContent(insertion_list[i], "first_insert",
- file, file, first_message_name),
+ EXPECT_EQ(GetOutputFileContent(insertion_list[i], "first_insert", file,
+ file, first_message_name),
lines[1 + i]);
// Second insertion point is indented, so the inserted text should
// automatically be indented too.
@@ -200,8 +200,8 @@
} else if (command == "HasJsonName") {
FieldDescriptorProto field_descriptor_proto;
file->message_type(i)->field(0)->CopyTo(&field_descriptor_proto);
- std::cerr << "Saw json_name: "
- << field_descriptor_proto.has_json_name() << std::endl;
+ std::cerr << "Saw json_name: " << field_descriptor_proto.has_json_name()
+ << std::endl;
abort();
} else if (command == "Annotate") {
annotate = true;
@@ -210,8 +210,8 @@
context->GetCompilerVersion(&compiler_version);
std::cerr << "Saw compiler_version: "
<< compiler_version.major() * 1000000 +
- compiler_version.minor() * 1000 +
- compiler_version.patch()
+ compiler_version.minor() * 1000 +
+ compiler_version.patch()
<< " " << compiler_version.suffix() << std::endl;
abort();
} else {
@@ -230,8 +230,8 @@
std::unique_ptr<io::ZeroCopyOutputStream> output(context->OpenForInsert(
GetOutputFileName(insert_into[i], file), kFirstInsertionPointName));
io::Printer printer(output.get(), '$');
- printer.PrintRaw(GetOutputFileContent(name_, "first_insert",
- file, context));
+ printer.PrintRaw(
+ GetOutputFileContent(name_, "first_insert", file, context));
if (printer.failed()) {
*error = "MockCodeGenerator detected write error.";
return false;
@@ -243,8 +243,8 @@
context->OpenForInsert(GetOutputFileName(insert_into[i], file),
kSecondInsertionPointName));
io::Printer printer(output.get(), '$');
- printer.PrintRaw(GetOutputFileContent(name_, "second_insert",
- file, context));
+ printer.PrintRaw(
+ GetOutputFileContent(name_, "second_insert", file, context));
if (printer.failed()) {
*error = "MockCodeGenerator detected write error.";
return false;
@@ -310,19 +310,17 @@
std::vector<const FileDescriptor*> all_files;
context->ListParsedFiles(&all_files);
return GetOutputFileContent(
- generator_name, parameter, file->name(),
- CommaSeparatedList(all_files),
- file->message_type_count() > 0 ?
- file->message_type(0)->name() : "(none)");
+ generator_name, parameter, file->name(), CommaSeparatedList(all_files),
+ file->message_type_count() > 0 ? file->message_type(0)->name()
+ : "(none)");
}
std::string MockCodeGenerator::GetOutputFileContent(
const std::string& generator_name, const std::string& parameter,
const std::string& file, const std::string& parsed_file_list,
const std::string& first_message_name) {
- return strings::Substitute("$0: $1, $2, $3, $4\n",
- generator_name, parameter, file,
- first_message_name, parsed_file_list);
+ return strings::Substitute("$0: $1, $2, $3, $4\n", generator_name, parameter,
+ file, first_message_name, parsed_file_list);
}
} // namespace compiler
diff --git a/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc b/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc
index 3d0b0d2..bcf4d39 100644
--- a/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc
+++ b/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc
@@ -47,7 +47,7 @@
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/io/printer.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
-#include <google/protobuf/stubs/io_win32.h>
+#include <google/protobuf/io/io_win32.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/strutil.h>
@@ -63,7 +63,7 @@
// in this port namespace to avoid ambiguous definition.
namespace posix {
#ifdef _WIN32
-using ::google::protobuf::internal::win32::open;
+using ::google::protobuf::io::win32::open;
#else
using ::open;
#endif
diff --git a/src/google/protobuf/compiler/parser.cc b/src/google/protobuf/compiler/parser.cc
index 9264710..c96fc17 100644
--- a/src/google/protobuf/compiler/parser.cc
+++ b/src/google/protobuf/compiler/parser.cc
@@ -65,23 +65,23 @@
TypeNameMap MakeTypeNameTable() {
TypeNameMap result;
- result["double" ] = FieldDescriptorProto::TYPE_DOUBLE;
- result["float" ] = FieldDescriptorProto::TYPE_FLOAT;
- result["uint64" ] = FieldDescriptorProto::TYPE_UINT64;
- result["fixed64" ] = FieldDescriptorProto::TYPE_FIXED64;
- result["fixed32" ] = FieldDescriptorProto::TYPE_FIXED32;
- result["bool" ] = FieldDescriptorProto::TYPE_BOOL;
- result["string" ] = FieldDescriptorProto::TYPE_STRING;
- result["group" ] = FieldDescriptorProto::TYPE_GROUP;
+ result["double"] = FieldDescriptorProto::TYPE_DOUBLE;
+ result["float"] = FieldDescriptorProto::TYPE_FLOAT;
+ result["uint64"] = FieldDescriptorProto::TYPE_UINT64;
+ result["fixed64"] = FieldDescriptorProto::TYPE_FIXED64;
+ result["fixed32"] = FieldDescriptorProto::TYPE_FIXED32;
+ result["bool"] = FieldDescriptorProto::TYPE_BOOL;
+ result["string"] = FieldDescriptorProto::TYPE_STRING;
+ result["group"] = FieldDescriptorProto::TYPE_GROUP;
- result["bytes" ] = FieldDescriptorProto::TYPE_BYTES;
- result["uint32" ] = FieldDescriptorProto::TYPE_UINT32;
+ result["bytes"] = FieldDescriptorProto::TYPE_BYTES;
+ result["uint32"] = FieldDescriptorProto::TYPE_UINT32;
result["sfixed32"] = FieldDescriptorProto::TYPE_SFIXED32;
result["sfixed64"] = FieldDescriptorProto::TYPE_SFIXED64;
- result["int32" ] = FieldDescriptorProto::TYPE_INT32;
- result["int64" ] = FieldDescriptorProto::TYPE_INT64;
- result["sint32" ] = FieldDescriptorProto::TYPE_SINT32;
- result["sint64" ] = FieldDescriptorProto::TYPE_SINT64;
+ result["int32"] = FieldDescriptorProto::TYPE_INT32;
+ result["int64"] = FieldDescriptorProto::TYPE_INT64;
+ result["sint32"] = FieldDescriptorProto::TYPE_SINT32;
+ result["sint64"] = FieldDescriptorProto::TYPE_SINT64;
return result;
}
@@ -119,21 +119,23 @@
// Makes code slightly more readable. The meaning of "DO(foo)" is
// "Execute foo and fail if it fails.", where failure is indicated by
// returning false.
-#define DO(STATEMENT) if (STATEMENT) {} else return false
+#define DO(STATEMENT) \
+ if (STATEMENT) { \
+ } else \
+ return false
// ===================================================================
Parser::Parser()
- : input_(NULL),
- error_collector_(NULL),
- source_location_table_(NULL),
- had_errors_(false),
- require_syntax_identifier_(false),
- stop_after_syntax_identifier_(false) {
+ : input_(NULL),
+ error_collector_(NULL),
+ source_location_table_(NULL),
+ had_errors_(false),
+ require_syntax_identifier_(false),
+ stop_after_syntax_identifier_(false) {
}
-Parser::~Parser() {
-}
+Parser::~Parser() {}
// ===================================================================
@@ -145,9 +147,7 @@
return input_->current().type == token_type;
}
-inline bool Parser::AtEnd() {
- return LookingAtType(io::Tokenizer::TYPE_END);
-}
+inline bool Parser::AtEnd() { return LookingAtType(io::Tokenizer::TYPE_END); }
bool Parser::TryConsume(const char* text) {
if (LookingAt(text)) {
@@ -190,8 +190,8 @@
bool Parser::ConsumeInteger(int* output, const char* error) {
if (LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
uint64 value = 0;
- if (!io::Tokenizer::ParseInteger(input_->current().text,
- kint32max, &value)) {
+ if (!io::Tokenizer::ParseInteger(input_->current().text, kint32max,
+ &value)) {
AddError("Integer out of range.");
// We still return true because we did, in fact, parse an integer.
}
@@ -243,8 +243,8 @@
} else if (LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
// Also accept integers.
uint64 value = 0;
- if (!io::Tokenizer::ParseInteger(input_->current().text,
- kuint64max, &value)) {
+ if (!io::Tokenizer::ParseInteger(input_->current().text, kuint64max,
+ &value)) {
AddError("Integer out of range.");
// We still return true because we did, in fact, parse a number.
}
@@ -281,8 +281,8 @@
}
}
-bool Parser::TryConsumeEndOfDeclaration(
- const char* text, const LocationRecorder* location) {
+bool Parser::TryConsumeEndOfDeclaration(const char* text,
+ const LocationRecorder* location) {
if (LookingAt(text)) {
std::string leading, trailing;
std::vector<std::string> detached;
@@ -312,8 +312,8 @@
}
}
-bool Parser::ConsumeEndOfDeclaration(
- const char* text, const LocationRecorder* location) {
+bool Parser::ConsumeEndOfDeclaration(const char* text,
+ const LocationRecorder* location) {
if (TryConsumeEndOfDeclaration(text, location)) {
return true;
} else {
@@ -408,7 +408,8 @@
location_->add_span(token.end_column);
}
-void Parser::LocationRecorder::RecordLegacyLocation(const Message* descriptor,
+void Parser::LocationRecorder::RecordLegacyLocation(
+ const Message* descriptor,
DescriptorPool::ErrorCollector::ErrorLocation location) {
if (parser_->source_location_table_ != NULL) {
parser_->source_location_table_->Add(
@@ -416,6 +417,14 @@
}
}
+void Parser::LocationRecorder::RecordLegacyImportLocation(
+ const Message* descriptor, const string& name) {
+ if (parser_->source_location_table_ != nullptr) {
+ parser_->source_location_table_->AddImport(
+ descriptor, name, location_->span(0), location_->span(1));
+ }
+}
+
int Parser::LocationRecorder::CurrentPathSize() const {
return location_->path_size();
}
@@ -433,8 +442,7 @@
location_->mutable_trailing_comments()->swap(*trailing);
}
for (int i = 0; i < detached_comments->size(); ++i) {
- location_->add_leading_detached_comments()->swap(
- (*detached_comments)[i]);
+ location_->add_leading_detached_comments()->swap((*detached_comments)[i]);
}
detached_comments->clear();
}
@@ -551,6 +559,8 @@
{
LocationRecorder root_location(this);
+ root_location.RecordLegacyLocation(file,
+ DescriptorPool::ErrorCollector::OTHER);
if (require_syntax_identifier_ || LookingAt("syntax")) {
if (!ParseSyntaxIdentifier(root_location)) {
@@ -561,8 +571,8 @@
// Store the syntax into the file.
if (file != NULL) file->set_syntax(syntax_identifier_);
} else if (!stop_after_syntax_identifier_) {
- GOOGLE_LOG(WARNING) << "No syntax specified for the proto file: "
- << file->name() << ". Please use 'syntax = \"proto2\";' "
+ GOOGLE_LOG(WARNING) << "No syntax specified for the proto file: " << file->name()
+ << ". Please use 'syntax = \"proto2\";' "
<< "or 'syntax = \"proto3\";' to specify a syntax "
<< "version. (Defaulted to proto2 syntax.)";
syntax_identifier_ = "proto2";
@@ -610,8 +620,9 @@
if (syntax != "proto2" && syntax != "proto3" &&
!stop_after_syntax_identifier_) {
AddError(syntax_token.line, syntax_token.column,
- "Unrecognized syntax identifier \"" + syntax + "\". This parser "
- "only recognizes \"proto2\" and \"proto3\".");
+ "Unrecognized syntax identifier \"" + syntax +
+ "\". This parser "
+ "only recognizes \"proto2\" and \"proto3\".");
return false;
}
@@ -625,34 +636,34 @@
return true;
} else if (LookingAt("message")) {
LocationRecorder location(root_location,
- FileDescriptorProto::kMessageTypeFieldNumber, file->message_type_size());
+ FileDescriptorProto::kMessageTypeFieldNumber,
+ file->message_type_size());
return ParseMessageDefinition(file->add_message_type(), location, file);
} else if (LookingAt("enum")) {
LocationRecorder location(root_location,
- FileDescriptorProto::kEnumTypeFieldNumber, file->enum_type_size());
+ FileDescriptorProto::kEnumTypeFieldNumber,
+ file->enum_type_size());
return ParseEnumDefinition(file->add_enum_type(), location, file);
} else if (LookingAt("service")) {
LocationRecorder location(root_location,
- FileDescriptorProto::kServiceFieldNumber, file->service_size());
+ FileDescriptorProto::kServiceFieldNumber,
+ file->service_size());
return ParseServiceDefinition(file->add_service(), location, file);
} else if (LookingAt("extend")) {
LocationRecorder location(root_location,
- FileDescriptorProto::kExtensionFieldNumber);
- return ParseExtend(file->mutable_extension(),
- file->mutable_message_type(),
- root_location,
- FileDescriptorProto::kMessageTypeFieldNumber,
- location, file);
+ FileDescriptorProto::kExtensionFieldNumber);
+ return ParseExtend(
+ file->mutable_extension(), file->mutable_message_type(), root_location,
+ FileDescriptorProto::kMessageTypeFieldNumber, location, file);
} else if (LookingAt("import")) {
return ParseImport(file->mutable_dependency(),
file->mutable_public_dependency(),
- file->mutable_weak_dependency(),
- root_location, file);
+ file->mutable_weak_dependency(), root_location, file);
} else if (LookingAt("package")) {
return ParsePackage(file, root_location, file);
} else if (LookingAt("option")) {
LocationRecorder location(root_location,
- FileDescriptorProto::kOptionsFieldNumber);
+ FileDescriptorProto::kOptionsFieldNumber);
return ParseOption(file->mutable_options(), location, file,
OPTION_STATEMENT);
} else {
@@ -665,15 +676,14 @@
// Messages
bool Parser::ParseMessageDefinition(
- DescriptorProto* message,
- const LocationRecorder& message_location,
+ DescriptorProto* message, const LocationRecorder& message_location,
const FileDescriptorProto* containing_file) {
DO(Consume("message"));
{
LocationRecorder location(message_location,
DescriptorProto::kNameFieldNumber);
- location.RecordLegacyLocation(
- message, DescriptorPool::ErrorCollector::NAME);
+ location.RecordLegacyLocation(message,
+ DescriptorPool::ErrorCollector::NAME);
DO(ConsumeIdentifier(message->mutable_name(), "Expected message name."));
}
DO(ParseMessageBlock(message, message_location, containing_file));
@@ -702,9 +712,8 @@
// tag number can only be determined after all options have been parsed.
void AdjustExtensionRangesWithMaxEndNumber(DescriptorProto* message) {
const bool is_message_set = IsMessageSetWireFormatMessage(*message);
- const int max_extension_number = is_message_set ?
- kint32max :
- FieldDescriptor::kMaxNumber + 1;
+ const int max_extension_number =
+ is_message_set ? kint32max : FieldDescriptor::kMaxNumber + 1;
for (int i = 0; i < message->extension_range_size(); ++i) {
if (message->extension_range(i).end() == kMaxRangeSentinel) {
message->mutable_extension_range(i)->set_end(max_extension_number);
@@ -717,9 +726,8 @@
// tag number can only be determined after all options have been parsed.
void AdjustReservedRangesWithMaxEndNumber(DescriptorProto* message) {
const bool is_message_set = IsMessageSetWireFormatMessage(*message);
- const int max_field_number = is_message_set ?
- kint32max :
- FieldDescriptor::kMaxNumber + 1;
+ const int max_field_number =
+ is_message_set ? kint32max : FieldDescriptor::kMaxNumber + 1;
for (int i = 0; i < message->reserved_range_size(); ++i) {
if (message->reserved_range(i).end() == kMaxRangeSentinel) {
message->mutable_reserved_range(i)->set_end(max_field_number);
@@ -784,34 +792,28 @@
LocationRecorder location(message_location,
DescriptorProto::kExtensionFieldNumber);
return ParseExtend(message->mutable_extension(),
- message->mutable_nested_type(),
- message_location,
- DescriptorProto::kNestedTypeFieldNumber,
- location, containing_file);
+ message->mutable_nested_type(), message_location,
+ DescriptorProto::kNestedTypeFieldNumber, location,
+ containing_file);
} else if (LookingAt("option")) {
LocationRecorder location(message_location,
DescriptorProto::kOptionsFieldNumber);
- return ParseOption(message->mutable_options(), location,
- containing_file, OPTION_STATEMENT);
+ return ParseOption(message->mutable_options(), location, containing_file,
+ OPTION_STATEMENT);
} else if (LookingAt("oneof")) {
int oneof_index = message->oneof_decl_size();
- LocationRecorder oneof_location(message_location,
- DescriptorProto::kOneofDeclFieldNumber,
- oneof_index);
+ LocationRecorder oneof_location(
+ message_location, DescriptorProto::kOneofDeclFieldNumber, oneof_index);
- return ParseOneof(message->add_oneof_decl(), message,
- oneof_index, oneof_location, message_location,
- containing_file);
+ return ParseOneof(message->add_oneof_decl(), message, oneof_index,
+ oneof_location, message_location, containing_file);
} else {
LocationRecorder location(message_location,
DescriptorProto::kFieldFieldNumber,
message->field_size());
- return ParseMessageField(message->add_field(),
- message->mutable_nested_type(),
- message_location,
- DescriptorProto::kNestedTypeFieldNumber,
- location,
- containing_file);
+ return ParseMessageField(
+ message->add_field(), message->mutable_nested_type(), message_location,
+ DescriptorProto::kNestedTypeFieldNumber, location, containing_file);
}
}
@@ -839,13 +841,11 @@
return ParseMessageFieldNoLabel(field, messages, parent_location,
location_field_number_for_nested_type,
- field_location,
- containing_file);
+ field_location, containing_file);
}
bool Parser::ParseMessageFieldNoLabel(
- FieldDescriptorProto* field,
- RepeatedPtrField<DescriptorProto>* messages,
+ FieldDescriptorProto* field, RepeatedPtrField<DescriptorProto>* messages,
const LocationRecorder& parent_location,
int location_field_number_for_nested_type,
const LocationRecorder& field_location,
@@ -936,8 +936,8 @@
{
LocationRecorder location(field_location,
FieldDescriptorProto::kNumberFieldNumber);
- location.RecordLegacyLocation(
- field, DescriptorPool::ErrorCollector::NUMBER);
+ location.RecordLegacyLocation(field,
+ DescriptorPool::ErrorCollector::NUMBER);
int number;
DO(ConsumeInteger(&number, "Expected field number."));
field->set_number(number);
@@ -964,8 +964,8 @@
DescriptorProto::kNameFieldNumber);
location.StartAt(name_token);
location.EndAt(name_token);
- location.RecordLegacyLocation(
- group, DescriptorPool::ErrorCollector::NAME);
+ location.RecordLegacyLocation(group,
+ DescriptorPool::ErrorCollector::NAME);
}
// The field's type_name also comes from the name. Confusing!
@@ -981,7 +981,7 @@
// not use groups; it should use nested messages.
if (group->name()[0] < 'A' || 'Z' < group->name()[0]) {
AddError(name_token.line, name_token.column,
- "Group names must start with a capital letter.");
+ "Group names must start with a capital letter.");
}
LowerString(field->mutable_name());
@@ -1057,12 +1057,12 @@
option.name(0).name_part() == "enforce_utf8" &&
!option.name(0).is_extension()) {
if (key_field->type() == FieldDescriptorProto::TYPE_STRING) {
- key_field->mutable_options()->add_uninterpreted_option()
- ->CopyFrom(option);
+ key_field->mutable_options()->add_uninterpreted_option()->CopyFrom(
+ option);
}
if (value_field->type() == FieldDescriptorProto::TYPE_STRING) {
- value_field->mutable_options()->add_uninterpreted_option()
- ->CopyFrom(option);
+ value_field->mutable_options()->add_uninterpreted_option()->CopyFrom(
+ option);
}
}
}
@@ -1088,8 +1088,8 @@
// Like default value, this "json_name" is not an actual option.
DO(ParseJsonName(field, field_location, containing_file));
} else {
- DO(ParseOption(field->mutable_options(), location,
- containing_file, OPTION_ASSIGNMENT));
+ DO(ParseOption(field->mutable_options(), location, containing_file,
+ OPTION_ASSIGNMENT));
}
} while (TryConsume(","));
@@ -1098,8 +1098,7 @@
}
bool Parser::ParseDefaultAssignment(
- FieldDescriptorProto* field,
- const LocationRecorder& field_location,
+ FieldDescriptorProto* field, const LocationRecorder& field_location,
const FileDescriptorProto* containing_file) {
if (field->has_default_value()) {
AddError("Already set option \"default\".");
@@ -1111,8 +1110,8 @@
LocationRecorder location(field_location,
FieldDescriptorProto::kDefaultValueFieldNumber);
- location.RecordLegacyLocation(
- field, DescriptorPool::ErrorCollector::DEFAULT_VALUE);
+ location.RecordLegacyLocation(field,
+ DescriptorPool::ErrorCollector::DEFAULT_VALUE);
std::string* default_value = field->mutable_default_value();
if (!field->has_type()) {
@@ -1211,7 +1210,8 @@
// Note: When file opton java_string_check_utf8 is true, if a
// non-string representation (eg byte[]) is later supported, it must
// be checked for UTF-8-ness.
- DO(ConsumeString(default_value, "Expected string for field default "
+ DO(ConsumeString(default_value,
+ "Expected string for field default "
"value."));
break;
@@ -1221,8 +1221,9 @@
break;
case FieldDescriptorProto::TYPE_ENUM:
- DO(ConsumeIdentifier(default_value, "Expected enum identifier for field "
- "default value."));
+ DO(ConsumeIdentifier(default_value,
+ "Expected enum identifier for field "
+ "default value."));
break;
case FieldDescriptorProto::TYPE_MESSAGE:
@@ -1234,34 +1235,37 @@
return true;
}
-bool Parser::ParseJsonName(
- FieldDescriptorProto* field,
- const LocationRecorder& field_location,
- const FileDescriptorProto* containing_file) {
+bool Parser::ParseJsonName(FieldDescriptorProto* field,
+ const LocationRecorder& field_location,
+ const FileDescriptorProto* containing_file) {
if (field->has_json_name()) {
AddError("Already set option \"json_name\".");
field->clear_json_name();
}
+ LocationRecorder location(field_location,
+ FieldDescriptorProto::kJsonNameFieldNumber);
+ location.RecordLegacyLocation(field,
+ DescriptorPool::ErrorCollector::OPTION_NAME);
+
DO(Consume("json_name"));
DO(Consume("="));
- LocationRecorder location(field_location,
- FieldDescriptorProto::kJsonNameFieldNumber);
- location.RecordLegacyLocation(
+ LocationRecorder value_location(location);
+ value_location.RecordLegacyLocation(
field, DescriptorPool::ErrorCollector::OPTION_VALUE);
+
DO(ConsumeString(field->mutable_json_name(),
"Expected string for JSON name."));
return true;
}
-
bool Parser::ParseOptionNamePart(UninterpretedOption* uninterpreted_option,
const LocationRecorder& part_location,
const FileDescriptorProto* containing_file) {
UninterpretedOption::NamePart* name = uninterpreted_option->add_name();
std::string identifier; // We parse identifiers into this string.
- if (LookingAt("(")) { // This is an extension.
+ if (LookingAt("(")) { // This is an extension.
DO(Consume("("));
{
@@ -1325,8 +1329,8 @@
const FileDescriptorProto* containing_file,
OptionStyle style) {
// Create an entry in the uninterpreted_option field.
- const FieldDescriptor* uninterpreted_option_field = options->GetDescriptor()->
- FindFieldByName("uninterpreted_option");
+ const FieldDescriptor* uninterpreted_option_field =
+ options->GetDescriptor()->FindFieldByName("uninterpreted_option");
GOOGLE_CHECK(uninterpreted_option_field != NULL)
<< "No field named \"uninterpreted_option\" in the Options proto.";
@@ -1340,9 +1344,9 @@
DO(Consume("option"));
}
- UninterpretedOption* uninterpreted_option = down_cast<UninterpretedOption*>(
- options->GetReflection()->AddMessage(options,
- uninterpreted_option_field));
+ UninterpretedOption* uninterpreted_option =
+ down_cast<UninterpretedOption*>(options->GetReflection()->AddMessage(
+ options, uninterpreted_option_field));
// Parse dot-separated name.
{
@@ -1473,8 +1477,8 @@
message->extension_range_size());
DescriptorProto::ExtensionRange* range = message->add_extension_range();
- location.RecordLegacyLocation(
- range, DescriptorPool::ErrorCollector::NUMBER);
+ location.RecordLegacyLocation(range,
+ DescriptorPool::ErrorCollector::NUMBER);
int start, end;
io::Tokenizer::Token start_token;
@@ -1539,8 +1543,8 @@
// Then copy the extension range options to all of the other ranges we've
// parsed.
for (int i = old_range_size + 1; i < message->extension_range_size(); i++) {
- message->mutable_extension_range(i)->mutable_options()
- ->CopyFrom(*options);
+ message->mutable_extension_range(i)->mutable_options()->CopyFrom(
+ *options);
}
// and copy source locations to the other ranges, too
for (int i = old_range_size; i < message->extension_range_size(); i++) {
@@ -1604,9 +1608,8 @@
LocationRecorder start_location(
location, DescriptorProto::ReservedRange::kStartFieldNumber);
start_token = input_->current();
- DO(ConsumeInteger(&start, (first ?
- "Expected field name or number range." :
- "Expected field number range.")));
+ DO(ConsumeInteger(&start, (first ? "Expected field name or number range."
+ : "Expected field number range.")));
}
if (TryConsume("to")) {
@@ -1683,9 +1686,9 @@
LocationRecorder start_location(
location, EnumDescriptorProto::EnumReservedRange::kStartFieldNumber);
start_token = input_->current();
- DO(ConsumeSignedInteger(&start, (first ?
- "Expected enum value or number range." :
- "Expected enum number range.")));
+ DO(ConsumeSignedInteger(&start,
+ (first ? "Expected enum value or number range."
+ : "Expected enum number range.")));
}
if (TryConsume("to")) {
@@ -1761,8 +1764,7 @@
field->set_extendee(extendee);
if (!ParseMessageField(field, messages, parent_location,
- location_field_number_for_nested_type,
- location,
+ location_field_number_for_nested_type, location,
containing_file)) {
// This statement failed to parse. Skip it, but keep looping to parse
// other statements.
@@ -1774,8 +1776,7 @@
}
bool Parser::ParseOneof(OneofDescriptorProto* oneof_decl,
- DescriptorProto* containing_type,
- int oneof_index,
+ DescriptorProto* containing_type, int oneof_index,
const LocationRecorder& oneof_location,
const LocationRecorder& containing_type_location,
const FileDescriptorProto* containing_file) {
@@ -1807,11 +1808,11 @@
// Print a nice error if the user accidentally tries to place a label
// on an individual member of a oneof.
- if (LookingAt("required") ||
- LookingAt("optional") ||
+ if (LookingAt("required") || LookingAt("optional") ||
LookingAt("repeated")) {
- AddError("Fields in oneofs must not have labels (required / optional "
- "/ repeated).");
+ AddError(
+ "Fields in oneofs must not have labels (required / optional "
+ "/ repeated).");
// We can continue parsing here because we understand what the user
// meant. The error report will still make parsing fail overall.
input_->Next();
@@ -1825,12 +1826,10 @@
field->set_label(FieldDescriptorProto::LABEL_OPTIONAL);
field->set_oneof_index(oneof_index);
- if (!ParseMessageFieldNoLabel(field,
- containing_type->mutable_nested_type(),
+ if (!ParseMessageFieldNoLabel(field, containing_type->mutable_nested_type(),
containing_type_location,
DescriptorProto::kNestedTypeFieldNumber,
- field_location,
- containing_file)) {
+ field_location, containing_file)) {
// This statement failed to parse. Skip it, but keep looping to parse
// other statements.
SkipStatement();
@@ -1851,8 +1850,8 @@
{
LocationRecorder location(enum_location,
EnumDescriptorProto::kNameFieldNumber);
- location.RecordLegacyLocation(
- enum_type, DescriptorPool::ErrorCollector::NAME);
+ location.RecordLegacyLocation(enum_type,
+ DescriptorPool::ErrorCollector::NAME);
DO(ConsumeIdentifier(enum_type->mutable_name(), "Expected enum name."));
}
@@ -1893,13 +1892,14 @@
} else if (LookingAt("option")) {
LocationRecorder location(enum_location,
EnumDescriptorProto::kOptionsFieldNumber);
- return ParseOption(enum_type->mutable_options(), location,
- containing_file, OPTION_STATEMENT);
+ return ParseOption(enum_type->mutable_options(), location, containing_file,
+ OPTION_STATEMENT);
} else if (LookingAt("reserved")) {
return ParseReserved(enum_type, enum_location);
} else {
LocationRecorder location(enum_location,
- EnumDescriptorProto::kValueFieldNumber, enum_type->value_size());
+ EnumDescriptorProto::kValueFieldNumber,
+ enum_type->value_size());
return ParseEnumConstant(enum_type->add_value(), location, containing_file);
}
}
@@ -1911,8 +1911,8 @@
{
LocationRecorder location(enum_value_location,
EnumValueDescriptorProto::kNameFieldNumber);
- location.RecordLegacyLocation(
- enum_value, DescriptorPool::ErrorCollector::NAME);
+ location.RecordLegacyLocation(enum_value,
+ DescriptorPool::ErrorCollector::NAME);
DO(ConsumeIdentifier(enum_value->mutable_name(),
"Expected enum constant name."));
}
@@ -1921,10 +1921,10 @@
// Parse value.
{
- LocationRecorder location(
- enum_value_location, EnumValueDescriptorProto::kNumberFieldNumber);
- location.RecordLegacyLocation(
- enum_value, DescriptorPool::ErrorCollector::NUMBER);
+ LocationRecorder location(enum_value_location,
+ EnumValueDescriptorProto::kNumberFieldNumber);
+ location.RecordLegacyLocation(enum_value,
+ DescriptorPool::ErrorCollector::NUMBER);
int number;
DO(ConsumeSignedInteger(&number, "Expected integer."));
@@ -1945,14 +1945,14 @@
const FileDescriptorProto* containing_file) {
if (!LookingAt("[")) return true;
- LocationRecorder location(
- enum_value_location, EnumValueDescriptorProto::kOptionsFieldNumber);
+ LocationRecorder location(enum_value_location,
+ EnumValueDescriptorProto::kOptionsFieldNumber);
DO(Consume("["));
do {
- DO(ParseOption(value->mutable_options(), location,
- containing_file, OPTION_ASSIGNMENT));
+ DO(ParseOption(value->mutable_options(), location, containing_file,
+ OPTION_ASSIGNMENT));
} while (TryConsume(","));
DO(Consume("]"));
@@ -1963,16 +1963,15 @@
// Services
bool Parser::ParseServiceDefinition(
- ServiceDescriptorProto* service,
- const LocationRecorder& service_location,
+ ServiceDescriptorProto* service, const LocationRecorder& service_location,
const FileDescriptorProto* containing_file) {
DO(Consume("service"));
{
LocationRecorder location(service_location,
ServiceDescriptorProto::kNameFieldNumber);
- location.RecordLegacyLocation(
- service, DescriptorPool::ErrorCollector::NAME);
+ location.RecordLegacyLocation(service,
+ DescriptorPool::ErrorCollector::NAME);
DO(ConsumeIdentifier(service->mutable_name(), "Expected service name."));
}
@@ -2008,13 +2007,14 @@
// empty statement; ignore
return true;
} else if (LookingAt("option")) {
- LocationRecorder location(
- service_location, ServiceDescriptorProto::kOptionsFieldNumber);
- return ParseOption(service->mutable_options(), location,
- containing_file, OPTION_STATEMENT);
+ LocationRecorder location(service_location,
+ ServiceDescriptorProto::kOptionsFieldNumber);
+ return ParseOption(service->mutable_options(), location, containing_file,
+ OPTION_STATEMENT);
} else {
LocationRecorder location(service_location,
- ServiceDescriptorProto::kMethodFieldNumber, service->method_size());
+ ServiceDescriptorProto::kMethodFieldNumber,
+ service->method_size());
return ParseServiceMethod(service->add_method(), location, containing_file);
}
}
@@ -2027,8 +2027,7 @@
{
LocationRecorder location(method_location,
MethodDescriptorProto::kNameFieldNumber);
- location.RecordLegacyLocation(
- method, DescriptorPool::ErrorCollector::NAME);
+ location.RecordLegacyLocation(method, DescriptorPool::ErrorCollector::NAME);
DO(ConsumeIdentifier(method->mutable_name(), "Expected method name."));
}
@@ -2038,16 +2037,16 @@
if (LookingAt("stream")) {
LocationRecorder location(
method_location, MethodDescriptorProto::kClientStreamingFieldNumber);
- location.RecordLegacyLocation(
- method, DescriptorPool::ErrorCollector::OTHER);
+ location.RecordLegacyLocation(method,
+ DescriptorPool::ErrorCollector::OTHER);
method->set_client_streaming(true);
DO(Consume("stream"));
}
LocationRecorder location(method_location,
MethodDescriptorProto::kInputTypeFieldNumber);
- location.RecordLegacyLocation(
- method, DescriptorPool::ErrorCollector::INPUT_TYPE);
+ location.RecordLegacyLocation(method,
+ DescriptorPool::ErrorCollector::INPUT_TYPE);
DO(ParseUserDefinedType(method->mutable_input_type()));
}
DO(Consume(")"));
@@ -2059,16 +2058,16 @@
if (LookingAt("stream")) {
LocationRecorder location(
method_location, MethodDescriptorProto::kServerStreamingFieldNumber);
- location.RecordLegacyLocation(
- method, DescriptorPool::ErrorCollector::OTHER);
+ location.RecordLegacyLocation(method,
+ DescriptorPool::ErrorCollector::OTHER);
DO(Consume("stream"));
method->set_server_streaming(true);
}
LocationRecorder location(method_location,
MethodDescriptorProto::kOutputTypeFieldNumber);
- location.RecordLegacyLocation(
- method, DescriptorPool::ErrorCollector::OUTPUT_TYPE);
+ location.RecordLegacyLocation(method,
+ DescriptorPool::ErrorCollector::OUTPUT_TYPE);
DO(ParseUserDefinedType(method->mutable_output_type()));
}
DO(Consume(")"));
@@ -2101,10 +2100,9 @@
if (TryConsumeEndOfDeclaration(";", NULL)) {
// empty statement; ignore
} else {
- LocationRecorder location(parent_location,
- optionsFieldNumber);
- if (!ParseOption(mutable_options, location,
- containing_file, OPTION_STATEMENT)) {
+ LocationRecorder location(parent_location, optionsFieldNumber);
+ if (!ParseOption(mutable_options, location, containing_file,
+ OPTION_STATEMENT)) {
// This statement failed to parse. Skip it, but keep looping to
// parse other statements.
SkipStatement();
@@ -2231,12 +2229,17 @@
LocationRecorder weak_location(
root_location, FileDescriptorProto::kWeakDependencyFieldNumber,
weak_dependency->size());
+ weak_location.RecordLegacyImportLocation(containing_file, "weak");
DO(Consume("weak"));
*weak_dependency->Add() = dependency->size();
}
- DO(ConsumeString(dependency->Add(),
+ string import_file;
+ DO(ConsumeString(&import_file,
"Expected a string naming the file to import."));
+ *dependency->Add() = import_file;
+ location.RecordLegacyImportLocation(containing_file, import_file);
+
DO(ConsumeEndOfDeclaration(";", &location));
return true;
@@ -2249,16 +2252,32 @@
bool SourceLocationTable::Find(
const Message* descriptor,
- DescriptorPool::ErrorCollector::ErrorLocation location,
- int* line, int* column) const {
+ DescriptorPool::ErrorCollector::ErrorLocation location, int* line,
+ int* column) const {
const std::pair<int, int>* result =
FindOrNull(location_map_, std::make_pair(descriptor, location));
if (result == NULL) {
- *line = -1;
+ *line = -1;
*column = 0;
return false;
} else {
- *line = result->first;
+ *line = result->first;
+ *column = result->second;
+ return true;
+ }
+}
+
+bool SourceLocationTable::FindImport(const Message* descriptor,
+ const string& name, int* line,
+ int* column) const {
+ const std::pair<int, int>* result =
+ FindOrNull(import_location_map_, std::make_pair(descriptor, name));
+ if (result == nullptr) {
+ *line = -1;
+ *column = 0;
+ return false;
+ } else {
+ *line = result->first;
*column = result->second;
return true;
}
@@ -2266,16 +2285,20 @@
void SourceLocationTable::Add(
const Message* descriptor,
- DescriptorPool::ErrorCollector::ErrorLocation location,
- int line, int column) {
+ DescriptorPool::ErrorCollector::ErrorLocation location, int line,
+ int column) {
location_map_[std::make_pair(descriptor, location)] =
std::make_pair(line, column);
}
-void SourceLocationTable::Clear() {
- location_map_.clear();
+void SourceLocationTable::AddImport(const Message* descriptor,
+ const string& name, int line, int column) {
+ import_location_map_[std::make_pair(descriptor, name)] =
+ std::make_pair(line, column);
}
+void SourceLocationTable::Clear() { location_map_.clear(); }
+
} // namespace compiler
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/compiler/parser.h b/src/google/protobuf/compiler/parser.h
index a5cb7a8..6ec19a1 100644
--- a/src/google/protobuf/compiler/parser.h
+++ b/src/google/protobuf/compiler/parser.h
@@ -188,13 +188,13 @@
// have been passed around by const reference, for no particularly good
// reason. We should probably go through and change them all to mutable
// pointer to make this more intuitive.
- bool TryConsumeEndOfDeclaration(
- const char* text, const LocationRecorder* location);
- bool TryConsumeEndOfDeclarationFinishScope(
- const char* text, const LocationRecorder* location);
+ bool TryConsumeEndOfDeclaration(const char* text,
+ const LocationRecorder* location);
+ bool TryConsumeEndOfDeclarationFinishScope(const char* text,
+ const LocationRecorder* location);
- bool ConsumeEndOfDeclaration(
- const char* text, const LocationRecorder* location);
+ bool ConsumeEndOfDeclaration(const char* text,
+ const LocationRecorder* location);
// -----------------------------------------------------------------
// Error logging helpers
@@ -254,8 +254,11 @@
// was passed to RecordSourceLocationsTo(), if any. SourceLocationTable
// is an older way of keeping track of source locations which is still
// used in some places.
- void RecordLegacyLocation(const Message* descriptor,
+ void RecordLegacyLocation(
+ const Message* descriptor,
DescriptorPool::ErrorCollector::ErrorLocation location);
+ void RecordLegacyImportLocation(const Message* descriptor,
+ const string& name);
// Returns the number of path components in the recorder's current location.
int CurrentPathSize() const;
@@ -402,8 +405,7 @@
// oneof_decl->label() since it will have had to parse the label before it
// knew it was parsing a oneof.
bool ParseOneof(OneofDescriptorProto* oneof_decl,
- DescriptorProto* containing_type,
- int oneof_index,
+ DescriptorProto* containing_type, int oneof_index,
const LocationRecorder& oneof_location,
const LocationRecorder& containing_type_location,
const FileDescriptorProto* containing_file);
@@ -467,8 +469,7 @@
// Parse a single option name/value pair, e.g. "ctype = CORD". The name
// identifies a field of the given Message, and the value of that field
// is set to the parsed value.
- bool ParseOption(Message* options,
- const LocationRecorder& options_location,
+ bool ParseOption(Message* options, const LocationRecorder& options_location,
const FileDescriptorProto* containing_file,
OptionStyle style);
@@ -560,22 +561,29 @@
// location" in the ErrorCollector interface). Returns true if found, false
// otherwise.
bool Find(const Message* descriptor,
- DescriptorPool::ErrorCollector::ErrorLocation location,
- int* line, int* column) const;
+ DescriptorPool::ErrorCollector::ErrorLocation location, int* line,
+ int* column) const;
+ bool FindImport(const Message* descriptor, const string& name, int* line,
+ int* column) const;
// Adds a location to the table.
void Add(const Message* descriptor,
- DescriptorPool::ErrorCollector::ErrorLocation location,
- int line, int column);
+ DescriptorPool::ErrorCollector::ErrorLocation location, int line,
+ int column);
+ void AddImport(const Message* descriptor, const string& name, int line,
+ int column);
// Clears the contents of the table.
void Clear();
private:
typedef std::map<
- std::pair<const Message*, DescriptorPool::ErrorCollector::ErrorLocation>,
- std::pair<int, int> > LocationMap;
+ std::pair<const Message*, DescriptorPool::ErrorCollector::ErrorLocation>,
+ std::pair<int, int> >
+ LocationMap;
LocationMap location_map_;
+ std::map<std::pair<const Message*, string>, std::pair<int, int> >
+ import_location_map_;
};
} // namespace compiler
diff --git a/src/google/protobuf/compiler/parser_unittest.cc b/src/google/protobuf/compiler/parser_unittest.cc
index 98280f8..cf7a85c 100644
--- a/src/google/protobuf/compiler/parser_unittest.cc
+++ b/src/google/protobuf/compiler/parser_unittest.cc
@@ -32,10 +32,10 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
-#include <memory>
-#include <vector>
#include <algorithm>
#include <map>
+#include <memory>
+#include <vector>
#include <google/protobuf/compiler/parser.h>
@@ -69,8 +69,7 @@
// implements ErrorCollector ---------------------------------------
void AddError(int line, int column, const std::string& message) {
- strings::SubstituteAndAppend(&text_, "$0:$1: $2\n",
- line, column, message);
+ strings::SubstituteAndAppend(&text_, "$0:$1: $2\n", line, column, message);
}
};
@@ -78,8 +77,8 @@
public:
MockValidationErrorCollector(const SourceLocationTable& source_locations,
io::ErrorCollector* wrapped_collector)
- : source_locations_(source_locations),
- wrapped_collector_(wrapped_collector) {}
+ : source_locations_(source_locations),
+ wrapped_collector_(wrapped_collector) {}
~MockValidationErrorCollector() {}
// implements ErrorCollector ---------------------------------------
@@ -87,7 +86,11 @@
const Message* descriptor, ErrorLocation location,
const std::string& message) {
int line, column;
- source_locations_.Find(descriptor, location, &line, &column);
+ if (location == DescriptorPool::ErrorCollector::IMPORT) {
+ source_locations_.FindImport(descriptor, element_name, &line, &column);
+ } else {
+ source_locations_.Find(descriptor, location, &line, &column);
+ }
wrapped_collector_->AddError(line, column, message);
}
@@ -98,8 +101,7 @@
class ParserTest : public testing::Test {
protected:
- ParserTest()
- : require_syntax_identifier_(false) {}
+ ParserTest() : require_syntax_identifier_(false) {}
// Set up the parser to parse the given text.
void SetupParser(const char* text) {
@@ -164,10 +166,10 @@
EXPECT_EQ(io::Tokenizer::TYPE_END, input_->current().type);
ASSERT_EQ("", error_collector_.text_);
- MockValidationErrorCollector validation_error_collector(
- source_locations, &error_collector_);
+ MockValidationErrorCollector validation_error_collector(source_locations,
+ &error_collector_);
EXPECT_TRUE(pool_.BuildFileCollectingErrors(
- file, &validation_error_collector) == NULL);
+ file, &validation_error_collector) == NULL);
EXPECT_EQ(expected_errors, error_collector_.text_);
}
@@ -184,9 +186,9 @@
TEST_F(ParserTest, StopAfterSyntaxIdentifier) {
SetupParser(
- "// blah\n"
- "syntax = \"foobar\";\n"
- "this line will not be parsed\n");
+ "// blah\n"
+ "syntax = \"foobar\";\n"
+ "this line will not be parsed\n");
parser_->SetStopAfterSyntaxIdentifier(true);
EXPECT_TRUE(parser_->Parse(input_.get(), NULL));
EXPECT_EQ("", error_collector_.text_);
@@ -195,8 +197,8 @@
TEST_F(ParserTest, StopAfterOmittedSyntaxIdentifier) {
SetupParser(
- "// blah\n"
- "this line will not be parsed\n");
+ "// blah\n"
+ "this line will not be parsed\n");
parser_->SetStopAfterSyntaxIdentifier(true);
EXPECT_TRUE(parser_->Parse(input_.get(), NULL));
EXPECT_EQ("", error_collector_.text_);
@@ -205,8 +207,8 @@
TEST_F(ParserTest, StopAfterSyntaxIdentifierWithErrors) {
SetupParser(
- "// blah\n"
- "syntax = error;\n");
+ "// blah\n"
+ "syntax = error;\n");
parser_->SetStopAfterSyntaxIdentifier(true);
EXPECT_FALSE(parser_->Parse(input_.get(), NULL));
EXPECT_EQ("1:9: Expected syntax identifier.\n", error_collector_.text_);
@@ -217,8 +219,8 @@
FileDescriptorProto file;
CaptureTestStderr();
EXPECT_TRUE(parser_->Parse(input_.get(), &file));
- EXPECT_TRUE(
- GetCapturedTestStderr().find("No syntax specified") != string::npos);
+ EXPECT_TRUE(GetCapturedTestStderr().find("No syntax specified") !=
+ string::npos);
}
// ===================================================================
@@ -226,22 +228,25 @@
typedef ParserTest ParseMessageTest;
TEST_F(ParseMessageTest, IgnoreBOM) {
- char input[] = " message TestMessage {\n"
+ char input[] =
+ " message TestMessage {\n"
" required int32 foo = 1;\n"
"}\n";
// Set UTF-8 BOM.
input[0] = (char)0xEF;
input[1] = (char)0xBB;
input[2] = (char)0xBF;
- ExpectParsesTo(input,
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
- "}");
+ ExpectParsesTo(
+ input,
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
+ "}");
}
TEST_F(ParseMessageTest, BOMError) {
- char input[] = " message TestMessage {\n"
+ char input[] =
+ " message TestMessage {\n"
" required int32 foo = 1;\n"
"}\n";
input[0] = (char)0xEF;
@@ -253,590 +258,634 @@
TEST_F(ParseMessageTest, SimpleMessage) {
ExpectParsesTo(
- "message TestMessage {\n"
- " required int32 foo = 1;\n"
- "}\n",
+ "message TestMessage {\n"
+ " required int32 foo = 1;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
+ "}");
}
TEST_F(ParseMessageTest, ImplicitSyntaxIdentifier) {
require_syntax_identifier_ = false;
ExpectParsesTo(
- "message TestMessage {\n"
- " required int32 foo = 1;\n"
- "}\n",
+ "message TestMessage {\n"
+ " required int32 foo = 1;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
+ "}");
EXPECT_EQ("proto2", parser_->GetSyntaxIdentifier());
}
TEST_F(ParseMessageTest, ExplicitSyntaxIdentifier) {
ExpectParsesTo(
- "syntax = \"proto2\";\n"
- "message TestMessage {\n"
- " required int32 foo = 1;\n"
- "}\n",
+ "syntax = \"proto2\";\n"
+ "message TestMessage {\n"
+ " required int32 foo = 1;\n"
+ "}\n",
- "syntax: 'proto2' "
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
- "}");
+ "syntax: 'proto2' "
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
+ "}");
EXPECT_EQ("proto2", parser_->GetSyntaxIdentifier());
}
TEST_F(ParseMessageTest, ExplicitRequiredSyntaxIdentifier) {
require_syntax_identifier_ = true;
ExpectParsesTo(
- "syntax = \"proto2\";\n"
- "message TestMessage {\n"
- " required int32 foo = 1;\n"
- "}\n",
+ "syntax = \"proto2\";\n"
+ "message TestMessage {\n"
+ " required int32 foo = 1;\n"
+ "}\n",
- "syntax: 'proto2' "
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
- "}");
+ "syntax: 'proto2' "
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
+ "}");
EXPECT_EQ("proto2", parser_->GetSyntaxIdentifier());
}
TEST_F(ParseMessageTest, SimpleFields) {
ExpectParsesTo(
- "message TestMessage {\n"
- " required int32 foo = 15;\n"
- " optional int32 bar = 34;\n"
- " repeated int32 baz = 3;\n"
- "}\n",
+ "message TestMessage {\n"
+ " required int32 foo = 15;\n"
+ " optional int32 bar = 34;\n"
+ " repeated int32 baz = 3;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:15 }"
- " field { name:\"bar\" label:LABEL_OPTIONAL type:TYPE_INT32 number:34 }"
- " field { name:\"baz\" label:LABEL_REPEATED type:TYPE_INT32 number:3 }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:15 }"
+ " field { name:\"bar\" label:LABEL_OPTIONAL type:TYPE_INT32 number:34 }"
+ " field { name:\"baz\" label:LABEL_REPEATED type:TYPE_INT32 number:3 }"
+ "}");
}
TEST_F(ParseMessageTest, PrimitiveFieldTypes) {
ExpectParsesTo(
- "message TestMessage {\n"
- " required int32 foo = 1;\n"
- " required int64 foo = 1;\n"
- " required uint32 foo = 1;\n"
- " required uint64 foo = 1;\n"
- " required sint32 foo = 1;\n"
- " required sint64 foo = 1;\n"
- " required fixed32 foo = 1;\n"
- " required fixed64 foo = 1;\n"
- " required sfixed32 foo = 1;\n"
- " required sfixed64 foo = 1;\n"
- " required float foo = 1;\n"
- " required double foo = 1;\n"
- " required string foo = 1;\n"
- " required bytes foo = 1;\n"
- " required bool foo = 1;\n"
- "}\n",
+ "message TestMessage {\n"
+ " required int32 foo = 1;\n"
+ " required int64 foo = 1;\n"
+ " required uint32 foo = 1;\n"
+ " required uint64 foo = 1;\n"
+ " required sint32 foo = 1;\n"
+ " required sint64 foo = 1;\n"
+ " required fixed32 foo = 1;\n"
+ " required fixed64 foo = 1;\n"
+ " required sfixed32 foo = 1;\n"
+ " required sfixed64 foo = 1;\n"
+ " required float foo = 1;\n"
+ " required double foo = 1;\n"
+ " required string foo = 1;\n"
+ " required bytes foo = 1;\n"
+ " required bool foo = 1;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT64 number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_UINT32 number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_UINT64 number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_SINT32 number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_SINT64 number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_FIXED32 number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_FIXED64 number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_SFIXED32 number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_SFIXED64 number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_FLOAT number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_DOUBLE number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_STRING number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_BYTES number:1 }"
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_BOOL number:1 }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT64 number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_UINT32 number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_UINT64 number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_SINT32 number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_SINT64 number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_FIXED32 number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_FIXED64 number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_SFIXED32 number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_SFIXED64 number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_FLOAT number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_DOUBLE number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_STRING number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_BYTES number:1 "
+ "}"
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_BOOL number:1 "
+ "}"
+ "}");
}
TEST_F(ParseMessageTest, FieldDefaults) {
ExpectParsesTo(
- "message TestMessage {\n"
- " required int32 foo = 1 [default= 1 ];\n"
- " required int32 foo = 1 [default= -2 ];\n"
- " required int64 foo = 1 [default= 3 ];\n"
- " required int64 foo = 1 [default= -4 ];\n"
- " required uint32 foo = 1 [default= 5 ];\n"
- " required uint64 foo = 1 [default= 6 ];\n"
- " required float foo = 1 [default= 7.5];\n"
- " required float foo = 1 [default= -8.5];\n"
- " required float foo = 1 [default= 9 ];\n"
- " required double foo = 1 [default= 10.5];\n"
- " required double foo = 1 [default=-11.5];\n"
- " required double foo = 1 [default= 12 ];\n"
- " required double foo = 1 [default= inf ];\n"
- " required double foo = 1 [default=-inf ];\n"
- " required double foo = 1 [default= nan ];\n"
- " required string foo = 1 [default='13\\001'];\n"
- " required string foo = 1 [default='a' \"b\" \n \"c\"];\n"
- " required bytes foo = 1 [default='14\\002'];\n"
- " required bytes foo = 1 [default='a' \"b\" \n 'c'];\n"
- " required bool foo = 1 [default=true ];\n"
- " required Foo foo = 1 [default=FOO ];\n"
+ "message TestMessage {\n"
+ " required int32 foo = 1 [default= 1 ];\n"
+ " required int32 foo = 1 [default= -2 ];\n"
+ " required int64 foo = 1 [default= 3 ];\n"
+ " required int64 foo = 1 [default= -4 ];\n"
+ " required uint32 foo = 1 [default= 5 ];\n"
+ " required uint64 foo = 1 [default= 6 ];\n"
+ " required float foo = 1 [default= 7.5];\n"
+ " required float foo = 1 [default= -8.5];\n"
+ " required float foo = 1 [default= 9 ];\n"
+ " required double foo = 1 [default= 10.5];\n"
+ " required double foo = 1 [default=-11.5];\n"
+ " required double foo = 1 [default= 12 ];\n"
+ " required double foo = 1 [default= inf ];\n"
+ " required double foo = 1 [default=-inf ];\n"
+ " required double foo = 1 [default= nan ];\n"
+ " required string foo = 1 [default='13\\001'];\n"
+ " required string foo = 1 [default='a' \"b\" \n \"c\"];\n"
+ " required bytes foo = 1 [default='14\\002'];\n"
+ " required bytes foo = 1 [default='a' \"b\" \n 'c'];\n"
+ " required bool foo = 1 [default=true ];\n"
+ " required Foo foo = 1 [default=FOO ];\n"
- " required int32 foo = 1 [default= 0x7FFFFFFF];\n"
- " required int32 foo = 1 [default=-0x80000000];\n"
- " required uint32 foo = 1 [default= 0xFFFFFFFF];\n"
- " required int64 foo = 1 [default= 0x7FFFFFFFFFFFFFFF];\n"
- " required int64 foo = 1 [default=-0x8000000000000000];\n"
- " required uint64 foo = 1 [default= 0xFFFFFFFFFFFFFFFF];\n"
- " required double foo = 1 [default= 0xabcd];\n"
- "}\n",
+ " required int32 foo = 1 [default= 0x7FFFFFFF];\n"
+ " required int32 foo = 1 [default=-0x80000000];\n"
+ " required uint32 foo = 1 [default= 0xFFFFFFFF];\n"
+ " required int64 foo = 1 [default= 0x7FFFFFFFFFFFFFFF];\n"
+ " required int64 foo = 1 [default=-0x8000000000000000];\n"
+ " required uint64 foo = 1 [default= 0xFFFFFFFFFFFFFFFF];\n"
+ " required double foo = 1 [default= 0xabcd];\n"
+ "}\n",
#define ETC "name:\"foo\" label:LABEL_REQUIRED number:1"
- "message_type {"
- " name: \"TestMessage\""
- " field { type:TYPE_INT32 default_value:\"1\" " ETC " }"
- " field { type:TYPE_INT32 default_value:\"-2\" " ETC " }"
- " field { type:TYPE_INT64 default_value:\"3\" " ETC " }"
- " field { type:TYPE_INT64 default_value:\"-4\" " ETC " }"
- " field { type:TYPE_UINT32 default_value:\"5\" " ETC " }"
- " field { type:TYPE_UINT64 default_value:\"6\" " ETC " }"
- " field { type:TYPE_FLOAT default_value:\"7.5\" " ETC " }"
- " field { type:TYPE_FLOAT default_value:\"-8.5\" " ETC " }"
- " field { type:TYPE_FLOAT default_value:\"9\" " ETC " }"
- " field { type:TYPE_DOUBLE default_value:\"10.5\" " ETC " }"
- " field { type:TYPE_DOUBLE default_value:\"-11.5\" " ETC " }"
- " field { type:TYPE_DOUBLE default_value:\"12\" " ETC " }"
- " field { type:TYPE_DOUBLE default_value:\"inf\" " ETC " }"
- " field { type:TYPE_DOUBLE default_value:\"-inf\" " ETC " }"
- " field { type:TYPE_DOUBLE default_value:\"nan\" " ETC " }"
- " field { type:TYPE_STRING default_value:\"13\\001\" " ETC " }"
- " field { type:TYPE_STRING default_value:\"abc\" " ETC " }"
- " field { type:TYPE_BYTES default_value:\"14\\\\002\" " ETC " }"
- " field { type:TYPE_BYTES default_value:\"abc\" " ETC " }"
- " field { type:TYPE_BOOL default_value:\"true\" " ETC " }"
- " field { type_name:\"Foo\" default_value:\"FOO\" " ETC " }"
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { type:TYPE_INT32 default_value:\"1\" " ETC
+ " }"
+ " field { type:TYPE_INT32 default_value:\"-2\" " ETC
+ " }"
+ " field { type:TYPE_INT64 default_value:\"3\" " ETC
+ " }"
+ " field { type:TYPE_INT64 default_value:\"-4\" " ETC
+ " }"
+ " field { type:TYPE_UINT32 default_value:\"5\" " ETC
+ " }"
+ " field { type:TYPE_UINT64 default_value:\"6\" " ETC
+ " }"
+ " field { type:TYPE_FLOAT default_value:\"7.5\" " ETC
+ " }"
+ " field { type:TYPE_FLOAT default_value:\"-8.5\" " ETC
+ " }"
+ " field { type:TYPE_FLOAT default_value:\"9\" " ETC
+ " }"
+ " field { type:TYPE_DOUBLE default_value:\"10.5\" " ETC
+ " }"
+ " field { type:TYPE_DOUBLE default_value:\"-11.5\" " ETC
+ " }"
+ " field { type:TYPE_DOUBLE default_value:\"12\" " ETC
+ " }"
+ " field { type:TYPE_DOUBLE default_value:\"inf\" " ETC
+ " }"
+ " field { type:TYPE_DOUBLE default_value:\"-inf\" " ETC
+ " }"
+ " field { type:TYPE_DOUBLE default_value:\"nan\" " ETC
+ " }"
+ " field { type:TYPE_STRING default_value:\"13\\001\" " ETC
+ " }"
+ " field { type:TYPE_STRING default_value:\"abc\" " ETC
+ " }"
+ " field { type:TYPE_BYTES default_value:\"14\\\\002\" " ETC
+ " }"
+ " field { type:TYPE_BYTES default_value:\"abc\" " ETC
+ " }"
+ " field { type:TYPE_BOOL default_value:\"true\" " ETC
+ " }"
+ " field { type_name:\"Foo\" default_value:\"FOO\" " ETC
+ " }"
- " field {"
- " type:TYPE_INT32 default_value:\"2147483647\" " ETC
- " }"
- " field {"
- " type:TYPE_INT32 default_value:\"-2147483648\" " ETC
- " }"
- " field {"
- " type:TYPE_UINT32 default_value:\"4294967295\" " ETC
- " }"
- " field {"
- " type:TYPE_INT64 default_value:\"9223372036854775807\" " ETC
- " }"
- " field {"
- " type:TYPE_INT64 default_value:\"-9223372036854775808\" " ETC
- " }"
- " field {"
- " type:TYPE_UINT64 default_value:\"18446744073709551615\" " ETC
- " }"
- " field {"
- " type:TYPE_DOUBLE default_value:\"43981\" " ETC
- " }"
- "}");
+ " field {"
+ " type:TYPE_INT32 default_value:\"2147483647\" " ETC
+ " }"
+ " field {"
+ " type:TYPE_INT32 default_value:\"-2147483648\" " ETC
+ " }"
+ " field {"
+ " type:TYPE_UINT32 default_value:\"4294967295\" " ETC
+ " }"
+ " field {"
+ " type:TYPE_INT64 default_value:\"9223372036854775807\" " ETC
+ " }"
+ " field {"
+ " type:TYPE_INT64 default_value:\"-9223372036854775808\" " ETC
+ " }"
+ " field {"
+ " type:TYPE_UINT64 default_value:\"18446744073709551615\" " ETC
+ " }"
+ " field {"
+ " type:TYPE_DOUBLE default_value:\"43981\" " ETC
+ " }"
+ "}");
#undef ETC
}
TEST_F(ParseMessageTest, FieldJsonName) {
ExpectParsesTo(
- "message TestMessage {\n"
- " optional string foo = 1 [json_name = \"@type\"];\n"
- "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " field {\n"
- " name: \"foo\" label: LABEL_OPTIONAL type: TYPE_STRING number: 1"
- " json_name: \"@type\"\n"
- " }\n"
- "}\n");
+ "message TestMessage {\n"
+ " optional string foo = 1 [json_name = \"@type\"];\n"
+ "}\n",
+ "message_type {"
+ " name: \"TestMessage\""
+ " field {\n"
+ " name: \"foo\" label: LABEL_OPTIONAL type: TYPE_STRING number: 1"
+ " json_name: \"@type\"\n"
+ " }\n"
+ "}\n");
}
TEST_F(ParseMessageTest, FieldOptions) {
ExpectParsesTo(
- "message TestMessage {\n"
- " optional string foo = 1\n"
- " [ctype=CORD, (foo)=7, foo.(.bar.baz).qux.quux.(corge)=-33, \n"
- " (quux)=\"x\040y\", (baz.qux)=hey];\n"
- "}\n",
+ "message TestMessage {\n"
+ " optional string foo = 1\n"
+ " [ctype=CORD, (foo)=7, foo.(.bar.baz).qux.quux.(corge)=-33, \n"
+ " (quux)=\"x\040y\", (baz.qux)=hey];\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " field { name: \"foo\" label: LABEL_OPTIONAL type: TYPE_STRING number: 1"
- " options { uninterpreted_option: { name { name_part: \"ctype\" "
- " is_extension: false } "
- " identifier_value: \"CORD\" }"
- " uninterpreted_option: { name { name_part: \"foo\" "
- " is_extension: true } "
- " positive_int_value: 7 }"
- " uninterpreted_option: { name { name_part: \"foo\" "
- " is_extension: false } "
- " name { name_part: \".bar.baz\""
- " is_extension: true } "
- " name { name_part: \"qux\" "
- " is_extension: false } "
- " name { name_part: \"quux\" "
- " is_extension: false } "
- " name { name_part: \"corge\" "
- " is_extension: true } "
- " negative_int_value: -33 }"
- " uninterpreted_option: { name { name_part: \"quux\" "
- " is_extension: true } "
- " string_value: \"x y\" }"
- " uninterpreted_option: { name { name_part: \"baz.qux\" "
- " is_extension: true } "
- " identifier_value: \"hey\" }"
- " }"
- " }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name: \"foo\" label: LABEL_OPTIONAL type: TYPE_STRING number: "
+ "1"
+ " options { uninterpreted_option: { name { name_part: \"ctype\" "
+ " is_extension: false "
+ "} "
+ " identifier_value: \"CORD\" "
+ "}"
+ " uninterpreted_option: { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " positive_int_value: 7 }"
+ " uninterpreted_option: { name { name_part: \"foo\" "
+ " is_extension: false "
+ "} "
+ " name { name_part: "
+ "\".bar.baz\""
+ " is_extension: true } "
+ " name { name_part: \"qux\" "
+ " is_extension: false "
+ "} "
+ " name { name_part: \"quux\" "
+ " is_extension: false "
+ "} "
+ " name { name_part: \"corge\" "
+ " is_extension: true } "
+ " negative_int_value: -33 }"
+ " uninterpreted_option: { name { name_part: \"quux\" "
+ " is_extension: true } "
+ " string_value: \"x y\" }"
+ " uninterpreted_option: { name { name_part: "
+ "\"baz.qux\" "
+ " is_extension: true } "
+ " identifier_value: \"hey\" }"
+ " }"
+ " }"
+ "}");
}
TEST_F(ParseMessageTest, Oneof) {
ExpectParsesTo(
- "message TestMessage {\n"
- " oneof foo {\n"
- " int32 a = 1;\n"
- " string b = 2;\n"
- " TestMessage c = 3;\n"
- " group D = 4 { optional int32 i = 5; }\n"
- " }\n"
- "}\n",
+ "message TestMessage {\n"
+ " oneof foo {\n"
+ " int32 a = 1;\n"
+ " string b = 2;\n"
+ " TestMessage c = 3;\n"
+ " group D = 4 { optional int32 i = 5; }\n"
+ " }\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"a\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 "
- " oneof_index:0 }"
- " field { name:\"b\" label:LABEL_OPTIONAL type:TYPE_STRING number:2 "
- " oneof_index:0 }"
- " field { name:\"c\" label:LABEL_OPTIONAL type_name:\"TestMessage\" "
- " number:3 oneof_index:0 }"
- " field { name:\"d\" label:LABEL_OPTIONAL type:TYPE_GROUP "
- " type_name:\"D\" number:4 oneof_index:0 }"
- " oneof_decl {"
- " name: \"foo\""
- " }"
- " nested_type {"
- " name: \"D\""
- " field { name:\"i\" label:LABEL_OPTIONAL type:TYPE_INT32 number:5 }"
- " }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"a\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 "
+ " oneof_index:0 }"
+ " field { name:\"b\" label:LABEL_OPTIONAL type:TYPE_STRING number:2 "
+ " oneof_index:0 }"
+ " field { name:\"c\" label:LABEL_OPTIONAL type_name:\"TestMessage\" "
+ " number:3 oneof_index:0 }"
+ " field { name:\"d\" label:LABEL_OPTIONAL type:TYPE_GROUP "
+ " type_name:\"D\" number:4 oneof_index:0 }"
+ " oneof_decl {"
+ " name: \"foo\""
+ " }"
+ " nested_type {"
+ " name: \"D\""
+ " field { name:\"i\" label:LABEL_OPTIONAL type:TYPE_INT32 number:5 }"
+ " }"
+ "}");
}
TEST_F(ParseMessageTest, MultipleOneofs) {
ExpectParsesTo(
- "message TestMessage {\n"
- " oneof foo {\n"
- " int32 a = 1;\n"
- " string b = 2;\n"
- " }\n"
- " oneof bar {\n"
- " int32 c = 3;\n"
- " string d = 4;\n"
- " }\n"
- "}\n",
+ "message TestMessage {\n"
+ " oneof foo {\n"
+ " int32 a = 1;\n"
+ " string b = 2;\n"
+ " }\n"
+ " oneof bar {\n"
+ " int32 c = 3;\n"
+ " string d = 4;\n"
+ " }\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"a\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 "
- " oneof_index:0 }"
- " field { name:\"b\" label:LABEL_OPTIONAL type:TYPE_STRING number:2 "
- " oneof_index:0 }"
- " field { name:\"c\" label:LABEL_OPTIONAL type:TYPE_INT32 number:3 "
- " oneof_index:1 }"
- " field { name:\"d\" label:LABEL_OPTIONAL type:TYPE_STRING number:4 "
- " oneof_index:1 }"
- " oneof_decl {"
- " name: \"foo\""
- " }"
- " oneof_decl {"
- " name: \"bar\""
- " }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"a\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 "
+ " oneof_index:0 }"
+ " field { name:\"b\" label:LABEL_OPTIONAL type:TYPE_STRING number:2 "
+ " oneof_index:0 }"
+ " field { name:\"c\" label:LABEL_OPTIONAL type:TYPE_INT32 number:3 "
+ " oneof_index:1 }"
+ " field { name:\"d\" label:LABEL_OPTIONAL type:TYPE_STRING number:4 "
+ " oneof_index:1 }"
+ " oneof_decl {"
+ " name: \"foo\""
+ " }"
+ " oneof_decl {"
+ " name: \"bar\""
+ " }"
+ "}");
}
TEST_F(ParseMessageTest, Maps) {
ExpectParsesTo(
- "message TestMessage {\n"
- " map<int32, string> primitive_type_map = 1;\n"
- " map<KeyType, ValueType> composite_type_map = 2;\n"
- "}\n",
+ "message TestMessage {\n"
+ " map<int32, string> primitive_type_map = 1;\n"
+ " map<KeyType, ValueType> composite_type_map = 2;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " nested_type {"
- " name: \"PrimitiveTypeMapEntry\""
- " field { "
- " name: \"key\" number: 1 label:LABEL_OPTIONAL"
- " type:TYPE_INT32"
- " }"
- " field { "
- " name: \"value\" number: 2 label:LABEL_OPTIONAL"
- " type:TYPE_STRING"
- " }"
- " options { map_entry: true }"
- " }"
- " nested_type {"
- " name: \"CompositeTypeMapEntry\""
- " field { "
- " name: \"key\" number: 1 label:LABEL_OPTIONAL"
- " type_name: \"KeyType\""
- " }"
- " field { "
- " name: \"value\" number: 2 label:LABEL_OPTIONAL"
- " type_name: \"ValueType\""
- " }"
- " options { map_entry: true }"
- " }"
- " field {"
- " name: \"primitive_type_map\""
- " label: LABEL_REPEATED"
- " type_name: \"PrimitiveTypeMapEntry\""
- " number: 1"
- " }"
- " field {"
- " name: \"composite_type_map\""
- " label: LABEL_REPEATED"
- " type_name: \"CompositeTypeMapEntry\""
- " number: 2"
- " }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " nested_type {"
+ " name: \"PrimitiveTypeMapEntry\""
+ " field { "
+ " name: \"key\" number: 1 label:LABEL_OPTIONAL"
+ " type:TYPE_INT32"
+ " }"
+ " field { "
+ " name: \"value\" number: 2 label:LABEL_OPTIONAL"
+ " type:TYPE_STRING"
+ " }"
+ " options { map_entry: true }"
+ " }"
+ " nested_type {"
+ " name: \"CompositeTypeMapEntry\""
+ " field { "
+ " name: \"key\" number: 1 label:LABEL_OPTIONAL"
+ " type_name: \"KeyType\""
+ " }"
+ " field { "
+ " name: \"value\" number: 2 label:LABEL_OPTIONAL"
+ " type_name: \"ValueType\""
+ " }"
+ " options { map_entry: true }"
+ " }"
+ " field {"
+ " name: \"primitive_type_map\""
+ " label: LABEL_REPEATED"
+ " type_name: \"PrimitiveTypeMapEntry\""
+ " number: 1"
+ " }"
+ " field {"
+ " name: \"composite_type_map\""
+ " label: LABEL_REPEATED"
+ " type_name: \"CompositeTypeMapEntry\""
+ " number: 2"
+ " }"
+ "}");
}
TEST_F(ParseMessageTest, Group) {
ExpectParsesTo(
- "message TestMessage {\n"
- " optional group TestGroup = 1 {};\n"
- "}\n",
+ "message TestMessage {\n"
+ " optional group TestGroup = 1 {};\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " nested_type { name: \"TestGroup\" }"
- " field { name:\"testgroup\" label:LABEL_OPTIONAL number:1"
- " type:TYPE_GROUP type_name: \"TestGroup\" }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " nested_type { name: \"TestGroup\" }"
+ " field { name:\"testgroup\" label:LABEL_OPTIONAL number:1"
+ " type:TYPE_GROUP type_name: \"TestGroup\" }"
+ "}");
}
TEST_F(ParseMessageTest, NestedMessage) {
ExpectParsesTo(
- "message TestMessage {\n"
- " message Nested {}\n"
- " optional Nested test_nested = 1;\n"
- "}\n",
+ "message TestMessage {\n"
+ " message Nested {}\n"
+ " optional Nested test_nested = 1;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " nested_type { name: \"Nested\" }"
- " field { name:\"test_nested\" label:LABEL_OPTIONAL number:1"
- " type_name: \"Nested\" }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " nested_type { name: \"Nested\" }"
+ " field { name:\"test_nested\" label:LABEL_OPTIONAL number:1"
+ " type_name: \"Nested\" }"
+ "}");
}
TEST_F(ParseMessageTest, NestedEnum) {
ExpectParsesTo(
- "message TestMessage {\n"
- " enum NestedEnum {}\n"
- " optional NestedEnum test_enum = 1;\n"
- "}\n",
+ "message TestMessage {\n"
+ " enum NestedEnum {}\n"
+ " optional NestedEnum test_enum = 1;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " enum_type { name: \"NestedEnum\" }"
- " field { name:\"test_enum\" label:LABEL_OPTIONAL number:1"
- " type_name: \"NestedEnum\" }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " enum_type { name: \"NestedEnum\" }"
+ " field { name:\"test_enum\" label:LABEL_OPTIONAL number:1"
+ " type_name: \"NestedEnum\" }"
+ "}");
}
TEST_F(ParseMessageTest, ReservedRange) {
ExpectParsesTo(
- "message TestMessage {\n"
- " required int32 foo = 1;\n"
- " reserved 2, 15, 9 to 11, 3, 20 to max;\n"
- "}\n",
+ "message TestMessage {\n"
+ " required int32 foo = 1;\n"
+ " reserved 2, 15, 9 to 11, 3, 20 to max;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
- " reserved_range { start:2 end:3 }"
- " reserved_range { start:15 end:16 }"
- " reserved_range { start:9 end:12 }"
- " reserved_range { start:3 end:4 }"
- " reserved_range { start:20 end:536870912 }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"foo\" label:LABEL_REQUIRED type:TYPE_INT32 number:1 }"
+ " reserved_range { start:2 end:3 }"
+ " reserved_range { start:15 end:16 }"
+ " reserved_range { start:9 end:12 }"
+ " reserved_range { start:3 end:4 }"
+ " reserved_range { start:20 end:536870912 }"
+ "}");
}
TEST_F(ParseMessageTest, ReservedRangeOnMessageSet) {
ExpectParsesTo(
- "message TestMessage {\n"
- " option message_set_wire_format = true;\n"
- " reserved 20 to max;\n"
- "}\n",
+ "message TestMessage {\n"
+ " option message_set_wire_format = true;\n"
+ " reserved 20 to max;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " options {"
- " uninterpreted_option {"
- " name {"
- " name_part: \"message_set_wire_format\""
- " is_extension: false"
- " }"
- " identifier_value: \"true\""
- " }"
- " }"
- " reserved_range { start:20 end:2147483647 }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " options {"
+ " uninterpreted_option {"
+ " name {"
+ " name_part: \"message_set_wire_format\""
+ " is_extension: false"
+ " }"
+ " identifier_value: \"true\""
+ " }"
+ " }"
+ " reserved_range { start:20 end:2147483647 }"
+ "}");
}
TEST_F(ParseMessageTest, ReservedNames) {
ExpectParsesTo(
- "message TestMessage {\n"
- " reserved \"foo\", \"bar\";\n"
- "}\n",
+ "message TestMessage {\n"
+ " reserved \"foo\", \"bar\";\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " reserved_name: \"foo\""
- " reserved_name: \"bar\""
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " reserved_name: \"foo\""
+ " reserved_name: \"bar\""
+ "}");
}
TEST_F(ParseMessageTest, ExtensionRange) {
ExpectParsesTo(
- "message TestMessage {\n"
- " extensions 10 to 19;\n"
- " extensions 30 to max;\n"
- "}\n",
+ "message TestMessage {\n"
+ " extensions 10 to 19;\n"
+ " extensions 30 to max;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " extension_range { start:10 end:20 }"
- " extension_range { start:30 end:536870912 }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " extension_range { start:10 end:20 }"
+ " extension_range { start:30 end:536870912 }"
+ "}");
}
TEST_F(ParseMessageTest, ExtensionRangeWithOptions) {
ExpectParsesTo(
- "message TestMessage {\n"
- " extensions 10 to 19 [(i) = 5];\n"
- "}\n",
+ "message TestMessage {\n"
+ " extensions 10 to 19 [(i) = 5];\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " extension_range {"
- " start:10"
- " end:20"
- " options {"
- " uninterpreted_option {"
- " name {"
- " name_part: \"i\""
- " is_extension: true"
- " }"
- " positive_int_value: 5"
- " }"
- " }"
- " }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " extension_range {"
+ " start:10"
+ " end:20"
+ " options {"
+ " uninterpreted_option {"
+ " name {"
+ " name_part: \"i\""
+ " is_extension: true"
+ " }"
+ " positive_int_value: 5"
+ " }"
+ " }"
+ " }"
+ "}");
}
TEST_F(ParseMessageTest, CompoundExtensionRange) {
ExpectParsesTo(
- "message TestMessage {\n"
- " extensions 2, 15, 9 to 11, 100 to max, 3;\n"
- "}\n",
+ "message TestMessage {\n"
+ " extensions 2, 15, 9 to 11, 100 to max, 3;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " extension_range { start:2 end:3 }"
- " extension_range { start:15 end:16 }"
- " extension_range { start:9 end:12 }"
- " extension_range { start:100 end:536870912 }"
- " extension_range { start:3 end:4 }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " extension_range { start:2 end:3 }"
+ " extension_range { start:15 end:16 }"
+ " extension_range { start:9 end:12 }"
+ " extension_range { start:100 end:536870912 }"
+ " extension_range { start:3 end:4 }"
+ "}");
}
TEST_F(ParseMessageTest, CompoundExtensionRangeWithOptions) {
ExpectParsesTo(
- "message TestMessage {\n"
- " extensions 2, 15, 9 to 11, 100 to max, 3 [(i) = 5];\n"
- "}\n",
+ "message TestMessage {\n"
+ " extensions 2, 15, 9 to 11, 100 to max, 3 [(i) = 5];\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " extension_range {"
- " start:2"
- " end:3"
- " options {"
- " uninterpreted_option {"
- " name {"
- " name_part: \"i\""
- " is_extension: true"
- " }"
- " positive_int_value: 5"
- " }"
- " }"
- " }"
- " extension_range {"
- " start:15"
- " end:16"
- " options {"
- " uninterpreted_option {"
- " name {"
- " name_part: \"i\""
- " is_extension: true"
- " }"
- " positive_int_value: 5"
- " }"
- " }"
- " }"
- " extension_range {"
- " start:9"
- " end:12"
- " options {"
- " uninterpreted_option {"
- " name {"
- " name_part: \"i\""
- " is_extension: true"
- " }"
- " positive_int_value: 5"
- " }"
- " }"
- " }"
- " extension_range {"
- " start:100"
- " end:536870912"
- " options {"
- " uninterpreted_option {"
- " name {"
- " name_part: \"i\""
- " is_extension: true"
- " }"
- " positive_int_value: 5"
- " }"
- " }"
- " }"
- " extension_range {"
- " start:3"
- " end:4"
- " options {"
- " uninterpreted_option {"
- " name {"
- " name_part: \"i\""
- " is_extension: true"
- " }"
- " positive_int_value: 5"
- " }"
- " }"
- " }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " extension_range {"
+ " start:2"
+ " end:3"
+ " options {"
+ " uninterpreted_option {"
+ " name {"
+ " name_part: \"i\""
+ " is_extension: true"
+ " }"
+ " positive_int_value: 5"
+ " }"
+ " }"
+ " }"
+ " extension_range {"
+ " start:15"
+ " end:16"
+ " options {"
+ " uninterpreted_option {"
+ " name {"
+ " name_part: \"i\""
+ " is_extension: true"
+ " }"
+ " positive_int_value: 5"
+ " }"
+ " }"
+ " }"
+ " extension_range {"
+ " start:9"
+ " end:12"
+ " options {"
+ " uninterpreted_option {"
+ " name {"
+ " name_part: \"i\""
+ " is_extension: true"
+ " }"
+ " positive_int_value: 5"
+ " }"
+ " }"
+ " }"
+ " extension_range {"
+ " start:100"
+ " end:536870912"
+ " options {"
+ " uninterpreted_option {"
+ " name {"
+ " name_part: \"i\""
+ " is_extension: true"
+ " }"
+ " positive_int_value: 5"
+ " }"
+ " }"
+ " }"
+ " extension_range {"
+ " start:3"
+ " end:4"
+ " options {"
+ " uninterpreted_option {"
+ " name {"
+ " name_part: \"i\""
+ " is_extension: true"
+ " }"
+ " positive_int_value: 5"
+ " }"
+ " }"
+ " }"
+ "}");
}
TEST_F(ParseMessageTest, LargerMaxForMessageSetWireFormatMessages) {
@@ -844,77 +893,79 @@
// extension numbers, as the numbers are not encoded as int32 field values
// rather than tags.
ExpectParsesTo(
- "message TestMessage {\n"
- " extensions 4 to max;\n"
- " option message_set_wire_format = true;\n"
- "}\n",
+ "message TestMessage {\n"
+ " extensions 4 to max;\n"
+ " option message_set_wire_format = true;\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " extension_range { start:4 end: 0x7fffffff }"
- " options {\n"
- " uninterpreted_option { \n"
- " name {\n"
- " name_part: \"message_set_wire_format\"\n"
- " is_extension: false\n"
- " }\n"
- " identifier_value: \"true\"\n"
- " }\n"
- " }\n"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " extension_range { start:4 end: 0x7fffffff }"
+ " options {\n"
+ " uninterpreted_option { \n"
+ " name {\n"
+ " name_part: \"message_set_wire_format\"\n"
+ " is_extension: false\n"
+ " }\n"
+ " identifier_value: \"true\"\n"
+ " }\n"
+ " }\n"
+ "}");
}
TEST_F(ParseMessageTest, Extensions) {
ExpectParsesTo(
- "extend Extendee1 { optional int32 foo = 12; }\n"
- "extend Extendee2 { repeated TestMessage bar = 22; }\n",
+ "extend Extendee1 { optional int32 foo = 12; }\n"
+ "extend Extendee2 { repeated TestMessage bar = 22; }\n",
- "extension { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:12"
- " extendee: \"Extendee1\" } "
- "extension { name:\"bar\" label:LABEL_REPEATED number:22"
- " type_name:\"TestMessage\" extendee: \"Extendee2\" }");
+ "extension { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:12"
+ " extendee: \"Extendee1\" } "
+ "extension { name:\"bar\" label:LABEL_REPEATED number:22"
+ " type_name:\"TestMessage\" extendee: \"Extendee2\" }");
}
TEST_F(ParseMessageTest, ExtensionsInMessageScope) {
ExpectParsesTo(
- "message TestMessage {\n"
- " extend Extendee1 { optional int32 foo = 12; }\n"
- " extend Extendee2 { repeated TestMessage bar = 22; }\n"
- "}\n",
+ "message TestMessage {\n"
+ " extend Extendee1 { optional int32 foo = 12; }\n"
+ " extend Extendee2 { repeated TestMessage bar = 22; }\n"
+ "}\n",
- "message_type {"
- " name: \"TestMessage\""
- " extension { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:12"
- " extendee: \"Extendee1\" }"
- " extension { name:\"bar\" label:LABEL_REPEATED number:22"
- " type_name:\"TestMessage\" extendee: \"Extendee2\" }"
- "}");
+ "message_type {"
+ " name: \"TestMessage\""
+ " extension { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "number:12"
+ " extendee: \"Extendee1\" }"
+ " extension { name:\"bar\" label:LABEL_REPEATED number:22"
+ " type_name:\"TestMessage\" extendee: \"Extendee2\" }"
+ "}");
}
TEST_F(ParseMessageTest, MultipleExtensionsOneExtendee) {
ExpectParsesTo(
- "extend Extendee1 {\n"
- " optional int32 foo = 12;\n"
- " repeated TestMessage bar = 22;\n"
- "}\n",
+ "extend Extendee1 {\n"
+ " optional int32 foo = 12;\n"
+ " repeated TestMessage bar = 22;\n"
+ "}\n",
- "extension { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:12"
- " extendee: \"Extendee1\" } "
- "extension { name:\"bar\" label:LABEL_REPEATED number:22"
- " type_name:\"TestMessage\" extendee: \"Extendee1\" }");
+ "extension { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:12"
+ " extendee: \"Extendee1\" } "
+ "extension { name:\"bar\" label:LABEL_REPEATED number:22"
+ " type_name:\"TestMessage\" extendee: \"Extendee1\" }");
}
TEST_F(ParseMessageTest, OptionalLabelProto3) {
ExpectParsesTo(
- "syntax = \"proto3\";\n"
- "message TestMessage {\n"
- " int32 foo = 1;\n"
- "}\n",
+ "syntax = \"proto3\";\n"
+ "message TestMessage {\n"
+ " int32 foo = 1;\n"
+ "}\n",
- "syntax: \"proto3\" "
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 } }");
+ "syntax: \"proto3\" "
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 } "
+ "}");
}
// ===================================================================
@@ -923,108 +974,109 @@
TEST_F(ParseEnumTest, SimpleEnum) {
ExpectParsesTo(
- "enum TestEnum {\n"
- " FOO = 0;\n"
- "}\n",
+ "enum TestEnum {\n"
+ " FOO = 0;\n"
+ "}\n",
- "enum_type {"
- " name: \"TestEnum\""
- " value { name:\"FOO\" number:0 }"
- "}");
+ "enum_type {"
+ " name: \"TestEnum\""
+ " value { name:\"FOO\" number:0 }"
+ "}");
}
TEST_F(ParseEnumTest, Values) {
ExpectParsesTo(
- "enum TestEnum {\n"
- " FOO = 13;\n"
- " BAR = -10;\n"
- " BAZ = 500;\n"
- " HEX_MAX = 0x7FFFFFFF;\n"
- " HEX_MIN = -0x80000000;\n"
- " INT_MAX = 2147483647;\n"
- " INT_MIN = -2147483648;\n"
- "}\n",
+ "enum TestEnum {\n"
+ " FOO = 13;\n"
+ " BAR = -10;\n"
+ " BAZ = 500;\n"
+ " HEX_MAX = 0x7FFFFFFF;\n"
+ " HEX_MIN = -0x80000000;\n"
+ " INT_MAX = 2147483647;\n"
+ " INT_MIN = -2147483648;\n"
+ "}\n",
- "enum_type {"
- " name: \"TestEnum\""
- " value { name:\"FOO\" number:13 }"
- " value { name:\"BAR\" number:-10 }"
- " value { name:\"BAZ\" number:500 }"
- " value { name:\"HEX_MAX\" number:2147483647 }"
- " value { name:\"HEX_MIN\" number:-2147483648 }"
- " value { name:\"INT_MAX\" number:2147483647 }"
- " value { name:\"INT_MIN\" number:-2147483648 }"
- "}");
+ "enum_type {"
+ " name: \"TestEnum\""
+ " value { name:\"FOO\" number:13 }"
+ " value { name:\"BAR\" number:-10 }"
+ " value { name:\"BAZ\" number:500 }"
+ " value { name:\"HEX_MAX\" number:2147483647 }"
+ " value { name:\"HEX_MIN\" number:-2147483648 }"
+ " value { name:\"INT_MAX\" number:2147483647 }"
+ " value { name:\"INT_MIN\" number:-2147483648 }"
+ "}");
}
TEST_F(ParseEnumTest, ValueOptions) {
ExpectParsesTo(
- "enum TestEnum {\n"
- " FOO = 13;\n"
- " BAR = -10 [ (something.text) = 'abc' ];\n"
- " BAZ = 500 [ (something.text) = 'def', other = 1 ];\n"
- "}\n",
+ "enum TestEnum {\n"
+ " FOO = 13;\n"
+ " BAR = -10 [ (something.text) = 'abc' ];\n"
+ " BAZ = 500 [ (something.text) = 'def', other = 1 ];\n"
+ "}\n",
- "enum_type {"
- " name: \"TestEnum\""
- " value { name: \"FOO\" number: 13 }"
- " value { name: \"BAR\" number: -10 "
- " options { "
- " uninterpreted_option { "
- " name { name_part: \"something.text\" is_extension: true } "
- " string_value: \"abc\" "
- " } "
- " } "
- " } "
- " value { name: \"BAZ\" number: 500 "
- " options { "
- " uninterpreted_option { "
- " name { name_part: \"something.text\" is_extension: true } "
- " string_value: \"def\" "
- " } "
- " uninterpreted_option { "
- " name { name_part: \"other\" is_extension: false } "
- " positive_int_value: 1 "
- " } "
- " } "
- " } "
- "}");
+ "enum_type {"
+ " name: \"TestEnum\""
+ " value { name: \"FOO\" number: 13 }"
+ " value { name: \"BAR\" number: -10 "
+ " options { "
+ " uninterpreted_option { "
+ " name { name_part: \"something.text\" is_extension: true } "
+ " string_value: \"abc\" "
+ " } "
+ " } "
+ " } "
+ " value { name: \"BAZ\" number: 500 "
+ " options { "
+ " uninterpreted_option { "
+ " name { name_part: \"something.text\" is_extension: true } "
+ " string_value: \"def\" "
+ " } "
+ " uninterpreted_option { "
+ " name { name_part: \"other\" is_extension: false } "
+ " positive_int_value: 1 "
+ " } "
+ " } "
+ " } "
+ "}");
}
TEST_F(ParseEnumTest, ReservedRange) {
ExpectParsesTo(
- "enum TestEnum {\n"
- " FOO = 0;\n"
- " reserved -2147483648, -6 to -4, -1 to 1, 2, 15, 9 to 11, 3, 20 to max;\n"
- "}\n",
+ "enum TestEnum {\n"
+ " FOO = 0;\n"
+ " reserved -2147483648, -6 to -4, -1 to 1, 2, 15, 9 to 11, 3, 20 to "
+ "max;\n"
+ "}\n",
- "enum_type {"
- " name: \"TestEnum\""
- " value { name:\"FOO\" number:0 }"
- " reserved_range { start:-2147483648 end:-2147483648 }"
- " reserved_range { start:-6 end:-4 }"
- " reserved_range { start:-1 end:1 }"
- " reserved_range { start:2 end:2 }"
- " reserved_range { start:15 end:15 }"
- " reserved_range { start:9 end:11 }"
- " reserved_range { start:3 end:3 }"
- " reserved_range { start:20 end:2147483647 }"
- "}");
+ "enum_type {"
+ " name: \"TestEnum\""
+ " value { name:\"FOO\" number:0 }"
+ " reserved_range { start:-2147483648 end:-2147483648 }"
+ " reserved_range { start:-6 end:-4 }"
+ " reserved_range { start:-1 end:1 }"
+ " reserved_range { start:2 end:2 }"
+ " reserved_range { start:15 end:15 }"
+ " reserved_range { start:9 end:11 }"
+ " reserved_range { start:3 end:3 }"
+ " reserved_range { start:20 end:2147483647 }"
+ "}");
}
TEST_F(ParseEnumTest, ReservedNames) {
ExpectParsesTo(
- "enum TestEnum {\n"
- " FOO = 0;\n"
- " reserved \"foo\", \"bar\";\n"
- "}\n",
+ "enum TestEnum {\n"
+ " FOO = 0;\n"
+ " reserved \"foo\", \"bar\";\n"
+ "}\n",
- "enum_type {"
- " name: \"TestEnum\""
- " value { name:\"FOO\" number:0 }"
- " reserved_name: \"foo\""
- " reserved_name: \"bar\""
- "}");
+ "enum_type {"
+ " name: \"TestEnum\""
+ " value { name:\"FOO\" number:0 }"
+ " reserved_name: \"foo\""
+ " reserved_name: \"bar\""
+ "}");
}
// ===================================================================
@@ -1033,80 +1085,76 @@
TEST_F(ParseServiceTest, SimpleService) {
ExpectParsesTo(
- "service TestService {\n"
- " rpc Foo(In) returns (Out);\n"
- "}\n",
+ "service TestService {\n"
+ " rpc Foo(In) returns (Out);\n"
+ "}\n",
- "service {"
- " name: \"TestService\""
- " method { name:\"Foo\" input_type:\"In\" output_type:\"Out\" }"
- "}");
+ "service {"
+ " name: \"TestService\""
+ " method { name:\"Foo\" input_type:\"In\" output_type:\"Out\" }"
+ "}");
}
TEST_F(ParseServiceTest, MethodsAndStreams) {
ExpectParsesTo(
- "service TestService {\n"
- " rpc Foo(In1) returns (Out1);\n"
- " rpc Bar(In2) returns (Out2);\n"
- " rpc Baz(In3) returns (Out3);\n"
- "}\n",
+ "service TestService {\n"
+ " rpc Foo(In1) returns (Out1);\n"
+ " rpc Bar(In2) returns (Out2);\n"
+ " rpc Baz(In3) returns (Out3);\n"
+ "}\n",
- "service {"
- " name: \"TestService\""
- " method { name:\"Foo\" input_type:\"In1\" output_type:\"Out1\" }"
- " method { name:\"Bar\" input_type:\"In2\" output_type:\"Out2\" }"
- " method { name:\"Baz\" input_type:\"In3\" output_type:\"Out3\" }"
- "}");
+ "service {"
+ " name: \"TestService\""
+ " method { name:\"Foo\" input_type:\"In1\" output_type:\"Out1\" }"
+ " method { name:\"Bar\" input_type:\"In2\" output_type:\"Out2\" }"
+ " method { name:\"Baz\" input_type:\"In3\" output_type:\"Out3\" }"
+ "}");
}
-
// ===================================================================
// imports and packages
typedef ParserTest ParseMiscTest;
TEST_F(ParseMiscTest, ParseImport) {
- ExpectParsesTo(
- "import \"foo/bar/baz.proto\";\n",
- "dependency: \"foo/bar/baz.proto\"");
+ ExpectParsesTo("import \"foo/bar/baz.proto\";\n",
+ "dependency: \"foo/bar/baz.proto\"");
}
TEST_F(ParseMiscTest, ParseMultipleImports) {
ExpectParsesTo(
- "import \"foo.proto\";\n"
- "import \"bar.proto\";\n"
- "import \"baz.proto\";\n",
- "dependency: \"foo.proto\""
- "dependency: \"bar.proto\""
- "dependency: \"baz.proto\"");
+ "import \"foo.proto\";\n"
+ "import \"bar.proto\";\n"
+ "import \"baz.proto\";\n",
+ "dependency: \"foo.proto\""
+ "dependency: \"bar.proto\""
+ "dependency: \"baz.proto\"");
}
TEST_F(ParseMiscTest, ParsePublicImports) {
ExpectParsesTo(
- "import \"foo.proto\";\n"
- "import public \"bar.proto\";\n"
- "import \"baz.proto\";\n"
- "import public \"qux.proto\";\n",
- "dependency: \"foo.proto\""
- "dependency: \"bar.proto\""
- "dependency: \"baz.proto\""
- "dependency: \"qux.proto\""
- "public_dependency: 1 "
- "public_dependency: 3 ");
+ "import \"foo.proto\";\n"
+ "import public \"bar.proto\";\n"
+ "import \"baz.proto\";\n"
+ "import public \"qux.proto\";\n",
+ "dependency: \"foo.proto\""
+ "dependency: \"bar.proto\""
+ "dependency: \"baz.proto\""
+ "dependency: \"qux.proto\""
+ "public_dependency: 1 "
+ "public_dependency: 3 ");
}
TEST_F(ParseMiscTest, ParsePackage) {
- ExpectParsesTo(
- "package foo.bar.baz;\n",
- "package: \"foo.bar.baz\"");
+ ExpectParsesTo("package foo.bar.baz;\n", "package: \"foo.bar.baz\"");
}
TEST_F(ParseMiscTest, ParsePackageWithSpaces) {
ExpectParsesTo(
- "package foo . bar. \n"
- " baz;\n",
- "package: \"foo.bar.baz\"");
+ "package foo . bar. \n"
+ " baz;\n",
+ "package: \"foo.bar.baz\"");
}
// ===================================================================
@@ -1149,341 +1197,335 @@
TEST_F(ParseErrorTest, UnknownSyntaxIdentifier) {
ExpectHasEarlyExitErrors(
- "syntax = \"no_such_syntax\";",
- "0:9: Unrecognized syntax identifier \"no_such_syntax\". This parser "
+ "syntax = \"no_such_syntax\";",
+ "0:9: Unrecognized syntax identifier \"no_such_syntax\". This parser "
"only recognizes \"proto2\" and \"proto3\".\n");
EXPECT_EQ("no_such_syntax", parser_->GetSyntaxIdentifier());
}
TEST_F(ParseErrorTest, SimpleSyntaxError) {
- ExpectHasErrors(
- "message TestMessage @#$ { blah }",
- "0:20: Expected \"{\".\n");
+ ExpectHasErrors("message TestMessage @#$ { blah }",
+ "0:20: Expected \"{\".\n");
EXPECT_EQ("proto2", parser_->GetSyntaxIdentifier());
}
TEST_F(ParseErrorTest, ExpectedTopLevel) {
- ExpectHasErrors(
- "blah;",
- "0:0: Expected top-level statement (e.g. \"message\").\n");
+ ExpectHasErrors("blah;",
+ "0:0: Expected top-level statement (e.g. \"message\").\n");
}
TEST_F(ParseErrorTest, UnmatchedCloseBrace) {
// This used to cause an infinite loop. Doh.
- ExpectHasErrors(
- "}",
- "0:0: Expected top-level statement (e.g. \"message\").\n"
- "0:0: Unmatched \"}\".\n");
+ ExpectHasErrors("}",
+ "0:0: Expected top-level statement (e.g. \"message\").\n"
+ "0:0: Unmatched \"}\".\n");
}
// -------------------------------------------------------------------
// Message errors
TEST_F(ParseErrorTest, MessageMissingName) {
- ExpectHasErrors(
- "message {}",
- "0:8: Expected message name.\n");
+ ExpectHasErrors("message {}", "0:8: Expected message name.\n");
}
TEST_F(ParseErrorTest, MessageMissingBody) {
- ExpectHasErrors(
- "message TestMessage;",
- "0:19: Expected \"{\".\n");
+ ExpectHasErrors("message TestMessage;", "0:19: Expected \"{\".\n");
}
TEST_F(ParseErrorTest, EofInMessage) {
ExpectHasErrors(
- "message TestMessage {",
- "0:21: Reached end of input in message definition (missing '}').\n");
+ "message TestMessage {",
+ "0:21: Reached end of input in message definition (missing '}').\n");
}
TEST_F(ParseErrorTest, MissingFieldNumber) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional int32 foo;\n"
- "}\n",
- "1:20: Missing field number.\n");
+ "message TestMessage {\n"
+ " optional int32 foo;\n"
+ "}\n",
+ "1:20: Missing field number.\n");
}
TEST_F(ParseErrorTest, ExpectedFieldNumber) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional int32 foo = ;\n"
- "}\n",
- "1:23: Expected field number.\n");
+ "message TestMessage {\n"
+ " optional int32 foo = ;\n"
+ "}\n",
+ "1:23: Expected field number.\n");
}
TEST_F(ParseErrorTest, FieldNumberOutOfRange) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional int32 foo = 0x100000000;\n"
- "}\n",
- "1:23: Integer out of range.\n");
+ "message TestMessage {\n"
+ " optional int32 foo = 0x100000000;\n"
+ "}\n",
+ "1:23: Integer out of range.\n");
}
TEST_F(ParseErrorTest, MissingLabel) {
ExpectHasErrors(
- "message TestMessage {\n"
- " int32 foo = 1;\n"
- "}\n",
- "1:2: Expected \"required\", \"optional\", or \"repeated\".\n");
+ "message TestMessage {\n"
+ " int32 foo = 1;\n"
+ "}\n",
+ "1:2: Expected \"required\", \"optional\", or \"repeated\".\n");
}
TEST_F(ParseErrorTest, ExpectedOptionName) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional uint32 foo = 1 [];\n"
- "}\n",
- "1:27: Expected identifier.\n");
+ "message TestMessage {\n"
+ " optional uint32 foo = 1 [];\n"
+ "}\n",
+ "1:27: Expected identifier.\n");
}
TEST_F(ParseErrorTest, NonExtensionOptionNameBeginningWithDot) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional uint32 foo = 1 [.foo=1];\n"
- "}\n",
- "1:27: Expected identifier.\n");
+ "message TestMessage {\n"
+ " optional uint32 foo = 1 [.foo=1];\n"
+ "}\n",
+ "1:27: Expected identifier.\n");
}
TEST_F(ParseErrorTest, DefaultValueTypeMismatch) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional uint32 foo = 1 [default=true];\n"
- "}\n",
- "1:35: Expected integer for field default value.\n");
+ "message TestMessage {\n"
+ " optional uint32 foo = 1 [default=true];\n"
+ "}\n",
+ "1:35: Expected integer for field default value.\n");
}
TEST_F(ParseErrorTest, DefaultValueNotBoolean) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional bool foo = 1 [default=blah];\n"
- "}\n",
- "1:33: Expected \"true\" or \"false\".\n");
+ "message TestMessage {\n"
+ " optional bool foo = 1 [default=blah];\n"
+ "}\n",
+ "1:33: Expected \"true\" or \"false\".\n");
}
TEST_F(ParseErrorTest, DefaultValueNotString) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional string foo = 1 [default=1];\n"
- "}\n",
- "1:35: Expected string for field default value.\n");
+ "message TestMessage {\n"
+ " optional string foo = 1 [default=1];\n"
+ "}\n",
+ "1:35: Expected string for field default value.\n");
}
TEST_F(ParseErrorTest, DefaultValueUnsignedNegative) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional uint32 foo = 1 [default=-1];\n"
- "}\n",
- "1:36: Unsigned field can't have negative default value.\n");
+ "message TestMessage {\n"
+ " optional uint32 foo = 1 [default=-1];\n"
+ "}\n",
+ "1:36: Unsigned field can't have negative default value.\n");
}
TEST_F(ParseErrorTest, DefaultValueTooLarge) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional int32 foo = 1 [default= 0x80000000];\n"
- " optional int32 foo = 1 [default=-0x80000001];\n"
- " optional uint32 foo = 1 [default= 0x100000000];\n"
- " optional int64 foo = 1 [default= 0x80000000000000000];\n"
- " optional int64 foo = 1 [default=-0x80000000000000001];\n"
- " optional uint64 foo = 1 [default= 0x100000000000000000];\n"
- "}\n",
- "1:36: Integer out of range.\n"
- "2:36: Integer out of range.\n"
- "3:36: Integer out of range.\n"
- "4:36: Integer out of range.\n"
- "5:36: Integer out of range.\n"
- "6:36: Integer out of range.\n");
+ "message TestMessage {\n"
+ " optional int32 foo = 1 [default= 0x80000000];\n"
+ " optional int32 foo = 1 [default=-0x80000001];\n"
+ " optional uint32 foo = 1 [default= 0x100000000];\n"
+ " optional int64 foo = 1 [default= 0x80000000000000000];\n"
+ " optional int64 foo = 1 [default=-0x80000000000000001];\n"
+ " optional uint64 foo = 1 [default= 0x100000000000000000];\n"
+ "}\n",
+ "1:36: Integer out of range.\n"
+ "2:36: Integer out of range.\n"
+ "3:36: Integer out of range.\n"
+ "4:36: Integer out of range.\n"
+ "5:36: Integer out of range.\n"
+ "6:36: Integer out of range.\n");
}
TEST_F(ParseErrorTest, JsonNameNotString) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional string foo = 1 [json_name=1];\n"
- "}\n",
- "1:37: Expected string for JSON name.\n");
+ "message TestMessage {\n"
+ " optional string foo = 1 [json_name=1];\n"
+ "}\n",
+ "1:37: Expected string for JSON name.\n");
}
TEST_F(ParseErrorTest, DuplicateJsonName) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional uint32 foo = 1 [json_name=\"a\",json_name=\"b\"];\n"
- "}\n",
- "1:41: Already set option \"json_name\".\n");
+ "message TestMessage {\n"
+ " optional uint32 foo = 1 [json_name=\"a\",json_name=\"b\"];\n"
+ "}\n",
+ "1:41: Already set option \"json_name\".\n");
}
TEST_F(ParseErrorTest, EnumValueOutOfRange) {
ExpectHasErrors(
- "enum TestEnum {\n"
- " HEX_TOO_BIG = 0x80000000;\n"
- " HEX_TOO_SMALL = -0x80000001;\n"
- " INT_TOO_BIG = 2147483648;\n"
- " INT_TOO_SMALL = -2147483649;\n"
- "}\n",
- "1:19: Integer out of range.\n"
- "2:19: Integer out of range.\n"
- "3:19: Integer out of range.\n"
- "4:19: Integer out of range.\n");
+ "enum TestEnum {\n"
+ " HEX_TOO_BIG = 0x80000000;\n"
+ " HEX_TOO_SMALL = -0x80000001;\n"
+ " INT_TOO_BIG = 2147483648;\n"
+ " INT_TOO_SMALL = -2147483649;\n"
+ "}\n",
+ "1:19: Integer out of range.\n"
+ "2:19: Integer out of range.\n"
+ "3:19: Integer out of range.\n"
+ "4:19: Integer out of range.\n");
}
TEST_F(ParseErrorTest, EnumAllowAliasFalse) {
ExpectHasErrors(
- "enum Foo {\n"
- " option allow_alias = false;\n"
- " BAR = 1;\n"
- " BAZ = 2;\n"
- "}\n",
- "5:0: \"Foo\" declares 'option allow_alias = false;' which has no effect. "
- "Please remove the declaration.\n");
+ "enum Foo {\n"
+ " option allow_alias = false;\n"
+ " BAR = 1;\n"
+ " BAZ = 2;\n"
+ "}\n",
+ "5:0: \"Foo\" declares 'option allow_alias = false;' which has no "
+ "effect. "
+ "Please remove the declaration.\n");
}
TEST_F(ParseErrorTest, UnnecessaryEnumAllowAlias) {
ExpectHasErrors(
- "enum Foo {\n"
- " option allow_alias = true;\n"
- " BAR = 1;\n"
- " BAZ = 2;\n"
- "}\n",
- "5:0: \"Foo\" declares support for enum aliases but no enum values share "
- "field numbers. Please remove the unnecessary 'option allow_alias = true;' "
- "declaration.\n");
+ "enum Foo {\n"
+ " option allow_alias = true;\n"
+ " BAR = 1;\n"
+ " BAZ = 2;\n"
+ "}\n",
+ "5:0: \"Foo\" declares support for enum aliases but no enum values share "
+ "field numbers. Please remove the unnecessary 'option allow_alias = "
+ "true;' "
+ "declaration.\n");
}
TEST_F(ParseErrorTest, DefaultValueMissing) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional uint32 foo = 1 [default=];\n"
- "}\n",
- "1:35: Expected integer for field default value.\n");
+ "message TestMessage {\n"
+ " optional uint32 foo = 1 [default=];\n"
+ "}\n",
+ "1:35: Expected integer for field default value.\n");
}
TEST_F(ParseErrorTest, DefaultValueForGroup) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional group Foo = 1 [default=blah] {}\n"
- "}\n",
- "1:34: Messages can't have default values.\n");
+ "message TestMessage {\n"
+ " optional group Foo = 1 [default=blah] {}\n"
+ "}\n",
+ "1:34: Messages can't have default values.\n");
}
TEST_F(ParseErrorTest, DuplicateDefaultValue) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional uint32 foo = 1 [default=1,default=2];\n"
- "}\n",
- "1:37: Already set option \"default\".\n");
+ "message TestMessage {\n"
+ " optional uint32 foo = 1 [default=1,default=2];\n"
+ "}\n",
+ "1:37: Already set option \"default\".\n");
}
TEST_F(ParseErrorTest, MissingOneofName) {
ExpectHasErrors(
- "message TestMessage {\n"
- " oneof {\n"
- " int32 bar = 1;\n"
- " }\n"
- "}\n",
- "1:8: Expected oneof name.\n");
+ "message TestMessage {\n"
+ " oneof {\n"
+ " int32 bar = 1;\n"
+ " }\n"
+ "}\n",
+ "1:8: Expected oneof name.\n");
}
TEST_F(ParseErrorTest, LabelInOneof) {
ExpectHasErrors(
- "message TestMessage {\n"
- " oneof foo {\n"
- " optional int32 bar = 1;\n"
- " }\n"
- "}\n",
- "2:4: Fields in oneofs must not have labels (required / optional "
+ "message TestMessage {\n"
+ " oneof foo {\n"
+ " optional int32 bar = 1;\n"
+ " }\n"
+ "}\n",
+ "2:4: Fields in oneofs must not have labels (required / optional "
"/ repeated).\n");
}
TEST_F(ParseErrorTest, MapInOneof) {
ExpectHasErrors(
- "message TestMessage {\n"
- " oneof foo {\n"
- " map<int32, int32> foo_map = 1;\n"
- " map message_field = 2;\n" // a normal message field is OK
- " }\n"
- "}\n",
- "2:7: Map fields are not allowed in oneofs.\n");
+ "message TestMessage {\n"
+ " oneof foo {\n"
+ " map<int32, int32> foo_map = 1;\n"
+ " map message_field = 2;\n" // a normal message field is OK
+ " }\n"
+ "}\n",
+ "2:7: Map fields are not allowed in oneofs.\n");
}
TEST_F(ParseErrorTest, LabelForMap) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional map<int32, int32> int_map = 1;\n"
- " required map<int32, int32> int_map2 = 2;\n"
- " repeated map<int32, int32> int_map3 = 3;\n"
- " optional map map_message = 4;\n" // a normal message field is OK
- "}\n",
- "1:14: Field labels (required/optional/repeated) are not allowed on map "
- "fields.\n"
- "2:14: Field labels (required/optional/repeated) are not allowed on map "
- "fields.\n"
- "3:14: Field labels (required/optional/repeated) are not allowed on map "
- "fields.\n");
+ "message TestMessage {\n"
+ " optional map<int32, int32> int_map = 1;\n"
+ " required map<int32, int32> int_map2 = 2;\n"
+ " repeated map<int32, int32> int_map3 = 3;\n"
+ " optional map map_message = 4;\n" // a normal message field is OK
+ "}\n",
+ "1:14: Field labels (required/optional/repeated) are not allowed on map "
+ "fields.\n"
+ "2:14: Field labels (required/optional/repeated) are not allowed on map "
+ "fields.\n"
+ "3:14: Field labels (required/optional/repeated) are not allowed on map "
+ "fields.\n");
}
TEST_F(ParseErrorTest, MalformedMaps) {
ExpectHasErrors(
- "message TestMessage {\n"
- " map map_message = 1;\n" // a normal message field lacking label
- " map<string> str_map = 2;\n"
- " map<string,> str_map2 = 3;\n"
- " map<,string> str_map3 = 4;\n"
- " map<> empty_map = 5;\n"
- " map<string,string str_map6 = 6;\n"
- "}"
- "extend SomeMessage {\n"
- " map<int32, int32> int_map = 1;\n"
- "}",
- "1:6: Expected \"required\", \"optional\", or \"repeated\".\n"
- "2:12: Expected \",\".\n"
- "3:13: Expected type name.\n"
- "4:6: Expected type name.\n"
- "5:6: Expected type name.\n"
- "6:20: Expected \">\".\n"
- "8:5: Map fields are not allowed to be extensions.\n");
+ "message TestMessage {\n"
+ " map map_message = 1;\n" // a normal message field lacking label
+ " map<string> str_map = 2;\n"
+ " map<string,> str_map2 = 3;\n"
+ " map<,string> str_map3 = 4;\n"
+ " map<> empty_map = 5;\n"
+ " map<string,string str_map6 = 6;\n"
+ "}"
+ "extend SomeMessage {\n"
+ " map<int32, int32> int_map = 1;\n"
+ "}",
+ "1:6: Expected \"required\", \"optional\", or \"repeated\".\n"
+ "2:12: Expected \",\".\n"
+ "3:13: Expected type name.\n"
+ "4:6: Expected type name.\n"
+ "5:6: Expected type name.\n"
+ "6:20: Expected \">\".\n"
+ "8:5: Map fields are not allowed to be extensions.\n");
}
TEST_F(ParseErrorTest, GroupNotCapitalized) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional group foo = 1 {}\n"
- "}\n",
- "1:17: Group names must start with a capital letter.\n");
+ "message TestMessage {\n"
+ " optional group foo = 1 {}\n"
+ "}\n",
+ "1:17: Group names must start with a capital letter.\n");
}
TEST_F(ParseErrorTest, GroupMissingBody) {
ExpectHasErrors(
- "message TestMessage {\n"
- " optional group Foo = 1;\n"
- "}\n",
- "1:24: Missing group body.\n");
+ "message TestMessage {\n"
+ " optional group Foo = 1;\n"
+ "}\n",
+ "1:24: Missing group body.\n");
}
TEST_F(ParseErrorTest, ExtendingPrimitive) {
- ExpectHasErrors(
- "extend int32 { optional string foo = 4; }\n",
- "0:7: Expected message type.\n");
+ ExpectHasErrors("extend int32 { optional string foo = 4; }\n",
+ "0:7: Expected message type.\n");
}
TEST_F(ParseErrorTest, ErrorInExtension) {
ExpectHasErrors(
- "message Foo { extensions 100 to 199; }\n"
- "extend Foo { optional string foo; }\n",
- "1:32: Missing field number.\n");
+ "message Foo { extensions 100 to 199; }\n"
+ "extend Foo { optional string foo; }\n",
+ "1:32: Missing field number.\n");
}
TEST_F(ParseErrorTest, MultipleParseErrors) {
// When a statement has a parse error, the parser should be able to continue
// parsing at the next statement.
ExpectHasErrors(
- "message TestMessage {\n"
- " optional int32 foo;\n"
- " !invalid statement ending in a block { blah blah { blah } blah }\n"
- " optional int32 bar = 3 {}\n"
- "}\n",
- "1:20: Missing field number.\n"
- "2:2: Expected \"required\", \"optional\", or \"repeated\".\n"
- "2:2: Expected type name.\n"
- "3:25: Expected \";\".\n");
+ "message TestMessage {\n"
+ " optional int32 foo;\n"
+ " !invalid statement ending in a block { blah blah { blah } blah }\n"
+ " optional int32 bar = 3 {}\n"
+ "}\n",
+ "1:20: Missing field number.\n"
+ "2:2: Expected \"required\", \"optional\", or \"repeated\".\n"
+ "2:2: Expected type name.\n"
+ "3:25: Expected \";\".\n");
}
TEST_F(ParseErrorTest, EofInAggregateValue) {
@@ -1503,67 +1545,66 @@
"label, as fields are 'optional' by default.\n");
}
-
// -------------------------------------------------------------------
// Enum errors
TEST_F(ParseErrorTest, EofInEnum) {
ExpectHasErrors(
- "enum TestEnum {",
- "0:15: Reached end of input in enum definition (missing '}').\n");
+ "enum TestEnum {",
+ "0:15: Reached end of input in enum definition (missing '}').\n");
}
TEST_F(ParseErrorTest, EnumValueMissingNumber) {
ExpectHasErrors(
- "enum TestEnum {\n"
- " FOO;\n"
- "}\n",
- "1:5: Missing numeric value for enum constant.\n");
+ "enum TestEnum {\n"
+ " FOO;\n"
+ "}\n",
+ "1:5: Missing numeric value for enum constant.\n");
}
TEST_F(ParseErrorTest, EnumReservedStandaloneMaxNotAllowed) {
ExpectHasErrors(
- "enum TestEnum {\n"
- " FOO = 1;\n"
- " reserved max;\n"
- "}\n",
- "2:11: Expected enum value or number range.\n");
+ "enum TestEnum {\n"
+ " FOO = 1;\n"
+ " reserved max;\n"
+ "}\n",
+ "2:11: Expected enum value or number range.\n");
}
TEST_F(ParseErrorTest, EnumReservedMixNameAndNumber) {
ExpectHasErrors(
- "enum TestEnum {\n"
- " FOO = 1;\n"
- " reserved 10, \"foo\";\n"
- "}\n",
- "2:15: Expected enum number range.\n");
+ "enum TestEnum {\n"
+ " FOO = 1;\n"
+ " reserved 10, \"foo\";\n"
+ "}\n",
+ "2:15: Expected enum number range.\n");
}
TEST_F(ParseErrorTest, EnumReservedPositiveNumberOutOfRange) {
ExpectHasErrors(
- "enum TestEnum {\n"
- "FOO = 1;\n"
- " reserved 2147483648;\n"
- "}\n",
- "2:11: Integer out of range.\n");
+ "enum TestEnum {\n"
+ "FOO = 1;\n"
+ " reserved 2147483648;\n"
+ "}\n",
+ "2:11: Integer out of range.\n");
}
TEST_F(ParseErrorTest, EnumReservedNegativeNumberOutOfRange) {
ExpectHasErrors(
- "enum TestEnum {\n"
- "FOO = 1;\n"
- " reserved -2147483649;\n"
- "}\n",
- "2:12: Integer out of range.\n");
+ "enum TestEnum {\n"
+ "FOO = 1;\n"
+ " reserved -2147483649;\n"
+ "}\n",
+ "2:12: Integer out of range.\n");
}
TEST_F(ParseErrorTest, EnumReservedMissingQuotes) {
ExpectHasErrors(
- "enum TestEnum {\n"
- " FOO = 1;\n"
- " reserved foo;\n"
- "}\n",
- "2:11: Expected enum value or number range.\n");
+ "enum TestEnum {\n"
+ " FOO = 1;\n"
+ " reserved foo;\n"
+ "}\n",
+ "2:11: Expected enum value or number range.\n");
}
// -------------------------------------------------------------------
@@ -1571,90 +1612,89 @@
TEST_F(ParseErrorTest, ReservedStandaloneMaxNotAllowed) {
ExpectHasErrors(
- "message Foo {\n"
- " reserved max;\n"
- "}\n",
- "1:11: Expected field name or number range.\n");
+ "message Foo {\n"
+ " reserved max;\n"
+ "}\n",
+ "1:11: Expected field name or number range.\n");
}
TEST_F(ParseErrorTest, ReservedMixNameAndNumber) {
ExpectHasErrors(
- "message Foo {\n"
- " reserved 10, \"foo\";\n"
- "}\n",
- "1:15: Expected field number range.\n");
+ "message Foo {\n"
+ " reserved 10, \"foo\";\n"
+ "}\n",
+ "1:15: Expected field number range.\n");
}
TEST_F(ParseErrorTest, ReservedMissingQuotes) {
ExpectHasErrors(
- "message Foo {\n"
- " reserved foo;\n"
- "}\n",
- "1:11: Expected field name or number range.\n");
+ "message Foo {\n"
+ " reserved foo;\n"
+ "}\n",
+ "1:11: Expected field name or number range.\n");
}
TEST_F(ParseErrorTest, ReservedNegativeNumber) {
ExpectHasErrors(
- "message Foo {\n"
- " reserved -10;\n"
- "}\n",
- "1:11: Expected field name or number range.\n");
+ "message Foo {\n"
+ " reserved -10;\n"
+ "}\n",
+ "1:11: Expected field name or number range.\n");
}
TEST_F(ParseErrorTest, ReservedNumberOutOfRange) {
ExpectHasErrors(
- "message Foo {\n"
- " reserved 2147483648;\n"
- "}\n",
- "1:11: Integer out of range.\n");
+ "message Foo {\n"
+ " reserved 2147483648;\n"
+ "}\n",
+ "1:11: Integer out of range.\n");
}
-
// -------------------------------------------------------------------
// Service errors
TEST_F(ParseErrorTest, EofInService) {
ExpectHasErrors(
- "service TestService {",
- "0:21: Reached end of input in service definition (missing '}').\n");
+ "service TestService {",
+ "0:21: Reached end of input in service definition (missing '}').\n");
}
TEST_F(ParseErrorTest, ServiceMethodPrimitiveParams) {
ExpectHasErrors(
- "service TestService {\n"
- " rpc Foo(int32) returns (string);\n"
- "}\n",
- "1:10: Expected message type.\n"
- "1:26: Expected message type.\n");
+ "service TestService {\n"
+ " rpc Foo(int32) returns (string);\n"
+ "}\n",
+ "1:10: Expected message type.\n"
+ "1:26: Expected message type.\n");
}
TEST_F(ParseErrorTest, EofInMethodOptions) {
ExpectHasErrors(
- "service TestService {\n"
- " rpc Foo(Bar) returns(Bar) {",
- "1:29: Reached end of input in method options (missing '}').\n"
- "1:29: Reached end of input in service definition (missing '}').\n");
+ "service TestService {\n"
+ " rpc Foo(Bar) returns(Bar) {",
+ "1:29: Reached end of input in method options (missing '}').\n"
+ "1:29: Reached end of input in service definition (missing '}').\n");
}
TEST_F(ParseErrorTest, PrimitiveMethodInput) {
ExpectHasErrors(
- "service TestService {\n"
- " rpc Foo(int32) returns(Bar);\n"
- "}\n",
- "1:10: Expected message type.\n");
+ "service TestService {\n"
+ " rpc Foo(int32) returns(Bar);\n"
+ "}\n",
+ "1:10: Expected message type.\n");
}
TEST_F(ParseErrorTest, MethodOptionTypeError) {
// This used to cause an infinite loop.
ExpectHasErrors(
- "message Baz {}\n"
- "service Foo {\n"
- " rpc Bar(Baz) returns(Baz) { option invalid syntax; }\n"
- "}\n",
- "2:45: Expected \"=\".\n");
+ "message Baz {}\n"
+ "service Foo {\n"
+ " rpc Bar(Baz) returns(Baz) { option invalid syntax; }\n"
+ "}\n",
+ "2:45: Expected \"=\".\n");
}
@@ -1662,16 +1702,15 @@
// Import and package errors
TEST_F(ParseErrorTest, ImportNotQuoted) {
- ExpectHasErrors(
- "import foo;\n",
- "0:7: Expected a string naming the file to import.\n");
+ ExpectHasErrors("import foo;\n",
+ "0:7: Expected a string naming the file to import.\n");
}
TEST_F(ParseErrorTest, MultiplePackagesInFile) {
ExpectHasErrors(
- "package foo;\n"
- "package bar;\n",
- "1:0: Multiple package definitions.\n");
+ "package foo;\n"
+ "package bar;\n",
+ "1:0: Multiple package definitions.\n");
}
// ===================================================================
@@ -1690,149 +1729,272 @@
// Now try to define it as a package.
ExpectHasValidationErrors(
- "package foo.bar;",
- "0:0: \"foo\" is already defined (as something other than a package) "
+ "package foo.bar;",
+ "0:0: \"foo\" is already defined (as something other than a package) "
"in file \"bar.proto\".\n");
}
+TEST_F(ParserValidationErrorTest, ImportUnloadedError) {
+ ExpectHasValidationErrors(
+ "package test;\n"
+ "\n"
+ "import \"unloaded.proto\";",
+ "2:0: Import \"unloaded.proto\" has not been loaded.\n");
+}
+
+TEST_F(ParserValidationErrorTest, ImportTwice) {
+ FileDescriptorProto other_file;
+ other_file.set_name("bar.proto");
+ other_file.add_message_type()->set_name("foo");
+ EXPECT_TRUE(pool_.BuildFile(other_file) != nullptr);
+
+ ExpectHasValidationErrors(
+ "package test;\n"
+ "\n"
+ "import \"bar.proto\";\n"
+ " import \"bar.proto\";",
+ "3:2: Import \"bar.proto\" was listed twice.\n");
+}
+
+TEST_F(ParserValidationErrorTest, DuplicateFileError) {
+ FileDescriptorProto other_file;
+ other_file.set_name("foo.proto");
+ EXPECT_TRUE(pool_.BuildFile(other_file) != nullptr);
+
+ ExpectHasValidationErrors(
+ "package test;", "0:0: A file with this name is already in the pool.\n");
+}
+
TEST_F(ParserValidationErrorTest, MessageNameError) {
ExpectHasValidationErrors(
- "message Foo {}\n"
- "message Foo {}\n",
- "1:8: \"Foo\" is already defined.\n");
+ "message Foo {}\n"
+ "message Foo {}\n",
+ "1:8: \"Foo\" is already defined.\n");
}
TEST_F(ParserValidationErrorTest, FieldNameError) {
ExpectHasValidationErrors(
- "message Foo {\n"
- " optional int32 bar = 1;\n"
- " optional int32 bar = 2;\n"
- "}\n",
- "2:17: \"bar\" is already defined in \"Foo\".\n");
+ "message Foo {\n"
+ " optional int32 bar = 1;\n"
+ " optional int32 bar = 2;\n"
+ "}\n",
+ "2:17: \"bar\" is already defined in \"Foo\".\n");
}
TEST_F(ParserValidationErrorTest, FieldTypeError) {
ExpectHasValidationErrors(
- "message Foo {\n"
- " optional Baz bar = 1;\n"
- "}\n",
- "1:11: \"Baz\" is not defined.\n");
+ "message Foo {\n"
+ " optional Baz bar = 1;\n"
+ "}\n",
+ "1:11: \"Baz\" is not defined.\n");
}
TEST_F(ParserValidationErrorTest, FieldNumberError) {
ExpectHasValidationErrors(
- "message Foo {\n"
- " optional int32 bar = 0;\n"
- "}\n",
- "1:23: Field numbers must be positive integers.\n");
+ "message Foo {\n"
+ " optional int32 bar = 0;\n"
+ "}\n",
+ "1:23: Field numbers must be positive integers.\n");
}
TEST_F(ParserValidationErrorTest, FieldExtendeeError) {
+ ExpectHasValidationErrors("extend Baz { optional int32 bar = 1; }\n",
+ "0:7: \"Baz\" is not defined.\n");
+}
+
+TEST_F(ParserValidationErrorTest, ExtensionJsonNameError) {
ExpectHasValidationErrors(
- "extend Baz { optional int32 bar = 1; }\n",
- "0:7: \"Baz\" is not defined.\n");
+ "message TestMessage {\n"
+ " extensions 1 to 100;\n"
+ "}\n"
+ "extend TestMessage {\n"
+ " optional int32 foo = 12 [json_name = \"bar\"];\n"
+ "}",
+ "4:27: option json_name is not allowed on extension fields.\n");
}
TEST_F(ParserValidationErrorTest, FieldDefaultValueError) {
ExpectHasValidationErrors(
- "enum Baz { QUX = 1; }\n"
- "message Foo {\n"
- " optional Baz bar = 1 [default=NO_SUCH_VALUE];\n"
- "}\n",
- "2:32: Enum type \"Baz\" has no value named \"NO_SUCH_VALUE\".\n");
+ "enum Baz { QUX = 1; }\n"
+ "message Foo {\n"
+ " optional Baz bar = 1 [default=NO_SUCH_VALUE];\n"
+ "}\n",
+ "2:32: Enum type \"Baz\" has no value named \"NO_SUCH_VALUE\".\n");
}
TEST_F(ParserValidationErrorTest, FileOptionNameError) {
ExpectHasValidationErrors(
- "option foo = 5;",
- "0:7: Option \"foo\" unknown. Ensure that your proto definition file "
- "imports the proto which defines the option.\n");
+ "option foo = 5;",
+ "0:7: Option \"foo\" unknown. Ensure that your proto definition file "
+ "imports the proto which defines the option.\n");
}
TEST_F(ParserValidationErrorTest, FileOptionValueError) {
ExpectHasValidationErrors(
- "option java_outer_classname = 5;",
- "0:30: Value must be quoted string for string option "
- "\"google.protobuf.FileOptions.java_outer_classname\".\n");
+ "option java_outer_classname = 5;",
+ "0:30: Value must be quoted string for string option "
+ "\"google.protobuf.FileOptions.java_outer_classname\".\n");
}
TEST_F(ParserValidationErrorTest, FieldOptionNameError) {
ExpectHasValidationErrors(
- "message Foo {\n"
- " optional bool bar = 1 [foo=1];\n"
- "}\n",
- "1:25: Option \"foo\" unknown. Ensure that your proto definition file "
- "imports the proto which defines the option.\n");
+ "message Foo {\n"
+ " optional bool bar = 1 [foo=1];\n"
+ "}\n",
+ "1:25: Option \"foo\" unknown. Ensure that your proto definition file "
+ "imports the proto which defines the option.\n");
}
TEST_F(ParserValidationErrorTest, FieldOptionValueError) {
ExpectHasValidationErrors(
- "message Foo {\n"
- " optional int32 bar = 1 [ctype=1];\n"
- "}\n",
- "1:32: Value must be identifier for enum-valued option "
- "\"google.protobuf.FieldOptions.ctype\".\n");
+ "message Foo {\n"
+ " optional int32 bar = 1 [ctype=1];\n"
+ "}\n",
+ "1:32: Value must be identifier for enum-valued option "
+ "\"google.protobuf.FieldOptions.ctype\".\n");
}
TEST_F(ParserValidationErrorTest, ExtensionRangeNumberError) {
ExpectHasValidationErrors(
- "message Foo {\n"
- " extensions 0;\n"
- "}\n",
- "1:13: Extension numbers must be positive integers.\n");
+ "message Foo {\n"
+ " extensions 0;\n"
+ "}\n",
+ "1:13: Extension numbers must be positive integers.\n");
+}
+
+TEST_F(ParserValidationErrorTest, Proto3ExtensionError) {
+ ExpectHasValidationErrors(
+ "syntax = 'proto3';\n"
+ "message Foo { \n"
+ " extensions 100 to 199;\n"
+ "}\n"
+ "extend Foo { string foo = 101; }\n",
+ "4:7: Extensions in proto3 are only allowed for defining options.\n"
+ "2:13: Extension ranges are not allowed in proto3.\n");
+}
+
+TEST_F(ParserValidationErrorTest, Proto3MessageSet) {
+ ExpectHasValidationErrors(
+ "syntax = 'proto3';\n"
+ "message Foo { \n"
+ " option message_set_wire_format = true;\n"
+ "}\n",
+ "1:8: MessageSet is not supported in proto3.\n");
+}
+
+TEST_F(ParserValidationErrorTest, Proto3Required) {
+ ExpectHasValidationErrors(
+ "syntax = 'proto3';\n"
+ "message Foo { \n"
+ " required int32 field = 1;"
+ "}\n",
+ "2:11: Required fields are not allowed in proto3.\n");
+}
+
+TEST_F(ParserValidationErrorTest, Proto3Default) {
+ ExpectHasValidationErrors(
+ "syntax = 'proto3';\n"
+ "message Foo { \n"
+ " int32 field = 1 [default = 12];"
+ "}\n",
+ "2:29: Explicit default values are not allowed in proto3.\n");
+}
+
+TEST_F(ParserValidationErrorTest, Proto3JsonConflictError) {
+ ExpectHasValidationErrors(
+ "syntax = 'proto3';\n"
+ "message TestMessage {\n"
+ " uint32 foo = 1;\n"
+ " uint32 Foo = 2;\n"
+ "}\n",
+ "3:9: The JSON camel-case name of field \"Foo\" conflicts with field "
+ "\"foo\". This is not allowed in proto3.\n");
}
TEST_F(ParserValidationErrorTest, EnumNameError) {
ExpectHasValidationErrors(
- "enum Foo {A = 1;}\n"
- "enum Foo {B = 1;}\n",
- "1:5: \"Foo\" is already defined.\n");
+ "enum Foo {A = 1;}\n"
+ "enum Foo {B = 1;}\n",
+ "1:5: \"Foo\" is already defined.\n");
+}
+
+TEST_F(ParserValidationErrorTest, Proto3EnumError) {
+ ExpectHasValidationErrors(
+ "syntax = 'proto3';\n"
+ "enum Foo {A = 1;}\n",
+ "1:14: The first enum value must be zero in proto3.\n");
}
TEST_F(ParserValidationErrorTest, EnumValueNameError) {
ExpectHasValidationErrors(
- "enum Foo {\n"
- " BAR = 1;\n"
- " BAR = 1;\n"
- "}\n",
- "2:2: \"BAR\" is already defined.\n");
+ "enum Foo {\n"
+ " BAR = 1;\n"
+ " BAR = 1;\n"
+ "}\n",
+ "2:2: \"BAR\" is already defined.\n");
+}
+
+TEST_F(ParserValidationErrorTest, EnumValueAliasError) {
+ ExpectHasValidationErrors(
+ "enum Foo {\n"
+ " BAR = 1;\n"
+ " BAZ = 1;\n"
+ "}\n",
+ "2:8: \"BAZ\" uses the same enum value as \"BAR\". If this is "
+ "intended, set 'option allow_alias = true;' to the enum "
+ "definition.\n");
+}
+
+TEST_F(ParserValidationErrorTest, ExplicitlyMapEntryError) {
+ ExpectHasValidationErrors(
+ "message Foo {\n"
+ " message ValueEntry {\n"
+ " option map_entry = true;\n"
+ " optional int32 key = 1;\n"
+ " optional int32 value = 2;\n"
+ " extensions 99 to 999;\n"
+ " }\n"
+ " repeated ValueEntry value = 1;\n"
+ "}",
+ "7:11: map_entry should not be set explicitly. Use "
+ "map<KeyType, ValueType> instead.\n");
}
TEST_F(ParserValidationErrorTest, ServiceNameError) {
ExpectHasValidationErrors(
- "service Foo {}\n"
- "service Foo {}\n",
- "1:8: \"Foo\" is already defined.\n");
+ "service Foo {}\n"
+ "service Foo {}\n",
+ "1:8: \"Foo\" is already defined.\n");
}
TEST_F(ParserValidationErrorTest, MethodNameError) {
ExpectHasValidationErrors(
- "message Baz {}\n"
- "service Foo {\n"
- " rpc Bar(Baz) returns(Baz);\n"
- " rpc Bar(Baz) returns(Baz);\n"
- "}\n",
- "3:6: \"Bar\" is already defined in \"Foo\".\n");
+ "message Baz {}\n"
+ "service Foo {\n"
+ " rpc Bar(Baz) returns(Baz);\n"
+ " rpc Bar(Baz) returns(Baz);\n"
+ "}\n",
+ "3:6: \"Bar\" is already defined in \"Foo\".\n");
}
TEST_F(ParserValidationErrorTest, MethodInputTypeError) {
ExpectHasValidationErrors(
- "message Baz {}\n"
- "service Foo {\n"
- " rpc Bar(Qux) returns(Baz);\n"
- "}\n",
- "2:10: \"Qux\" is not defined.\n");
+ "message Baz {}\n"
+ "service Foo {\n"
+ " rpc Bar(Qux) returns(Baz);\n"
+ "}\n",
+ "2:10: \"Qux\" is not defined.\n");
}
TEST_F(ParserValidationErrorTest, MethodOutputTypeError) {
ExpectHasValidationErrors(
- "message Baz {}\n"
- "service Foo {\n"
- " rpc Bar(Baz) returns(Qux);\n"
- "}\n",
- "2:23: \"Qux\" is not defined.\n");
+ "message Baz {}\n"
+ "service Foo {\n"
+ " rpc Bar(Baz) returns(Qux);\n"
+ "}\n",
+ "2:23: \"Qux\" is not defined.\n");
}
@@ -1847,16 +2009,16 @@
// Define "foo.base" and try "base.bar".
// "base.bar" is resolved to "foo.base.bar" which is not defined.
ExpectHasValidationErrors(
- "package foo.base;\n"
- "import \"base.proto\";\n"
- "message qux {\n"
- " optional base.bar baz = 1;\n"
- " optional .base.bar quz = 2;\n"
- "}\n",
- "3:11: \"base.bar\" is resolved to \"foo.base.bar\","
- " which is not defined. The innermost scope is searched first "
- "in name resolution. Consider using a leading '.'(i.e., \".base.bar\")"
- " to start from the outermost scope.\n");
+ "package foo.base;\n"
+ "import \"base.proto\";\n"
+ "message qux {\n"
+ " optional base.bar baz = 1;\n"
+ " optional .base.bar quz = 2;\n"
+ "}\n",
+ "3:11: \"base.bar\" is resolved to \"foo.base.bar\","
+ " which is not defined. The innermost scope is searched first "
+ "in name resolution. Consider using a leading '.'(i.e., \".base.bar\")"
+ " to start from the outermost scope.\n");
}
TEST_F(ParserValidationErrorTest, ResovledUndefinedOptionError) {
@@ -1928,26 +2090,26 @@
};
// Sorts nested DescriptorProtos of a DescriptoProto, by name.
-void SortMessages(DescriptorProto *descriptor_proto) {
+void SortMessages(DescriptorProto* descriptor_proto) {
int size = descriptor_proto->nested_type_size();
// recursively sort; we can't guarantee the order of nested messages either
for (int i = 0; i < size; ++i) {
SortMessages(descriptor_proto->mutable_nested_type(i));
}
- DescriptorProto **data =
- descriptor_proto->mutable_nested_type()->mutable_data();
+ DescriptorProto** data =
+ descriptor_proto->mutable_nested_type()->mutable_data();
std::sort(data, data + size, CompareDescriptorNames());
}
// Sorts DescriptorProtos belonging to a FileDescriptorProto, by name.
-void SortMessages(FileDescriptorProto *file_descriptor_proto) {
+void SortMessages(FileDescriptorProto* file_descriptor_proto) {
int size = file_descriptor_proto->message_type_size();
// recursively sort; we can't guarantee the order of nested messages either
for (int i = 0; i < size; ++i) {
SortMessages(file_descriptor_proto->mutable_message_type(i));
}
- DescriptorProto **data =
- file_descriptor_proto->mutable_message_type()->mutable_data();
+ DescriptorProto** data =
+ file_descriptor_proto->mutable_message_type()->mutable_data();
std::sort(data, data + size, CompareDescriptorNames());
}
@@ -1974,7 +2136,7 @@
TEST_F(ParseDescriptorDebugTest, TestAllDescriptorTypes) {
const FileDescriptor* original_file =
- protobuf_unittest::TestAllTypes::descriptor()->file();
+ protobuf_unittest::TestAllTypes::descriptor()->file();
FileDescriptorProto expected;
original_file->CopyTo(&expected);
@@ -1987,8 +2149,7 @@
FileDescriptorProto parsed;
parser_->Parse(input_.get(), &parsed);
EXPECT_EQ(io::Tokenizer::TYPE_END, input_->current().type);
- ASSERT_EQ("", error_collector_.text_)
- << "Failed to parse:\n" << debug_string;
+ ASSERT_EQ("", error_collector_.text_) << "Failed to parse:\n" << debug_string;
// We now have a FileDescriptorProto, but to compare with the expected we
// need to link to a FileDecriptor, then output back to a proto. We'll
@@ -2002,14 +2163,13 @@
public_import->CopyTo(&public_import_proto);
ASSERT_TRUE(pool_.BuildFile(public_import_proto) != NULL);
const FileDescriptor* import =
- protobuf_unittest_import::ImportMessage::descriptor()->file();
+ protobuf_unittest_import::ImportMessage::descriptor()->file();
FileDescriptorProto import_proto;
import->CopyTo(&import_proto);
ASSERT_TRUE(pool_.BuildFile(import_proto) != NULL);
const FileDescriptor* actual = pool_.BuildFile(parsed);
parsed.Clear();
- ASSERT_TRUE(actual != NULL)
- << "Failed to validate:\n" << debug_string;
+ ASSERT_TRUE(actual != NULL) << "Failed to validate:\n" << debug_string;
actual->CopyTo(&parsed);
ASSERT_TRUE(actual != NULL);
@@ -2027,7 +2187,7 @@
TEST_F(ParseDescriptorDebugTest, TestCustomOptions) {
const FileDescriptor* original_file =
- protobuf_unittest::AggregateMessage::descriptor()->file();
+ protobuf_unittest::AggregateMessage::descriptor()->file();
FileDescriptorProto expected;
original_file->CopyTo(&expected);
@@ -2139,25 +2299,25 @@
// We don't test the exact comment placement or formatting, because we do not
// want to be too fragile here.
const char* expected_comments[] = {
- "Detached comment before syntax.",
- "Syntax comment.",
- "Detached comment before package.",
- "Package comment.",
- "Detached comment before TestMessage1.",
- "Message comment.",
- "More detail in message comment.",
- "Detached comment before foo.",
- "Field comment",
- "Detached comment before NestedMessage.",
- "Nested-message comment",
- "Detached comment before MyEnumType.",
- "Enum comment",
- "Detached comment before ASDF.",
- "Enum-value comment",
- "Detached comment before MyService.",
- "Service comment",
- "Detached comment before MyRPCCall.",
- "RPC comment",
+ "Detached comment before syntax.",
+ "Syntax comment.",
+ "Detached comment before package.",
+ "Package comment.",
+ "Detached comment before TestMessage1.",
+ "Message comment.",
+ "More detail in message comment.",
+ "Detached comment before foo.",
+ "Field comment",
+ "Detached comment before NestedMessage.",
+ "Nested-message comment",
+ "Detached comment before MyEnumType.",
+ "Enum comment",
+ "Detached comment before ASDF.",
+ "Enum-value comment",
+ "Detached comment before MyService.",
+ "Service comment",
+ "Detached comment before MyRPCCall.",
+ "RPC comment",
};
DebugStringOptions debug_string_options;
@@ -2179,8 +2339,8 @@
FileDescriptorProto parsed;
parser_->Parse(input_.get(), &parsed);
EXPECT_EQ(io::Tokenizer::TYPE_END, input_->current().type);
- ASSERT_EQ("", error_collector_.text_)
- << "Failed to parse:\n" << debug_string;
+ ASSERT_EQ("", error_collector_.text_) << "Failed to parse:\n"
+ << debug_string;
}
}
@@ -2234,11 +2394,9 @@
// *output_field to the descriptor of the field, and *output_index to -1.
// Returns true if the path was valid, false otherwise. A gTest failure is
// recorded before returning false.
-bool FollowPath(const Message& root,
- const int* path_begin, const int* path_end,
+bool FollowPath(const Message& root, const int* path_begin, const int* path_end,
const Message** output_message,
- const FieldDescriptor** output_field,
- int* output_index) {
+ const FieldDescriptor** output_field, int* output_index) {
if (path_begin == path_end) {
// Path refers to this whole message.
*output_message = &root;
@@ -2253,8 +2411,8 @@
const FieldDescriptor* field = descriptor->FindFieldByNumber(*path_begin);
if (field == NULL) {
- ADD_FAILURE() << descriptor->name() << " has no field number: "
- << *path_begin;
+ ADD_FAILURE() << descriptor->name()
+ << " has no field number: " << *path_begin;
return false;
}
@@ -2274,16 +2432,16 @@
if (index >= size) {
ADD_FAILURE() << descriptor->name() << "." << field->name()
- << " has size " << size << ", but path contained index: "
- << index;
+ << " has size " << size
+ << ", but path contained index: " << index;
return false;
}
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
// Descend into child message.
const Message& child = reflection->GetRepeatedMessage(root, field, index);
- return FollowPath(child, path_begin, path_end,
- output_message, output_field, output_index);
+ return FollowPath(child, path_begin, path_end, output_message,
+ output_field, output_index);
} else if (path_begin == path_end) {
// Path refers to this element.
*output_message = &root;
@@ -2298,8 +2456,8 @@
} else {
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
const Message& child = reflection->GetMessage(root, field);
- return FollowPath(child, path_begin, path_end,
- output_message, output_field, output_index);
+ return FollowPath(child, path_begin, path_end, output_message,
+ output_field, output_index);
} else if (path_begin == path_end) {
// Path refers to this field.
*output_message = &root;
@@ -2359,9 +2517,8 @@
}
virtual void TearDown() {
- EXPECT_TRUE(spans_.empty())
- << "Forgot to call HasSpan() for:\n"
- << spans_.begin()->second->DebugString();
+ EXPECT_TRUE(spans_.empty()) << "Forgot to call HasSpan() for:\n"
+ << spans_.begin()->second->DebugString();
}
// -----------------------------------------------------------------
@@ -2372,8 +2529,8 @@
bool HasSpan(char start_marker, char end_marker,
const Message& descriptor_proto) {
- return HasSpanWithComment(
- start_marker, end_marker, descriptor_proto, NULL, -1, NULL, NULL, NULL);
+ return HasSpanWithComment(start_marker, end_marker, descriptor_proto, NULL,
+ -1, NULL, NULL, NULL);
}
bool HasSpanWithComment(char start_marker, char end_marker,
@@ -2381,10 +2538,10 @@
const char* expected_leading_comments,
const char* expected_trailing_comments,
const char* expected_leading_detached_comments) {
- return HasSpanWithComment(
- start_marker, end_marker, descriptor_proto, NULL, -1,
- expected_leading_comments, expected_trailing_comments,
- expected_leading_detached_comments);
+ return HasSpanWithComment(start_marker, end_marker, descriptor_proto, NULL,
+ -1, expected_leading_comments,
+ expected_trailing_comments,
+ expected_leading_detached_comments);
}
bool HasSpan(char start_marker, char end_marker,
@@ -2395,8 +2552,8 @@
bool HasSpan(char start_marker, char end_marker,
const Message& descriptor_proto, const std::string& field_name,
int index) {
- return HasSpan(start_marker, end_marker, descriptor_proto,
- field_name, index, NULL, NULL, NULL);
+ return HasSpan(start_marker, end_marker, descriptor_proto, field_name,
+ index, NULL, NULL, NULL);
}
bool HasSpan(char start_marker, char end_marker,
@@ -2412,15 +2569,15 @@
return false;
}
- return HasSpanWithComment(
- start_marker, end_marker, descriptor_proto, field, index,
- expected_leading_comments, expected_trailing_comments,
- expected_leading_detached_comments);
+ return HasSpanWithComment(start_marker, end_marker, descriptor_proto, field,
+ index, expected_leading_comments,
+ expected_trailing_comments,
+ expected_leading_detached_comments);
}
bool HasSpan(const Message& descriptor_proto) {
- return HasSpanWithComment(
- '\0', '\0', descriptor_proto, NULL, -1, NULL, NULL, NULL);
+ return HasSpanWithComment('\0', '\0', descriptor_proto, NULL, -1, NULL,
+ NULL, NULL);
}
bool HasSpan(const Message& descriptor_proto, const std::string& field_name) {
@@ -2432,12 +2589,12 @@
return HasSpan('\0', '\0', descriptor_proto, field_name, index);
}
- bool HasSpanWithComment(
- char start_marker, char end_marker, const Message& descriptor_proto,
- const FieldDescriptor* field, int index,
- const char* expected_leading_comments,
- const char* expected_trailing_comments,
- const char* expected_leading_detached_comments) {
+ bool HasSpanWithComment(char start_marker, char end_marker,
+ const Message& descriptor_proto,
+ const FieldDescriptor* field, int index,
+ const char* expected_leading_comments,
+ const char* expected_trailing_comments,
+ const char* expected_leading_detached_comments) {
std::pair<SpanMap::iterator, SpanMap::iterator> range =
spans_.equal_range(SpanKey(descriptor_proto, field, index));
@@ -2501,9 +2658,9 @@
inline SpanKey() {}
inline SpanKey(const Message& descriptor_proto_param,
- const FieldDescriptor* field_param,
- int index_param)
- : descriptor_proto(&descriptor_proto_param), field(field_param),
+ const FieldDescriptor* field_param, int index_param)
+ : descriptor_proto(&descriptor_proto_param),
+ field(field_param),
index(index_param) {}
inline bool operator<(const SpanKey& other) const {
@@ -2551,15 +2708,15 @@
};
TEST_F(SourceInfoTest, BasicFileDecls) {
- EXPECT_TRUE(Parse(
- "$a$syntax = \"proto2\";$i$\n"
- "$b$package foo.bar;$c$\n"
- "$d$import \"baz.proto\";$e$\n"
- "$f$import\"qux.proto\";$h$\n"
- "$j$import $k$public$l$ \"bar.proto\";$m$\n"
- "$n$import $o$weak$p$ \"bar.proto\";$q$\n"
- "\n"
- "// comment ignored\n"));
+ EXPECT_TRUE(
+ Parse("$a$syntax = \"proto2\";$i$\n"
+ "$b$package foo.bar;$c$\n"
+ "$d$import \"baz.proto\";$e$\n"
+ "$f$import\"qux.proto\";$h$\n"
+ "$j$import $k$public$l$ \"bar.proto\";$m$\n"
+ "$n$import $o$weak$p$ \"bar.proto\";$q$\n"
+ "\n"
+ "// comment ignored\n"));
EXPECT_TRUE(HasSpan('a', 'q', file_));
EXPECT_TRUE(HasSpan('b', 'c', file_, "package"));
@@ -2573,9 +2730,9 @@
}
TEST_F(SourceInfoTest, Messages) {
- EXPECT_TRUE(Parse(
- "$a$message $b$Foo$c$ {}$d$\n"
- "$e$message $f$Bar$g$ {}$h$\n"));
+ EXPECT_TRUE(
+ Parse("$a$message $b$Foo$c$ {}$d$\n"
+ "$e$message $f$Bar$g$ {}$h$\n"));
EXPECT_TRUE(HasSpan('a', 'd', file_.message_type(0)));
EXPECT_TRUE(HasSpan('b', 'c', file_.message_type(0), "name"));
@@ -2587,11 +2744,11 @@
}
TEST_F(SourceInfoTest, Fields) {
- EXPECT_TRUE(Parse(
- "message Foo {\n"
- " $a$optional$b$ $c$int32$d$ $e$bar$f$ = $g$1$h$;$i$\n"
- " $j$repeated$k$ $l$X.Y$m$ $n$baz$o$ = $p$2$q$;$r$\n"
- "}\n"));
+ EXPECT_TRUE(
+ Parse("message Foo {\n"
+ " $a$optional$b$ $c$int32$d$ $e$bar$f$ = $g$1$h$;$i$\n"
+ " $j$repeated$k$ $l$X.Y$m$ $n$baz$o$ = $p$2$q$;$r$\n"
+ "}\n"));
const FieldDescriptorProto& field1 = file_.message_type(0).field(0);
const FieldDescriptorProto& field2 = file_.message_type(0).field(1);
@@ -2615,14 +2772,14 @@
}
TEST_F(SourceInfoTest, Extensions) {
- EXPECT_TRUE(Parse(
- "$a$extend $b$Foo$c$ {\n"
- " $d$optional$e$ int32 bar = 1;$f$\n"
- " $g$repeated$h$ X.Y baz = 2;$i$\n"
- "}$j$\n"
- "$k$extend $l$Bar$m$ {\n"
- " $n$optional int32 qux = 1;$o$\n"
- "}$p$\n"));
+ EXPECT_TRUE(
+ Parse("$a$extend $b$Foo$c$ {\n"
+ " $d$optional$e$ int32 bar = 1;$f$\n"
+ " $g$repeated$h$ X.Y baz = 2;$i$\n"
+ "}$j$\n"
+ "$k$extend $l$Bar$m$ {\n"
+ " $n$optional int32 qux = 1;$o$\n"
+ "}$p$\n"));
const FieldDescriptorProto& field1 = file_.extension(0);
const FieldDescriptorProto& field2 = file_.extension(1);
@@ -2657,16 +2814,16 @@
}
TEST_F(SourceInfoTest, NestedExtensions) {
- EXPECT_TRUE(Parse(
- "message Message {\n"
- " $a$extend $b$Foo$c$ {\n"
- " $d$optional$e$ int32 bar = 1;$f$\n"
- " $g$repeated$h$ X.Y baz = 2;$i$\n"
- " }$j$\n"
- " $k$extend $l$Bar$m$ {\n"
- " $n$optional int32 qux = 1;$o$\n"
- " }$p$\n"
- "}\n"));
+ EXPECT_TRUE(
+ Parse("message Message {\n"
+ " $a$extend $b$Foo$c$ {\n"
+ " $d$optional$e$ int32 bar = 1;$f$\n"
+ " $g$repeated$h$ X.Y baz = 2;$i$\n"
+ " }$j$\n"
+ " $k$extend $l$Bar$m$ {\n"
+ " $n$optional int32 qux = 1;$o$\n"
+ " }$p$\n"
+ "}\n"));
const FieldDescriptorProto& field1 = file_.message_type(0).extension(0);
const FieldDescriptorProto& field2 = file_.message_type(0).extension(1);
@@ -2703,11 +2860,11 @@
}
TEST_F(SourceInfoTest, ExtensionRanges) {
- EXPECT_TRUE(Parse(
- "message Message {\n"
- " $a$extensions $b$1$c$ to $d$4$e$, $f$6$g$;$h$\n"
- " $i$extensions $j$8$k$ to $l$max$m$;$n$\n"
- "}\n"));
+ EXPECT_TRUE(
+ Parse("message Message {\n"
+ " $a$extensions $b$1$c$ to $d$4$e$, $f$6$g$;$h$\n"
+ " $i$extensions $j$8$k$ to $l$max$m$;$n$\n"
+ "}\n"));
const DescriptorProto::ExtensionRange& range1 =
file_.message_type(0).extension_range(0);
@@ -2765,12 +2922,12 @@
}
TEST_F(SourceInfoTest, Oneofs) {
- EXPECT_TRUE(Parse(
- "message Foo {\n"
- " $a$oneof $c$foo$d$ {\n"
- " $e$int32$f$ $g$a$h$ = $i$1$j$;$k$\n"
- " }$r$\n"
- "}\n"));
+ EXPECT_TRUE(
+ Parse("message Foo {\n"
+ " $a$oneof $c$foo$d$ {\n"
+ " $e$int32$f$ $g$a$h$ = $i$1$j$;$k$\n"
+ " }$r$\n"
+ "}\n"));
const OneofDescriptorProto& oneof_decl = file_.message_type(0).oneof_decl(0);
const FieldDescriptorProto& field = file_.message_type(0).field(0);
@@ -2790,13 +2947,13 @@
}
TEST_F(SourceInfoTest, NestedMessages) {
- EXPECT_TRUE(Parse(
- "message Foo {\n"
- " $a$message $b$Bar$c$ {\n"
- " $d$message $e$Baz$f$ {}$g$\n"
- " }$h$\n"
- " $i$message $j$Qux$k$ {}$l$\n"
- "}\n"));
+ EXPECT_TRUE(
+ Parse("message Foo {\n"
+ " $a$message $b$Bar$c$ {\n"
+ " $d$message $e$Baz$f$ {}$g$\n"
+ " }$h$\n"
+ " $i$message $j$Qux$k$ {}$l$\n"
+ "}\n"));
const DescriptorProto& bar = file_.message_type(0).nested_type(0);
const DescriptorProto& baz = bar.nested_type(0);
@@ -2816,13 +2973,13 @@
}
TEST_F(SourceInfoTest, Groups) {
- EXPECT_TRUE(Parse(
- "message Foo {\n"
- " message Bar {}\n"
- " $a$optional$b$ $c$group$d$ $e$Baz$f$ = $g$1$h$ {\n"
- " $i$message Qux {}$j$\n"
- " }$k$\n"
- "}\n"));
+ EXPECT_TRUE(
+ Parse("message Foo {\n"
+ " message Bar {}\n"
+ " $a$optional$b$ $c$group$d$ $e$Baz$f$ = $g$1$h$ {\n"
+ " $i$message Qux {}$j$\n"
+ " }$k$\n"
+ "}\n"));
const DescriptorProto& bar = file_.message_type(0).nested_type(0);
const DescriptorProto& baz = file_.message_type(0).nested_type(1);
@@ -2850,9 +3007,9 @@
}
TEST_F(SourceInfoTest, Enums) {
- EXPECT_TRUE(Parse(
- "$a$enum $b$Foo$c$ {}$d$\n"
- "$e$enum $f$Bar$g$ {}$h$\n"));
+ EXPECT_TRUE(
+ Parse("$a$enum $b$Foo$c$ {}$d$\n"
+ "$e$enum $f$Bar$g$ {}$h$\n"));
EXPECT_TRUE(HasSpan('a', 'd', file_.enum_type(0)));
EXPECT_TRUE(HasSpan('b', 'c', file_.enum_type(0), "name"));
@@ -2864,11 +3021,11 @@
}
TEST_F(SourceInfoTest, EnumValues) {
- EXPECT_TRUE(Parse(
- "enum Foo {\n"
- " $a$BAR$b$ = $c$1$d$;$e$\n"
- " $f$BAZ$g$ = $h$2$i$;$j$\n"
- "}"));
+ EXPECT_TRUE(
+ Parse("enum Foo {\n"
+ " $a$BAR$b$ = $c$1$d$;$e$\n"
+ " $f$BAZ$g$ = $h$2$i$;$j$\n"
+ "}"));
const EnumValueDescriptorProto& bar = file_.enum_type(0).value(0);
const EnumValueDescriptorProto& baz = file_.enum_type(0).value(1);
@@ -2887,11 +3044,11 @@
}
TEST_F(SourceInfoTest, NestedEnums) {
- EXPECT_TRUE(Parse(
- "message Foo {\n"
- " $a$enum $b$Bar$c$ {}$d$\n"
- " $e$enum $f$Baz$g$ {}$h$\n"
- "}\n"));
+ EXPECT_TRUE(
+ Parse("message Foo {\n"
+ " $a$enum $b$Bar$c$ {}$d$\n"
+ " $e$enum $f$Baz$g$ {}$h$\n"
+ "}\n"));
const EnumDescriptorProto& bar = file_.message_type(0).enum_type(0);
const EnumDescriptorProto& baz = file_.message_type(0).enum_type(1);
@@ -2908,9 +3065,9 @@
}
TEST_F(SourceInfoTest, Services) {
- EXPECT_TRUE(Parse(
- "$a$service $b$Foo$c$ {}$d$\n"
- "$e$service $f$Bar$g$ {}$h$\n"));
+ EXPECT_TRUE(
+ Parse("$a$service $b$Foo$c$ {}$d$\n"
+ "$e$service $f$Bar$g$ {}$h$\n"));
EXPECT_TRUE(HasSpan('a', 'd', file_.service(0)));
EXPECT_TRUE(HasSpan('b', 'c', file_.service(0), "name"));
@@ -2922,11 +3079,11 @@
}
TEST_F(SourceInfoTest, MethodsAndStreams) {
- EXPECT_TRUE(Parse(
- "service Foo {\n"
- " $a$rpc $b$Bar$c$($d$X$e$) returns($f$Y$g$);$h$"
- " $i$rpc $j$Baz$k$($l$Z$m$) returns($n$W$o$);$p$"
- "}"));
+ EXPECT_TRUE(
+ Parse("service Foo {\n"
+ " $a$rpc $b$Bar$c$($d$X$e$) returns($f$Y$g$);$h$"
+ " $i$rpc $j$Baz$k$($l$Z$m$) returns($n$W$o$);$p$"
+ "}"));
const MethodDescriptorProto& bar = file_.service(0).method(0);
const MethodDescriptorProto& baz = file_.service(0).method(1);
@@ -2949,15 +3106,14 @@
TEST_F(SourceInfoTest, Options) {
- EXPECT_TRUE(Parse(
- "$a$option $b$foo$c$.$d$($e$bar.baz$f$)$g$ = "
- "$h$123$i$;$j$\n"
- "$k$option qux = $l$-123$m$;$n$\n"
- "$o$option corge = $p$abc$q$;$r$\n"
- "$s$option grault = $t$'blah'$u$;$v$\n"
- "$w$option garply = $x${ yadda yadda }$y$;$z$\n"
- "$0$option waldo = $1$123.0$2$;$3$\n"
- ));
+ EXPECT_TRUE(
+ Parse("$a$option $b$foo$c$.$d$($e$bar.baz$f$)$g$ = "
+ "$h$123$i$;$j$\n"
+ "$k$option qux = $l$-123$m$;$n$\n"
+ "$o$option corge = $p$abc$q$;$r$\n"
+ "$s$option grault = $t$'blah'$u$;$v$\n"
+ "$w$option garply = $x${ yadda yadda }$y$;$z$\n"
+ "$0$option waldo = $1$123.0$2$;$3$\n"));
const UninterpretedOption& option1 = file_.options().uninterpreted_option(0);
const UninterpretedOption& option2 = file_.options().uninterpreted_option(1);
@@ -3015,22 +3171,22 @@
}
TEST_F(SourceInfoTest, ScopedOptions) {
- EXPECT_TRUE(Parse(
- "message Foo {\n"
- " $a$option mopt = 1;$b$\n"
- "}\n"
- "enum Bar {\n"
- " $c$option eopt = 1;$d$\n"
- "}\n"
- "service Baz {\n"
- " $e$option sopt = 1;$f$\n"
- " rpc M(X) returns(Y) {\n"
- " $g$option mopt = 1;$h$\n"
- " }\n"
- " rpc MS4($1$stream$2$ X) returns($3$stream$4$ Y) {\n"
- " $k$option mopt = 1;$l$\n"
- " }\n"
- "}\n"));
+ EXPECT_TRUE(
+ Parse("message Foo {\n"
+ " $a$option mopt = 1;$b$\n"
+ "}\n"
+ "enum Bar {\n"
+ " $c$option eopt = 1;$d$\n"
+ "}\n"
+ "service Baz {\n"
+ " $e$option sopt = 1;$f$\n"
+ " rpc M(X) returns(Y) {\n"
+ " $g$option mopt = 1;$h$\n"
+ " }\n"
+ " rpc MS4($1$stream$2$ X) returns($3$stream$4$ Y) {\n"
+ " $k$option mopt = 1;$l$\n"
+ " }\n"
+ "}\n"));
EXPECT_TRUE(HasSpan('a', 'b', file_.message_type(0).options()));
EXPECT_TRUE(HasSpan('c', 'd', file_.enum_type(0).options()));
@@ -3041,87 +3197,89 @@
EXPECT_TRUE(HasSpan(file_));
EXPECT_TRUE(HasSpan(file_.message_type(0)));
EXPECT_TRUE(HasSpan(file_.message_type(0), "name"));
- EXPECT_TRUE(HasSpan(file_.message_type(0).options()
- .uninterpreted_option(0)));
- EXPECT_TRUE(HasSpan(file_.message_type(0).options()
- .uninterpreted_option(0), "name"));
- EXPECT_TRUE(HasSpan(file_.message_type(0).options()
- .uninterpreted_option(0).name(0)));
- EXPECT_TRUE(HasSpan(file_.message_type(0).options()
- .uninterpreted_option(0).name(0), "name_part"));
- EXPECT_TRUE(HasSpan(file_.message_type(0).options()
- .uninterpreted_option(0), "positive_int_value"));
+ EXPECT_TRUE(HasSpan(file_.message_type(0).options().uninterpreted_option(0)));
+ EXPECT_TRUE(
+ HasSpan(file_.message_type(0).options().uninterpreted_option(0), "name"));
+ EXPECT_TRUE(
+ HasSpan(file_.message_type(0).options().uninterpreted_option(0).name(0)));
+ EXPECT_TRUE(
+ HasSpan(file_.message_type(0).options().uninterpreted_option(0).name(0),
+ "name_part"));
+ EXPECT_TRUE(HasSpan(file_.message_type(0).options().uninterpreted_option(0),
+ "positive_int_value"));
EXPECT_TRUE(HasSpan(file_.enum_type(0)));
EXPECT_TRUE(HasSpan(file_.enum_type(0), "name"));
- EXPECT_TRUE(HasSpan(file_.enum_type(0).options()
- .uninterpreted_option(0)));
- EXPECT_TRUE(HasSpan(file_.enum_type(0).options()
- .uninterpreted_option(0), "name"));
- EXPECT_TRUE(HasSpan(file_.enum_type(0).options()
- .uninterpreted_option(0).name(0)));
- EXPECT_TRUE(HasSpan(file_.enum_type(0).options()
- .uninterpreted_option(0).name(0), "name_part"));
- EXPECT_TRUE(HasSpan(file_.enum_type(0).options()
- .uninterpreted_option(0), "positive_int_value"));
+ EXPECT_TRUE(HasSpan(file_.enum_type(0).options().uninterpreted_option(0)));
+ EXPECT_TRUE(
+ HasSpan(file_.enum_type(0).options().uninterpreted_option(0), "name"));
+ EXPECT_TRUE(
+ HasSpan(file_.enum_type(0).options().uninterpreted_option(0).name(0)));
+ EXPECT_TRUE(
+ HasSpan(file_.enum_type(0).options().uninterpreted_option(0).name(0),
+ "name_part"));
+ EXPECT_TRUE(HasSpan(file_.enum_type(0).options().uninterpreted_option(0),
+ "positive_int_value"));
EXPECT_TRUE(HasSpan(file_.service(0)));
EXPECT_TRUE(HasSpan(file_.service(0), "name"));
EXPECT_TRUE(HasSpan(file_.service(0).method(0)));
- EXPECT_TRUE(HasSpan(file_.service(0).options()
- .uninterpreted_option(0)));
- EXPECT_TRUE(HasSpan(file_.service(0).options()
- .uninterpreted_option(0), "name"));
- EXPECT_TRUE(HasSpan(file_.service(0).options()
- .uninterpreted_option(0).name(0)));
- EXPECT_TRUE(HasSpan(file_.service(0).options()
- .uninterpreted_option(0).name(0), "name_part"));
- EXPECT_TRUE(HasSpan(file_.service(0).options()
- .uninterpreted_option(0), "positive_int_value"));
+ EXPECT_TRUE(HasSpan(file_.service(0).options().uninterpreted_option(0)));
+ EXPECT_TRUE(
+ HasSpan(file_.service(0).options().uninterpreted_option(0), "name"));
+ EXPECT_TRUE(
+ HasSpan(file_.service(0).options().uninterpreted_option(0).name(0)));
+ EXPECT_TRUE(HasSpan(
+ file_.service(0).options().uninterpreted_option(0).name(0), "name_part"));
+ EXPECT_TRUE(HasSpan(file_.service(0).options().uninterpreted_option(0),
+ "positive_int_value"));
EXPECT_TRUE(HasSpan(file_.service(0).method(0), "name"));
EXPECT_TRUE(HasSpan(file_.service(0).method(0), "input_type"));
EXPECT_TRUE(HasSpan(file_.service(0).method(0), "output_type"));
- EXPECT_TRUE(HasSpan(file_.service(0).method(0).options()
- .uninterpreted_option(0)));
- EXPECT_TRUE(HasSpan(file_.service(0).method(0).options()
- .uninterpreted_option(0), "name"));
- EXPECT_TRUE(HasSpan(file_.service(0).method(0).options()
- .uninterpreted_option(0).name(0)));
- EXPECT_TRUE(HasSpan(file_.service(0).method(0).options()
- .uninterpreted_option(0).name(0), "name_part"));
- EXPECT_TRUE(HasSpan(file_.service(0).method(0).options()
- .uninterpreted_option(0), "positive_int_value"));
+ EXPECT_TRUE(
+ HasSpan(file_.service(0).method(0).options().uninterpreted_option(0)));
+ EXPECT_TRUE(HasSpan(
+ file_.service(0).method(0).options().uninterpreted_option(0), "name"));
+ EXPECT_TRUE(HasSpan(
+ file_.service(0).method(0).options().uninterpreted_option(0).name(0)));
+ EXPECT_TRUE(HasSpan(
+ file_.service(0).method(0).options().uninterpreted_option(0).name(0),
+ "name_part"));
+ EXPECT_TRUE(
+ HasSpan(file_.service(0).method(0).options().uninterpreted_option(0),
+ "positive_int_value"));
EXPECT_TRUE(HasSpan('k', 'l', file_.service(0).method(1).options()));
EXPECT_TRUE(HasSpan(file_.service(0).method(1)));
EXPECT_TRUE(HasSpan(file_.service(0).method(1), "name"));
EXPECT_TRUE(HasSpan(file_.service(0).method(1), "input_type"));
EXPECT_TRUE(HasSpan(file_.service(0).method(1), "output_type"));
- EXPECT_TRUE(HasSpan(file_.service(0).method(1).options()
- .uninterpreted_option(0)));
- EXPECT_TRUE(HasSpan(file_.service(0).method(1).options()
- .uninterpreted_option(0), "name"));
- EXPECT_TRUE(HasSpan(file_.service(0).method(1).options()
- .uninterpreted_option(0).name(0)));
- EXPECT_TRUE(HasSpan(file_.service(0).method(1).options()
- .uninterpreted_option(0).name(0), "name_part"));
- EXPECT_TRUE(HasSpan(file_.service(0).method(1).options()
- .uninterpreted_option(0), "positive_int_value"));
- EXPECT_TRUE(HasSpan('1', '2', file_.service(0).method(1),
- "client_streaming"));
- EXPECT_TRUE(HasSpan('3', '4', file_.service(0).method(1),
- "server_streaming"));
+ EXPECT_TRUE(
+ HasSpan(file_.service(0).method(1).options().uninterpreted_option(0)));
+ EXPECT_TRUE(HasSpan(
+ file_.service(0).method(1).options().uninterpreted_option(0), "name"));
+ EXPECT_TRUE(HasSpan(
+ file_.service(0).method(1).options().uninterpreted_option(0).name(0)));
+ EXPECT_TRUE(HasSpan(
+ file_.service(0).method(1).options().uninterpreted_option(0).name(0),
+ "name_part"));
+ EXPECT_TRUE(
+ HasSpan(file_.service(0).method(1).options().uninterpreted_option(0),
+ "positive_int_value"));
+ EXPECT_TRUE(
+ HasSpan('1', '2', file_.service(0).method(1), "client_streaming"));
+ EXPECT_TRUE(
+ HasSpan('3', '4', file_.service(0).method(1), "server_streaming"));
}
TEST_F(SourceInfoTest, FieldOptions) {
// The actual "name = value" pairs are parsed by the same code as for
// top-level options so we won't re-test that -- just make sure that the
// syntax used for field options is understood.
- EXPECT_TRUE(Parse(
- "message Foo {"
- " optional int32 bar = 1 "
- "$a$[default=$b$123$c$,$d$opt1=123$e$,"
- "$f$opt2='hi'$g$]$h$;"
- "}\n"
- ));
+ EXPECT_TRUE(
+ Parse("message Foo {"
+ " optional int32 bar = 1 "
+ "$a$[default=$b$123$c$,$d$opt1=123$e$,"
+ "$f$opt2='hi'$g$]$h$;"
+ "}\n"));
const FieldDescriptorProto& field = file_.message_type(0).field(0);
const UninterpretedOption& option1 = field.options().uninterpreted_option(0);
@@ -3155,11 +3313,10 @@
// The actual "name = value" pairs are parsed by the same code as for
// top-level options so we won't re-test that -- just make sure that the
// syntax used for enum options is understood.
- EXPECT_TRUE(Parse(
- "enum Foo {"
- " BAR = 1 $a$[$b$opt1=123$c$,$d$opt2='hi'$e$]$f$;"
- "}\n"
- ));
+ EXPECT_TRUE(
+ Parse("enum Foo {"
+ " BAR = 1 $a$[$b$opt1=123$c$,$d$opt2='hi'$e$]$f$;"
+ "}\n"));
const EnumValueDescriptorProto& value = file_.enum_type(0).value(0);
const UninterpretedOption& option1 = value.options().uninterpreted_option(0);
@@ -3187,33 +3344,28 @@
}
TEST_F(SourceInfoTest, DocComments) {
- EXPECT_TRUE(Parse(
- "// Foo leading\n"
- "// line 2\n"
- "$a$message Foo {\n"
- " // Foo trailing\n"
- " // line 2\n"
- "\n"
- " // detached\n"
- "\n"
- " // bar leading\n"
- " $b$optional int32 bar = 1;$c$\n"
- " // bar trailing\n"
- "}$d$\n"
- "// ignored\n"
- ));
+ EXPECT_TRUE(
+ Parse("// Foo leading\n"
+ "// line 2\n"
+ "$a$message Foo {\n"
+ " // Foo trailing\n"
+ " // line 2\n"
+ "\n"
+ " // detached\n"
+ "\n"
+ " // bar leading\n"
+ " $b$optional int32 bar = 1;$c$\n"
+ " // bar trailing\n"
+ "}$d$\n"
+ "// ignored\n"));
const DescriptorProto& foo = file_.message_type(0);
const FieldDescriptorProto& bar = foo.field(0);
- EXPECT_TRUE(HasSpanWithComment('a', 'd', foo,
- " Foo leading\n line 2\n",
- " Foo trailing\n line 2\n",
- NULL));
- EXPECT_TRUE(HasSpanWithComment('b', 'c', bar,
- " bar leading\n",
- " bar trailing\n",
- " detached\n"));
+ EXPECT_TRUE(HasSpanWithComment('a', 'd', foo, " Foo leading\n line 2\n",
+ " Foo trailing\n line 2\n", NULL));
+ EXPECT_TRUE(HasSpanWithComment('b', 'c', bar, " bar leading\n",
+ " bar trailing\n", " detached\n"));
// Ignore these.
EXPECT_TRUE(HasSpan(file_));
@@ -3225,45 +3377,40 @@
}
TEST_F(SourceInfoTest, DocComments2) {
- EXPECT_TRUE(Parse(
- "// detached before message.\n"
- "\n"
- "// Foo leading\n"
- "// line 2\n"
- "$a$message Foo {\n"
- " /* Foo trailing\n"
- " * line 2 */\n"
- " // detached\n"
- " /* bar leading\n"
- " */"
- " $b$optional int32 bar = 1;$c$ // bar trailing\n"
- " // ignored detached\n"
- "}$d$\n"
- "// ignored\n"
- "\n"
- "// detached before option\n"
- "\n"
- "// option leading\n"
- "$e$option baz = 123;$f$\n"
- "// option trailing\n"
- ));
+ EXPECT_TRUE(
+ Parse("// detached before message.\n"
+ "\n"
+ "// Foo leading\n"
+ "// line 2\n"
+ "$a$message Foo {\n"
+ " /* Foo trailing\n"
+ " * line 2 */\n"
+ " // detached\n"
+ " /* bar leading\n"
+ " */"
+ " $b$optional int32 bar = 1;$c$ // bar trailing\n"
+ " // ignored detached\n"
+ "}$d$\n"
+ "// ignored\n"
+ "\n"
+ "// detached before option\n"
+ "\n"
+ "// option leading\n"
+ "$e$option baz = 123;$f$\n"
+ "// option trailing\n"));
const DescriptorProto& foo = file_.message_type(0);
const FieldDescriptorProto& bar = foo.field(0);
const UninterpretedOption& baz = file_.options().uninterpreted_option(0);
- EXPECT_TRUE(HasSpanWithComment('a', 'd', foo,
- " Foo leading\n line 2\n",
- " Foo trailing\n line 2 ",
- " detached before message.\n"));
- EXPECT_TRUE(HasSpanWithComment('b', 'c', bar,
- " bar leading\n",
- " bar trailing\n",
- " detached\n"));
- EXPECT_TRUE(HasSpanWithComment('e', 'f', baz,
- " option leading\n",
- " option trailing\n",
- " detached before option\n"));
+ EXPECT_TRUE(HasSpanWithComment('a', 'd', foo, " Foo leading\n line 2\n",
+ " Foo trailing\n line 2 ",
+ " detached before message.\n"));
+ EXPECT_TRUE(HasSpanWithComment('b', 'c', bar, " bar leading\n",
+ " bar trailing\n", " detached\n"));
+ EXPECT_TRUE(HasSpanWithComment('e', 'f', baz, " option leading\n",
+ " option trailing\n",
+ " detached before option\n"));
// Ignore these.
EXPECT_TRUE(HasSpan(file_));
@@ -3280,22 +3427,19 @@
}
TEST_F(SourceInfoTest, DocComments3) {
- EXPECT_TRUE(Parse(
- "$a$message Foo {\n"
- " // bar leading\n"
- " $b$optional int32 bar = 1 [(baz.qux) = {}];$c$\n"
- " // bar trailing\n"
- "}$d$\n"
- "// ignored\n"
- ));
+ EXPECT_TRUE(
+ Parse("$a$message Foo {\n"
+ " // bar leading\n"
+ " $b$optional int32 bar = 1 [(baz.qux) = {}];$c$\n"
+ " // bar trailing\n"
+ "}$d$\n"
+ "// ignored\n"));
const DescriptorProto& foo = file_.message_type(0);
const FieldDescriptorProto& bar = foo.field(0);
- EXPECT_TRUE(HasSpanWithComment('b', 'c', bar,
- " bar leading\n",
- " bar trailing\n",
- NULL));
+ EXPECT_TRUE(HasSpanWithComment('b', 'c', bar, " bar leading\n",
+ " bar trailing\n", NULL));
// Ignore these.
EXPECT_TRUE(HasSpan(file_));
@@ -3309,88 +3453,82 @@
EXPECT_TRUE(HasSpan(bar.options().uninterpreted_option(0)));
EXPECT_TRUE(HasSpan(bar.options().uninterpreted_option(0), "name"));
EXPECT_TRUE(HasSpan(bar.options().uninterpreted_option(0).name(0)));
- EXPECT_TRUE(HasSpan(
- bar.options().uninterpreted_option(0).name(0), "name_part"));
- EXPECT_TRUE(HasSpan(
- bar.options().uninterpreted_option(0), "aggregate_value"));
+ EXPECT_TRUE(
+ HasSpan(bar.options().uninterpreted_option(0).name(0), "name_part"));
+ EXPECT_TRUE(
+ HasSpan(bar.options().uninterpreted_option(0), "aggregate_value"));
}
TEST_F(SourceInfoTest, DocCommentsTopLevel) {
- EXPECT_TRUE(Parse(
- "// detached before syntax paragraph 1\n"
- "\n"
- "// detached before syntax paragraph 2\n"
- "\n"
- "// syntax leading\n"
- "$a$syntax = \"proto2\";$b$\n"
- "// syntax trailing\n"
- "\n"
- "// syntax-package detached comments\n"
- "\n"
- ";\n"
- "\n"
- "// detached after empty before package\n"
- "\n"
- "// package leading\n"
- "$c$package foo;$d$\n"
- "// package trailing\n"
- "\n"
- "// ignored detach\n"
- "\n"));
+ EXPECT_TRUE(
+ Parse("// detached before syntax paragraph 1\n"
+ "\n"
+ "// detached before syntax paragraph 2\n"
+ "\n"
+ "// syntax leading\n"
+ "$a$syntax = \"proto2\";$b$\n"
+ "// syntax trailing\n"
+ "\n"
+ "// syntax-package detached comments\n"
+ "\n"
+ ";\n"
+ "\n"
+ "// detached after empty before package\n"
+ "\n"
+ "// package leading\n"
+ "$c$package foo;$d$\n"
+ "// package trailing\n"
+ "\n"
+ "// ignored detach\n"
+ "\n"));
- EXPECT_TRUE(HasSpan('a', 'b', file_, "syntax", -1,
- " syntax leading\n",
- " syntax trailing\n",
- " detached before syntax paragraph 1\n"
- "\n"
- " detached before syntax paragraph 2\n"));
- EXPECT_TRUE(HasSpan('c', 'd', file_, "package", -1,
- " package leading\n",
- " package trailing\n",
- " syntax-package detached comments\n"
- "\n"
- " detached after empty before package\n"));
+ EXPECT_TRUE(HasSpan('a', 'b', file_, "syntax", -1, " syntax leading\n",
+ " syntax trailing\n",
+ " detached before syntax paragraph 1\n"
+ "\n"
+ " detached before syntax paragraph 2\n"));
+ EXPECT_TRUE(HasSpan('c', 'd', file_, "package", -1, " package leading\n",
+ " package trailing\n",
+ " syntax-package detached comments\n"
+ "\n"
+ " detached after empty before package\n"));
// ignore these.
EXPECT_TRUE(HasSpan(file_));
}
TEST_F(SourceInfoTest, DocCommentsOneof) {
- EXPECT_TRUE(Parse(
- "// Foo leading\n"
- "$a$message Foo {\n"
- " /* Foo trailing\n"
- " */\n"
- " // detached before oneof\n"
- " /* bar leading\n"
- " * line 2 */\n"
- " $b$oneof bar {\n"
- " /* bar trailing\n"
- " * line 2 */\n"
- " // detached before bar_int\n"
- " /* bar_int leading\n"
- " */\n"
- " $c$int32 bar_int = 1;$d$ // bar_int trailing\n"
- " // detach comment ignored\n"
- " }$e$\n"
- "}$f$\n"));
+ EXPECT_TRUE(
+ Parse("// Foo leading\n"
+ "$a$message Foo {\n"
+ " /* Foo trailing\n"
+ " */\n"
+ " // detached before oneof\n"
+ " /* bar leading\n"
+ " * line 2 */\n"
+ " $b$oneof bar {\n"
+ " /* bar trailing\n"
+ " * line 2 */\n"
+ " // detached before bar_int\n"
+ " /* bar_int leading\n"
+ " */\n"
+ " $c$int32 bar_int = 1;$d$ // bar_int trailing\n"
+ " // detach comment ignored\n"
+ " }$e$\n"
+ "}$f$\n"));
const DescriptorProto& foo = file_.message_type(0);
const OneofDescriptorProto& bar = foo.oneof_decl(0);
const FieldDescriptorProto& bar_int = foo.field(0);
- EXPECT_TRUE(HasSpanWithComment('a', 'f', foo,
- " Foo leading\n",
- " Foo trailing\n",
- NULL));
- EXPECT_TRUE(HasSpanWithComment('b', 'e', bar,
- " bar leading\n line 2 ",
- " bar trailing\n line 2 ",
- " detached before oneof\n"));
- EXPECT_TRUE(HasSpanWithComment('c', 'd', bar_int,
- " bar_int leading\n",
- " bar_int trailing\n",
- " detached before bar_int\n"));
+ EXPECT_TRUE(HasSpanWithComment('a', 'f', foo, " Foo leading\n",
+ " Foo trailing\n", NULL));
+ EXPECT_TRUE(HasSpanWithComment('b', 'e', bar, " bar leading\n line 2 ",
+ " bar trailing\n line 2 ",
+ " detached before oneof\n"));
+ EXPECT_TRUE(HasSpanWithComment('c', 'd', bar_int, " bar_int leading\n",
+ " bar_int trailing\n",
+ " detached before bar_int\n"));
// Ignore these.
EXPECT_TRUE(HasSpan(file_));
diff --git a/src/google/protobuf/compiler/plugin.cc b/src/google/protobuf/compiler/plugin.cc
index 3504875..ac383f8 100644
--- a/src/google/protobuf/compiler/plugin.cc
+++ b/src/google/protobuf/compiler/plugin.cc
@@ -45,9 +45,9 @@
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/compiler/plugin.pb.h>
#include <google/protobuf/compiler/code_generator.h>
+#include <google/protobuf/io/io_win32.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/descriptor.h>
-#include <google/protobuf/stubs/io_win32.h>
namespace google {
@@ -57,14 +57,13 @@
#if defined(_WIN32)
// DO NOT include <io.h>, instead create functions in io_win32.{h,cc} and import
// them like we do below.
-using google::protobuf::internal::win32::setmode;
+using google::protobuf::io::win32::setmode;
#endif
class GeneratorResponseContext : public GeneratorContext {
public:
GeneratorResponseContext(
- const Version& compiler_version,
- CodeGeneratorResponse* response,
+ const Version& compiler_version, CodeGeneratorResponse* response,
const std::vector<const FileDescriptor*>& parsed_files)
: compiler_version_(compiler_version),
response_(response),
@@ -117,24 +116,26 @@
for (int i = 0; i < request.file_to_generate_size(); i++) {
parsed_files.push_back(pool.FindFileByName(request.file_to_generate(i)));
if (parsed_files.back() == NULL) {
- *error_msg = "protoc asked plugin to generate a file but "
- "did not provide a descriptor for the file: " +
- request.file_to_generate(i);
+ *error_msg =
+ "protoc asked plugin to generate a file but "
+ "did not provide a descriptor for the file: " +
+ request.file_to_generate(i);
return false;
}
}
- GeneratorResponseContext context(
- request.compiler_version(), response, parsed_files);
+ GeneratorResponseContext context(request.compiler_version(), response,
+ parsed_files);
std::string error;
- bool succeeded = generator.GenerateAll(
- parsed_files, request.parameter(), &context, &error);
+ bool succeeded = generator.GenerateAll(parsed_files, request.parameter(),
+ &context, &error);
if (!succeeded && error.empty()) {
- error = "Code generator returned false but provided no error "
- "description.";
+ error =
+ "Code generator returned false but provided no error "
+ "description.";
}
if (!error.empty()) {
response->set_error(error);
diff --git a/src/google/protobuf/compiler/plugin.h b/src/google/protobuf/compiler/plugin.h
index 0eed2df..69c5d3f 100644
--- a/src/google/protobuf/compiler/plugin.h
+++ b/src/google/protobuf/compiler/plugin.h
@@ -70,7 +70,7 @@
namespace protobuf {
namespace compiler {
-class CodeGenerator; // code_generator.h
+class CodeGenerator; // code_generator.h
class CodeGeneratorRequest;
class CodeGeneratorResponse;
diff --git a/src/google/protobuf/compiler/plugin.pb.cc b/src/google/protobuf/compiler/plugin.pb.cc
index 4759473..16ea252 100644
--- a/src/google/protobuf/compiler/plugin.pb.cc
+++ b/src/google/protobuf/compiler/plugin.pb.cc
@@ -98,13 +98,6 @@
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsCodeGeneratorResponse_google_2fprotobuf_2fcompiler_2fplugin_2eproto}, {
&scc_info_CodeGeneratorResponse_File_google_2fprotobuf_2fcompiler_2fplugin_2eproto.base,}};
-void InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Version_google_2fprotobuf_2fcompiler_2fplugin_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CodeGeneratorRequest_google_2fprotobuf_2fcompiler_2fplugin_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CodeGeneratorResponse_File_google_2fprotobuf_2fcompiler_2fplugin_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CodeGeneratorResponse_google_2fprotobuf_2fcompiler_2fplugin_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2fcompiler_2fplugin_2eproto[4];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2fcompiler_2fplugin_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fcompiler_2fplugin_2eproto = nullptr;
@@ -196,8 +189,7 @@
"rotobuf/protoc-gen-go/plugin;plugin_go"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto = {
- false, InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2fcompiler_2fplugin_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2fcompiler_2fplugin_2eproto,
"google/protobuf/compiler/plugin.proto", &assign_descriptors_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto, 638,
};
@@ -206,6 +198,10 @@
{
::AddDescriptors_google_2fprotobuf_2fdescriptor_2eproto,
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Version_google_2fprotobuf_2fcompiler_2fplugin_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CodeGeneratorRequest_google_2fprotobuf_2fcompiler_2fplugin_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CodeGeneratorResponse_File_google_2fprotobuf_2fcompiler_2fplugin_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CodeGeneratorResponse_google_2fprotobuf_2fcompiler_2fplugin_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto, deps, 1);
}
@@ -220,17 +216,18 @@
}
class Version::HasBitSetters {
public:
- static void set_has_major(Version* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ using HasBits = decltype(std::declval<Version>()._has_bits_);
+ static void set_has_major(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
- static void set_has_minor(Version* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_minor(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
- static void set_has_patch(Version* msg) {
- msg->_has_bits_[0] |= 0x00000008u;
+ static void set_has_patch(HasBits* has_bits) {
+ (*has_bits)[0] |= 8u;
}
- static void set_has_suffix(Version* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ static void set_has_suffix(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
};
@@ -309,52 +306,63 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Version::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional int32 major = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_major(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_major(&has_bits);
+ major_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional int32 minor = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_minor(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_minor(&has_bits);
+ minor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional int32 patch = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 24) goto handle_unusual;
- set_patch(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_patch(&has_bits);
+ patch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional string suffix = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_suffix(), ptr, ctx, "google.protobuf.compiler.Version.suffix");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Version::MergePartialFromCodedStream(
@@ -370,7 +378,7 @@
// optional int32 major = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
- HasBitSetters::set_has_major(this);
+ HasBitSetters::set_has_major(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &major_)));
@@ -383,7 +391,7 @@
// optional int32 minor = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
- HasBitSetters::set_has_minor(this);
+ HasBitSetters::set_has_minor(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &minor_)));
@@ -396,7 +404,7 @@
// optional int32 patch = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
- HasBitSetters::set_has_patch(this);
+ HasBitSetters::set_has_patch(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &patch_)));
@@ -659,12 +667,13 @@
}
class CodeGeneratorRequest::HasBitSetters {
public:
- static void set_has_parameter(CodeGeneratorRequest* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<CodeGeneratorRequest>()._has_bits_);
+ static void set_has_parameter(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
static const PROTOBUF_NAMESPACE_ID::compiler::Version& compiler_version(const CodeGeneratorRequest* msg);
- static void set_has_compiler_version(CodeGeneratorRequest* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_compiler_version(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -756,58 +765,70 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* CodeGeneratorRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// repeated string file_to_generate = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
- do {
+ while (true) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(add_file_to_generate(), ptr, ctx, "google.protobuf.compiler.CodeGeneratorRequest.file_to_generate");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 10 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 10) break;
+ ptr += 1;
+ }
break;
}
// optional string parameter = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_parameter(), ptr, ctx, "google.protobuf.compiler.CodeGeneratorRequest.parameter");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional .google.protobuf.compiler.Version compiler_version = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_compiler_version(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
case 15: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 122) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_proto_file(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 122 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 122) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool CodeGeneratorRequest::MergePartialFromCodedStream(
@@ -1130,14 +1151,15 @@
}
class CodeGeneratorResponse_File::HasBitSetters {
public:
- static void set_has_name(CodeGeneratorResponse_File* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<CodeGeneratorResponse_File>()._has_bits_);
+ static void set_has_name(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_insertion_point(CodeGeneratorResponse_File* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_insertion_point(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
- static void set_has_content(CodeGeneratorResponse_File* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_content(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
};
@@ -1224,45 +1246,53 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* CodeGeneratorResponse_File::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name(), ptr, ctx, "google.protobuf.compiler.CodeGeneratorResponse.File.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string insertion_point = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_insertion_point(), ptr, ctx, "google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string content = 15;
case 15: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 122) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_content(), ptr, ctx, "google.protobuf.compiler.CodeGeneratorResponse.File.content");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool CodeGeneratorResponse_File::MergePartialFromCodedStream(
@@ -1560,8 +1590,9 @@
}
class CodeGeneratorResponse::HasBitSetters {
public:
- static void set_has_error(CodeGeneratorResponse* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<CodeGeneratorResponse>()._has_bits_);
+ static void set_has_error(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
};
@@ -1629,41 +1660,51 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* CodeGeneratorResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional string error = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_error(), ptr, ctx, "google.protobuf.compiler.CodeGeneratorResponse.error");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
case 15: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 122) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_file(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 122 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 122) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool CodeGeneratorResponse::MergePartialFromCodedStream(
diff --git a/src/google/protobuf/compiler/python/python_generator.cc b/src/google/protobuf/compiler/python/python_generator.cc
index f652ef6..cf5b7f6 100644
--- a/src/google/protobuf/compiler/python/python_generator.cc
+++ b/src/google/protobuf/compiler/python/python_generator.cc
@@ -114,7 +114,7 @@
"class", "continue", "def", "del", "elif", "else", "except",
"finally", "for", "from", "global", "if", "import", "in",
"is", "lambda", "nonlocal", "not", "or", "pass", "raise",
- "return", "try", "while", "with", "yield",
+ "return", "try", "while", "with", "yield", "print",
};
const char* const* kKeywordsEnd =
kKeywords + (sizeof(kKeywords) / sizeof(kKeywords[0]));
@@ -129,6 +129,17 @@
return false;
}
+inline bool IsPythonKeyword(const string& name) {
+ return (std::find(kKeywords, kKeywordsEnd, name) != kKeywordsEnd);
+}
+
+std::string ResolveKeyword(const std::string& name) {
+ if (IsPythonKeyword(name)) {
+ return "globals()['" + name + "']";
+ }
+ return name;
+}
+
// Returns the name of all containing types for descriptor,
// in order from outermost to innermost, followed by descriptor's
// own name. Each name is separated by |separator|.
@@ -136,9 +147,17 @@
std::string NamePrefixedWithNestedTypes(const DescriptorT& descriptor,
const std::string& separator) {
std::string name = descriptor.name();
- for (const Descriptor* current = descriptor.containing_type();
- current != NULL; current = current->containing_type()) {
- name = current->name() + separator + name;
+ const Descriptor* parent = descriptor.containing_type();
+ if (parent != nullptr) {
+ std::string prefix = NamePrefixedWithNestedTypes(*parent, separator);
+ if (separator == "." && IsPythonKeyword(name)) {
+ return "getattr(" + prefix + ", '" + name + "')";
+ } else {
+ return prefix + separator + name;
+ }
+ }
+ if (separator == ".") {
+ name = ResolveKeyword(name);
}
return name;
}
@@ -149,30 +168,27 @@
// in proto2/public/reflection.py.
const char kDescriptorKey[] = "DESCRIPTOR";
-
// Does the file have top-level enums?
-inline bool HasTopLevelEnums(const FileDescriptor *file) {
+inline bool HasTopLevelEnums(const FileDescriptor* file) {
return file->enum_type_count() > 0;
}
-
// Should we generate generic services for this file?
-inline bool HasGenericServices(const FileDescriptor *file) {
- return file->service_count() > 0 &&
- file->options().py_generic_services();
+inline bool HasGenericServices(const FileDescriptor* file) {
+ return file->service_count() > 0 && file->options().py_generic_services();
}
-
// Prints the common boilerplate needed at the top of every .py
// file output by this generator.
-void PrintTopBoilerplate(
- io::Printer* printer, const FileDescriptor* file, bool descriptor_proto) {
+void PrintTopBoilerplate(io::Printer* printer, const FileDescriptor* file,
+ bool descriptor_proto) {
// TODO(robinson): Allow parameterization of Python version?
printer->Print(
"# -*- coding: utf-8 -*-\n"
"# Generated by the protocol buffer compiler. DO NOT EDIT!\n"
"# source: $filename$\n"
- "\nimport sys\n_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))" //##PY25
+ "\nimport sys\n_b=sys.version_info[0]<3 and (lambda x:x) or (lambda "
+ "x:x.encode('latin1'))" //##PY25
"\n",
"filename", file->name());
if (HasTopLevelEnums(file)) {
@@ -197,7 +213,6 @@
printer->Print("\n\n");
}
-
// Returns a Python literal giving the default value for a field.
// If the field specifies no explicit default value, we'll return
// the default default value for the field type (zero for numbers,
@@ -259,12 +274,14 @@
case FieldDescriptor::CPPTYPE_ENUM:
return StrCat(field.default_value_enum()->number());
case FieldDescriptor::CPPTYPE_STRING:
-//##!PY25 return "b\"" + CEscape(field.default_value_string()) +
-//##!PY25 (field.type() != FieldDescriptor::TYPE_STRING ? "\"" :
-//##!PY25 "\".decode('utf-8')");
+ //##!PY25 return "b\"" + CEscape(field.default_value_string())
+ //+
+ //##!PY25 (field.type() != FieldDescriptor::TYPE_STRING ? "\""
+ //:
+ //##!PY25 "\".decode('utf-8')");
return "_b(\"" + CEscape(field.default_value_string()) + //##PY25
(field.type() != FieldDescriptor::TYPE_STRING ? "\")" : //##PY25
- "\").decode('utf-8')"); //##PY25
+ "\").decode('utf-8')"); //##PY25
case FieldDescriptor::CPPTYPE_MESSAGE:
return "None";
}
@@ -290,12 +307,9 @@
} // namespace
+Generator::Generator() : file_(NULL) {}
-Generator::Generator() : file_(NULL) {
-}
-
-Generator::~Generator() {
-}
+Generator::~Generator() {}
bool Generator::Generate(const FileDescriptor* file,
const std::string& parameter,
@@ -349,8 +363,7 @@
PrintServices();
}
- printer.Print(
- "# @@protoc_insertion_point(module_scope)\n");
+ printer.Print("# @@protoc_insertion_point(module_scope)\n");
return !printer.failed();
}
@@ -363,9 +376,7 @@
void StripThirdPartyPy(std::string* module_name) {
const std::string third_party_py_prefix = "google3.third_party.py.";
int len = third_party_py_prefix.length();
- if (module_name->compare(0, len,
- third_party_py_prefix, 0,
- len) == 0) {
+ if (module_name->compare(0, len, third_party_py_prefix, 0, len) == 0) {
*module_name = module_name->erase(0, len);
}
}
@@ -474,11 +485,11 @@
for (int i = 0; i < file_->enum_type_count(); ++i) {
const EnumDescriptor& enum_descriptor = *file_->enum_type(i);
PrintEnum(enum_descriptor);
- printer_->Print("$name$ = "
- "enum_type_wrapper.EnumTypeWrapper($descriptor_name$)",
- "name", enum_descriptor.name(),
- "descriptor_name",
- ModuleLevelDescriptorName(enum_descriptor));
+ printer_->Print(
+ "$name$ = "
+ "enum_type_wrapper.EnumTypeWrapper($descriptor_name$)",
+ "name", ResolveKeyword(enum_descriptor.name()), "descriptor_name",
+ ModuleLevelDescriptorName(enum_descriptor));
printer_->Print("\n");
for (int j = 0; j < enum_descriptor.value_count(); ++j) {
@@ -490,7 +501,7 @@
for (int i = 0; i < top_level_enum_values.size(); ++i) {
printer_->Print("$name$ = $value$\n", "name",
- top_level_enum_values[i].first, "value",
+ ResolveKeyword(top_level_enum_values[i].first), "value",
StrCat(top_level_enum_values[i].second));
}
printer_->Print("\n");
@@ -533,8 +544,7 @@
printer_->Outdent();
printer_->Print("],\n");
printer_->Print("containing_type=None,\n");
- printer_->Print("serialized_options=$options_value$,\n",
- "options_value",
+ printer_->Print("serialized_options=$options_value$,\n", "options_value",
OptionsValue(options_string));
EnumDescriptorProto edp;
PrintSerializedPbInterval(enum_descriptor, edp);
@@ -566,7 +576,8 @@
printer_->Print("$constant_name$ = $number$\n", "constant_name",
constant_name, "number",
StrCat(extension_field.number()));
- printer_->Print("$name$ = ", "name", extension_field.name());
+ printer_->Print("$name$ = ", "name",
+ ResolveKeyword(extension_field.name()));
PrintFieldDescriptor(extension_field, is_extension);
printer_->Print("\n");
}
@@ -604,9 +615,8 @@
std::string options_string;
descriptor.options().SerializeToString(&options_string);
- printer_->Print(
- "$service_name$ = _descriptor.ServiceDescriptor(\n",
- "service_name", service_name);
+ printer_->Print("$service_name$ = _descriptor.ServiceDescriptor(\n",
+ "service_name", service_name);
printer_->Indent();
std::map<std::string, std::string> m;
m["name"] = descriptor.name();
@@ -640,15 +650,14 @@
m["options_value"] = OptionsValue(options_string);
printer_->Print("_descriptor.MethodDescriptor(\n");
printer_->Indent();
- printer_->Print(
- m,
- "name='$name$',\n"
- "full_name='$full_name$',\n"
- "index=$index$,\n"
- "containing_service=None,\n"
- "input_type=$input_type$,\n"
- "output_type=$output_type$,\n"
- "serialized_options=$options_value$,\n");
+ printer_->Print(m,
+ "name='$name$',\n"
+ "full_name='$full_name$',\n"
+ "index=$index$,\n"
+ "containing_service=None,\n"
+ "input_type=$input_type$,\n"
+ "output_type=$output_type$,\n"
+ "serialized_options=$options_value$,\n");
printer_->Outdent();
printer_->Print("),\n");
}
@@ -660,23 +669,21 @@
printer_->Print("\n");
}
-
void Generator::PrintDescriptorKeyAndModuleName(
const ServiceDescriptor& descriptor) const {
- printer_->Print(
- "$descriptor_key$ = $descriptor_name$,\n",
- "descriptor_key", kDescriptorKey,
- "descriptor_name", ModuleLevelServiceDescriptorName(descriptor));
- printer_->Print(
- "__module__ = '$module_name$'\n",
- "module_name", ModuleName(file_->name()));
+ printer_->Print("$descriptor_key$ = $descriptor_name$,\n", "descriptor_key",
+ kDescriptorKey, "descriptor_name",
+ ModuleLevelServiceDescriptorName(descriptor));
+ printer_->Print("__module__ = '$module_name$'\n", "module_name",
+ ModuleName(file_->name()));
}
void Generator::PrintServiceClass(const ServiceDescriptor& descriptor) const {
// Print the service.
- printer_->Print("$class_name$ = service_reflection.GeneratedServiceType("
- "'$class_name$', (_service.Service,), dict(\n",
- "class_name", descriptor.name());
+ printer_->Print(
+ "$class_name$ = service_reflection.GeneratedServiceType("
+ "'$class_name$', (_service.Service,), dict(\n",
+ "class_name", descriptor.name());
printer_->Indent();
Generator::PrintDescriptorKeyAndModuleName(descriptor);
printer_->Print("))\n\n");
@@ -685,10 +692,11 @@
void Generator::PrintServiceStub(const ServiceDescriptor& descriptor) const {
// Print the service stub.
- printer_->Print("$class_name$_Stub = "
- "service_reflection.GeneratedServiceStubType("
- "'$class_name$_Stub', ($class_name$,), dict(\n",
- "class_name", descriptor.name());
+ printer_->Print(
+ "$class_name$_Stub = "
+ "service_reflection.GeneratedServiceStubType("
+ "'$class_name$_Stub', ($class_name$,), dict(\n",
+ "class_name", descriptor.name());
printer_->Indent();
Generator::PrintDescriptorKeyAndModuleName(descriptor);
printer_->Print("))\n\n");
@@ -747,9 +755,8 @@
"serialized_options=$options_value$,\n"
"is_extendable=$extendable$,\n"
"syntax='$syntax$'",
- "options_value", OptionsValue(options_string),
- "extendable", message_descriptor.extension_range_count() > 0 ?
- "True" : "False",
+ "options_value", OptionsValue(options_string), "extendable",
+ message_descriptor.extension_range_count() > 0 ? "True" : "False",
"syntax", StringifySyntax(message_descriptor.file()->syntax()));
printer_->Print(",\n");
@@ -777,12 +784,11 @@
} else {
m["serialized_options"] = ", serialized_options=" + options_string;
}
- printer_->Print(
- m,
- "_descriptor.OneofDescriptor(\n"
- " name='$name$', full_name='$full_name$',\n"
- " index=$index$, containing_type=None, "
- "fields=[]$serialized_options$),\n");
+ printer_->Print(m,
+ "_descriptor.OneofDescriptor(\n"
+ " name='$name$', full_name='$full_name$',\n"
+ " index=$index$, containing_type=None, "
+ "fields=[]$serialized_options$),\n");
}
printer_->Outdent();
printer_->Print("],\n");
@@ -812,7 +818,7 @@
PrintMessage(*file_->message_type(i), "", &to_register, false);
for (int j = 0; j < to_register.size(); ++j) {
printer_->Print("_sym_db.RegisterMessage($name$)\n", "name",
- to_register[j]);
+ ResolveKeyword(to_register[j]));
}
printer_->Print("\n");
}
@@ -830,28 +836,36 @@
const std::string& prefix,
std::vector<std::string>* to_register,
bool is_nested) const {
- std::string qualified_name(prefix + message_descriptor.name());
- to_register->push_back(qualified_name);
+ std::string qualified_name;
if (is_nested) {
+ if (IsPythonKeyword(message_descriptor.name())) {
+ qualified_name =
+ "getattr(" + prefix + ", '" + message_descriptor.name() + "')";
+ } else {
+ qualified_name = prefix + "." + message_descriptor.name();
+ }
printer_->Print(
"'$name$' : _reflection.GeneratedProtocolMessageType('$name$', "
"(_message.Message,), {\n",
"name", message_descriptor.name());
} else {
+ qualified_name = ResolveKeyword(message_descriptor.name());
printer_->Print(
- "$name$ = _reflection.GeneratedProtocolMessageType('$name$', "
+ "$qualified_name$ = _reflection.GeneratedProtocolMessageType('$name$', "
"(_message.Message,), {\n",
- "name", message_descriptor.name());
+ "qualified_name", qualified_name, "name", message_descriptor.name());
}
printer_->Indent();
- PrintNestedMessages(message_descriptor, qualified_name + ".", to_register);
+ to_register->push_back(qualified_name);
+
+ PrintNestedMessages(message_descriptor, qualified_name, to_register);
std::map<std::string, std::string> m;
m["descriptor_key"] = kDescriptorKey;
m["descriptor_name"] = ModuleLevelDescriptorName(message_descriptor);
printer_->Print(m, "'$descriptor_key$' : $descriptor_name$,\n");
- printer_->Print("'__module__' : '$module_name$'\n",
- "module_name", ModuleName(file_->name()));
+ printer_->Print("'__module__' : '$module_name$'\n", "module_name",
+ ModuleName(file_->name()));
printer_->Print("# @@protoc_insertion_point(class_scope:$full_name$)\n",
"full_name", message_descriptor.full_name());
printer_->Print("})\n");
@@ -954,9 +968,10 @@
std::map<std::string, std::string> m;
m["descriptor_name"] = kDescriptorKey;
m["field_name"] = descriptor.name();
+ m["resolved_name"] = ResolveKeyword(descriptor.name());
const char file_descriptor_template[] =
"$descriptor_name$.extensions_by_name['$field_name$'] = "
- "$field_name$\n";
+ "$resolved_name$\n";
printer_->Print(m, file_descriptor_template);
}
@@ -1002,15 +1017,14 @@
const std::string& python_dict_name) const {
// We should only ever be looking up fields in the current file.
// The only things we refer to from other files are message descriptors.
- GOOGLE_CHECK_EQ(field.file(), file_) << field.file()->name() << " vs. "
- << file_->name();
+ GOOGLE_CHECK_EQ(field.file(), file_)
+ << field.file()->name() << " vs. " << file_->name();
if (!containing_type) {
- return field.name();
+ return ResolveKeyword(field.name());
}
- return strings::Substitute(
- "$0.$1['$2']",
- ModuleLevelDescriptorName(*containing_type),
- python_dict_name, field.name());
+ return strings::Substitute("$0.$1['$2']",
+ ModuleLevelDescriptorName(*containing_type),
+ python_dict_name, field.name());
}
// Prints containing_type for nested descriptors or enum descriptors.
@@ -1022,10 +1036,8 @@
const std::string nested_name = ModuleLevelDescriptorName(descriptor);
const std::string parent_name =
ModuleLevelDescriptorName(*containing_descriptor);
- printer_->Print(
- "$nested_name$.containing_type = $parent_name$\n",
- "nested_name", nested_name,
- "parent_name", parent_name);
+ printer_->Print("$nested_name$.containing_type = $parent_name$\n",
+ "nested_name", nested_name, "parent_name", parent_name);
}
}
@@ -1081,11 +1093,10 @@
// containing_type() means "extended type."
// On the other hand, extension_scope() will give us what we normally
// mean by containing_type().
- m["extended_message_class"] = ModuleLevelMessageName(
- *extension_field.containing_type());
- m["field"] = FieldReferencingExpression(extension_field.extension_scope(),
- extension_field,
- "extensions_by_name");
+ m["extended_message_class"] =
+ ModuleLevelMessageName(*extension_field.containing_type());
+ m["field"] = FieldReferencingExpression(
+ extension_field.extension_scope(), extension_field, "extensions_by_name");
printer_->Print(m, "$extended_message_class$.RegisterExtension($field$)\n");
}
@@ -1114,12 +1125,11 @@
m["index"] = StrCat(descriptor.index());
m["number"] = StrCat(descriptor.number());
m["options"] = OptionsValue(options_string);
- printer_->Print(
- m,
- "_descriptor.EnumValueDescriptor(\n"
- " name='$name$', index=$index$, number=$number$,\n"
- " serialized_options=$options$,\n"
- " type=None)");
+ printer_->Print(m,
+ "_descriptor.EnumValueDescriptor(\n"
+ " name='$name$', index=$index$, number=$number$,\n"
+ " serialized_options=$options$,\n"
+ " type=None)");
}
// Returns a CEscaped string of serialized_options.
@@ -1128,14 +1138,14 @@
if (serialized_options.length() == 0 || GeneratingDescriptorProto()) {
return "None";
} else {
-//##!PY25 return "b'('" + CEscape(serialized_options)+ "')";
- return "_b('"+ CEscape(serialized_options) + "')"; //##PY25
+ //##!PY25 return "b'('" + CEscape(serialized_options)+ "')";
+ return "_b('" + CEscape(serialized_options) + "')"; //##PY25
}
}
// Prints an expression for a Python FieldDescriptor for |field|.
-void Generator::PrintFieldDescriptor(
- const FieldDescriptor& field, bool is_extension) const {
+void Generator::PrintFieldDescriptor(const FieldDescriptor& field,
+ bool is_extension) const {
std::string options_string;
field.options().SerializeToString(&options_string);
std::map<std::string, std::string> m;
@@ -1150,19 +1160,20 @@
m["default_value"] = StringifyDefaultValue(field);
m["is_extension"] = is_extension ? "True" : "False";
m["serialized_options"] = OptionsValue(options_string);
- m["json_name"] = field.has_json_name() ?
- ", json_name='" + field.json_name() + "'": "";
+ m["json_name"] =
+ field.has_json_name() ? ", json_name='" + field.json_name() + "'" : "";
// We always set message_type and enum_type to None at this point, and then
// these fields in correctly after all referenced descriptors have been
// defined and/or imported (see FixForeignFieldsInDescriptors()).
const char field_descriptor_decl[] =
- "_descriptor.FieldDescriptor(\n"
- " name='$name$', full_name='$full_name$', index=$index$,\n"
- " number=$number$, type=$type$, cpp_type=$cpp_type$, label=$label$,\n"
- " has_default_value=$has_default_value$, default_value=$default_value$,\n"
- " message_type=None, enum_type=None, containing_type=None,\n"
- " is_extension=$is_extension$, extension_scope=None,\n"
- " serialized_options=$serialized_options$$json_name$, file=DESCRIPTOR)";
+ "_descriptor.FieldDescriptor(\n"
+ " name='$name$', full_name='$full_name$', index=$index$,\n"
+ " number=$number$, type=$type$, cpp_type=$cpp_type$, label=$label$,\n"
+ " has_default_value=$has_default_value$, "
+ "default_value=$default_value$,\n"
+ " message_type=None, enum_type=None, containing_type=None,\n"
+ " is_extension=$is_extension$, extension_scope=None,\n"
+ " serialized_options=$serialized_options$$json_name$, file=DESCRIPTOR)";
printer_->Print(m, field_descriptor_decl);
}
@@ -1174,8 +1185,7 @@
printer_->Print("$list$=[\n", "list", list_variable_name);
printer_->Indent();
for (int i = 0; i < (message_descriptor.*CountFn)(); ++i) {
- PrintFieldDescriptor(*(message_descriptor.*GetterFn)(i),
- is_extension);
+ PrintFieldDescriptor(*(message_descriptor.*GetterFn)(i), is_extension);
printer_->Print(",\n");
}
printer_->Outdent();
@@ -1187,9 +1197,9 @@
void Generator::PrintFieldsInDescriptor(
const Descriptor& message_descriptor) const {
const bool is_extension = false;
- PrintFieldDescriptorsInDescriptor(
- message_descriptor, is_extension, "fields",
- &Descriptor::field_count, &Descriptor::field);
+ PrintFieldDescriptorsInDescriptor(message_descriptor, is_extension, "fields",
+ &Descriptor::field_count,
+ &Descriptor::field);
}
// Prints a statement assigning "extensions" to a list of Python
@@ -1197,9 +1207,9 @@
void Generator::PrintExtensionsInDescriptor(
const Descriptor& message_descriptor) const {
const bool is_extension = true;
- PrintFieldDescriptorsInDescriptor(
- message_descriptor, is_extension, "extensions",
- &Descriptor::extension_count, &Descriptor::extension);
+ PrintFieldDescriptorsInDescriptor(message_descriptor, is_extension,
+ "extensions", &Descriptor::extension_count,
+ &Descriptor::extension);
}
bool Generator::GeneratingDescriptorProto() const {
@@ -1273,8 +1283,8 @@
// serialized_end=43,
//
template <typename DescriptorT, typename DescriptorProtoT>
-void Generator::PrintSerializedPbInterval(
- const DescriptorT& descriptor, DescriptorProtoT& proto) const {
+void Generator::PrintSerializedPbInterval(const DescriptorT& descriptor,
+ DescriptorProtoT& proto) const {
descriptor.CopyTo(&proto);
std::string sp;
proto.SerializeToString(&sp);
@@ -1294,9 +1304,7 @@
io::Printer* printer) {
// Reset the _options to None thus DescriptorBase.GetOptions() can
// parse _options again after extensions are registered.
- printer->Print(
- "$descriptor$._options = None\n",
- "descriptor", descriptor);
+ printer->Print("$descriptor$._options = None\n", "descriptor", descriptor);
}
} // namespace
@@ -1358,8 +1366,7 @@
// Prints expressions that set the options for field descriptors (including
// extensions).
-void Generator::FixOptionsForField(
- const FieldDescriptor& field) const {
+void Generator::FixOptionsForField(const FieldDescriptor& field) const {
std::string field_options = OptionsValue(field.options().SerializeAsString());
if (field_options != "None") {
std::string field_name;
@@ -1368,12 +1375,12 @@
// Top level extensions.
field_name = field.name();
} else {
- field_name = FieldReferencingExpression(
- field.extension_scope(), field, "extensions_by_name");
+ field_name = FieldReferencingExpression(field.extension_scope(), field,
+ "extensions_by_name");
}
} else {
- field_name = FieldReferencingExpression(
- field.containing_type(), field, "fields_by_name");
+ field_name = FieldReferencingExpression(field.containing_type(), field,
+ "fields_by_name");
}
PrintDescriptorOptionsFixingCode(field_name, field_options, printer_);
}
@@ -1409,8 +1416,7 @@
OptionsValue(descriptor.options().SerializeAsString());
if (message_options != "None") {
std::string descriptor_name = ModuleLevelDescriptorName(descriptor);
- PrintDescriptorOptionsFixingCode(descriptor_name,
- message_options,
+ PrintDescriptorOptionsFixingCode(descriptor_name, message_options,
printer_);
}
}
@@ -1425,13 +1431,12 @@
// There's no module alias in the dependent file if it was generated by
// an old protoc (less than 3.0.0-alpha-1). Use module name in this
// situation.
- printer_->Print("try:\n"
- " $alias$ = $copy_from$.$alias$\n"
- "except AttributeError:\n"
- " $alias$ = $copy_from$.$module$\n",
- "alias", module_alias,
- "module", module_name,
- "copy_from", copy_from);
+ printer_->Print(
+ "try:\n"
+ " $alias$ = $copy_from$.$alias$\n"
+ "except AttributeError:\n"
+ " $alias$ = $copy_from$.$module$\n",
+ "alias", module_alias, "module", module_name, "copy_from", copy_from);
CopyPublicDependenciesAliases(copy_from, file->public_dependency(i));
}
}
diff --git a/src/google/protobuf/compiler/python/python_generator.h b/src/google/protobuf/compiler/python/python_generator.h
index b4959bf..4630671 100644
--- a/src/google/protobuf/compiler/python/python_generator.h
+++ b/src/google/protobuf/compiler/python/python_generator.h
@@ -52,7 +52,9 @@
class OneofDescriptor;
class ServiceDescriptor;
-namespace io { class Printer; }
+namespace io {
+class Printer;
+}
namespace compiler {
namespace python {
@@ -82,8 +84,8 @@
void PrintTopLevelExtensions() const;
- void PrintFieldDescriptor(
- const FieldDescriptor& field, bool is_extension) const;
+ void PrintFieldDescriptor(const FieldDescriptor& field,
+ bool is_extension) const;
void PrintFieldDescriptorsInDescriptor(
const Descriptor& message_descriptor, bool is_extension,
const std::string& list_variable_name, int (Descriptor::*CountFn)() const,
@@ -146,8 +148,8 @@
const ServiceDescriptor& descriptor) const;
template <typename DescriptorT, typename DescriptorProtoT>
- void PrintSerializedPbInterval(
- const DescriptorT& descriptor, DescriptorProtoT& proto) const;
+ void PrintSerializedPbInterval(const DescriptorT& descriptor,
+ DescriptorProtoT& proto) const;
void FixAllDescriptorOptions() const;
void FixOptionsForField(const FieldDescriptor& field) const;
diff --git a/src/google/protobuf/compiler/python/python_plugin_unittest.cc b/src/google/protobuf/compiler/python/python_plugin_unittest.cc
index aa04e8b..8d7ef98 100644
--- a/src/google/protobuf/compiler/python/python_plugin_unittest.cc
+++ b/src/google/protobuf/compiler/python/python_plugin_unittest.cc
@@ -36,10 +36,10 @@
#include <memory>
-#include <google/protobuf/compiler/python/python_generator.h>
#include <google/protobuf/compiler/command_line_interface.h>
-#include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/compiler/python/python_generator.h>
#include <google/protobuf/io/printer.h>
+#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/testing/file.h>
#include <google/protobuf/testing/file.h>
@@ -102,13 +102,8 @@
std::string python_out = "--python_out=" + TestTempDir();
std::string test_out = "--test_out=" + TestTempDir();
- const char* argv[] = {
- "protoc",
- proto_path.c_str(),
- python_out.c_str(),
- test_out.c_str(),
- "test.proto"
- };
+ const char* argv[] = {"protoc", proto_path.c_str(), python_out.c_str(),
+ test_out.c_str(), "test.proto"};
EXPECT_EQ(0, cli.Run(5, argv));
}
diff --git a/src/google/protobuf/compiler/subprocess.cc b/src/google/protobuf/compiler/subprocess.cc
index 42f3d06..b920b2d 100644
--- a/src/google/protobuf/compiler/subprocess.cc
+++ b/src/google/protobuf/compiler/subprocess.cc
@@ -38,9 +38,9 @@
#ifndef _WIN32
#include <errno.h>
+#include <signal.h>
#include <sys/select.h>
#include <sys/wait.h>
-#include <signal.h>
#endif
#include <google/protobuf/stubs/logging.h>
@@ -54,7 +54,7 @@
namespace {
char* portable_strdup(const char* s) {
- char* ns = (char*) malloc(strlen(s) + 1);
+ char* ns = (char*)malloc(strlen(s) + 1);
if (ns != NULL) {
strcpy(ns, s);
}
@@ -73,7 +73,9 @@
Subprocess::Subprocess()
: process_start_error_(ERROR_SUCCESS),
- child_handle_(NULL), child_stdin_(NULL), child_stdout_(NULL) {}
+ child_handle_(NULL),
+ child_stdin_(NULL),
+ child_stdout_(NULL) {}
Subprocess::~Subprocess() {
if (child_stdin_ != NULL) {
@@ -99,13 +101,13 @@
}
// Make child side of the pipes inheritable.
- if (!SetHandleInformation(stdin_pipe_read,
- HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT)) {
+ if (!SetHandleInformation(stdin_pipe_read, HANDLE_FLAG_INHERIT,
+ HANDLE_FLAG_INHERIT)) {
GOOGLE_LOG(FATAL) << "SetHandleInformation: "
<< Win32ErrorMessage(GetLastError());
}
- if (!SetHandleInformation(stdout_pipe_write,
- HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT)) {
+ if (!SetHandleInformation(stdout_pipe_write, HANDLE_FLAG_INHERIT,
+ HANDLE_FLAG_INHERIT)) {
GOOGLE_LOG(FATAL) << "SetHandleInformation: "
<< Win32ErrorMessage(GetLastError());
}
@@ -120,14 +122,13 @@
startup_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
if (startup_info.hStdError == INVALID_HANDLE_VALUE) {
- GOOGLE_LOG(FATAL) << "GetStdHandle: "
- << Win32ErrorMessage(GetLastError());
+ GOOGLE_LOG(FATAL) << "GetStdHandle: " << Win32ErrorMessage(GetLastError());
}
// Invoking cmd.exe allows for '.bat' files from the path as well as '.exe'.
// Using a malloc'ed string because CreateProcess() can mutate its second
// parameter.
- char *command_line =
+ char* command_line =
portable_strdup(("cmd.exe /c \"" + program + "\"").c_str());
// Create the process.
@@ -141,8 +142,7 @@
0, // obscure creation flags
NULL, // environment (inherit from parent)
NULL, // current directory (inherit from parent)
- &startup_info,
- &process_info)) {
+ &startup_info, &process_info)) {
child_handle_ = process_info.hProcess;
CloseHandleOrDie(process_info.hThread);
child_stdin_ = stdin_pipe_write;
@@ -200,10 +200,8 @@
if (signaled_handle == child_stdin_) {
DWORD n;
- if (!WriteFile(child_stdin_,
- input_data.data() + input_pos,
- input_data.size() - input_pos,
- &n, NULL)) {
+ if (!WriteFile(child_stdin_, input_data.data() + input_pos,
+ input_data.size() - input_pos, &n, NULL)) {
// Child closed pipe. Presumably it will report an error later.
// Pretend we're done for now.
input_pos = input_data.size();
@@ -257,8 +255,8 @@
child_handle_ = NULL;
if (exit_code != 0) {
- *error = strings::Substitute(
- "Plugin failed with status code $0.", exit_code);
+ *error =
+ strings::Substitute("Plugin failed with status code $0.", exit_code);
return false;
}
@@ -312,7 +310,7 @@
GOOGLE_CHECK(pipe(stdin_pipe) != -1);
GOOGLE_CHECK(pipe(stdout_pipe) != -1);
- char* argv[2] = { portable_strdup(program.c_str()), NULL };
+ char* argv[2] = {portable_strdup(program.c_str()), NULL};
child_pid_ = fork();
if (child_pid_ == -1) {
@@ -342,7 +340,7 @@
ignored = write(STDERR_FILENO, argv[0], strlen(argv[0]));
const char* message = ": program not found or is not executable\n";
ignored = write(STDERR_FILENO, message, strlen(message));
- (void) ignored;
+ (void)ignored;
// Must use _exit() rather than exit() to avoid flushing output buffers
// that will also be flushed by the parent.
@@ -397,7 +395,7 @@
if (child_stdin_ != -1 && FD_ISSET(child_stdin_, &write_fds)) {
int n = write(child_stdin_, input_data.data() + input_pos,
- input_data.size() - input_pos);
+ input_data.size() - input_pos);
if (n < 0) {
// Child closed pipe. Presumably it will report an error later.
// Pretend we're done for now.
@@ -447,14 +445,13 @@
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) != 0) {
int error_code = WEXITSTATUS(status);
- *error = strings::Substitute(
- "Plugin failed with status code $0.", error_code);
+ *error =
+ strings::Substitute("Plugin failed with status code $0.", error_code);
return false;
}
} else if (WIFSIGNALED(status)) {
int signal = WTERMSIG(status);
- *error = strings::Substitute(
- "Plugin killed by signal $0.", signal);
+ *error = strings::Substitute("Plugin killed by signal $0.", signal);
return false;
} else {
*error = "Neither WEXITSTATUS nor WTERMSIG is true?";
diff --git a/src/google/protobuf/compiler/subprocess.h b/src/google/protobuf/compiler/subprocess.h
index 977abff..9c4f8b7 100644
--- a/src/google/protobuf/compiler/subprocess.h
+++ b/src/google/protobuf/compiler/subprocess.h
@@ -34,7 +34,7 @@
#define GOOGLE_PROTOBUF_COMPILER_SUBPROCESS_H__
#ifdef _WIN32
-#define WIN32_LEAN_AND_MEAN // right...
+#define WIN32_LEAN_AND_MEAN // right...
#include <windows.h>
#else // _WIN32
#include <sys/types.h>
@@ -60,8 +60,8 @@
~Subprocess();
enum SearchMode {
- SEARCH_PATH, // Use PATH environment variable.
- EXACT_NAME // Program is an exact file name; don't use the PATH.
+ SEARCH_PATH, // Use PATH environment variable.
+ EXACT_NAME // Program is an exact file name; don't use the PATH.
};
// Start the subprocess. Currently we don't provide a way to specify
diff --git a/src/google/protobuf/compiler/test_plugin.cc b/src/google/protobuf/compiler/test_plugin.cc
index 4b75876..6b56170 100644
--- a/src/google/protobuf/compiler/test_plugin.cc
+++ b/src/google/protobuf/compiler/test_plugin.cc
@@ -33,10 +33,10 @@
// This is a dummy code generator plugin used by
// command_line_interface_unittest.
-#include <string>
#include <stdlib.h>
-#include <google/protobuf/compiler/plugin.h>
+#include <string>
#include <google/protobuf/compiler/mock_code_generator.h>
+#include <google/protobuf/compiler/plugin.h>
namespace google {
namespace protobuf {
diff --git a/src/google/protobuf/compiler/zip_writer.cc b/src/google/protobuf/compiler/zip_writer.cc
index f03b3a6..872dd9e 100644
--- a/src/google/protobuf/compiler/zip_writer.cc
+++ b/src/google/protobuf/compiler/zip_writer.cc
@@ -75,50 +75,49 @@
static const uint16 kDosEpoch = 1 << 5 | 1;
static const uint32 kCRC32Table[256] = {
- 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
- 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
- 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
- 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
- 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
- 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
- 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
- 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
- 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
- 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
- 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
- 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
- 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
- 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
- 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
- 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
- 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
- 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
- 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
- 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
- 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
- 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
- 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
- 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
- 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
- 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
- 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
- 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
- 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
- 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
- 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
- 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
- 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
- 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
- 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
- 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
- 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
- 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
- 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
- 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
- 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
- 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
- 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
-};
+ 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+ 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+ 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+ 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+ 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+ 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+ 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+ 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+ 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+ 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+ 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+ 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+ 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+ 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+ 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+ 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+ 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+ 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+ 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+ 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+ 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+ 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+ 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+ 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+ 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+ 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+ 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+ 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+ 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+ 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+ 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+ 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+ 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+ 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+ 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+ 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+ 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+ 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+ 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+ 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+ 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+ 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+ 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d};
static uint32 ComputeCRC32(const std::string& buf) {
uint32 x = ~0U;
@@ -129,7 +128,7 @@
return ~x;
}
-static void WriteShort(io::CodedOutputStream *out, uint16 val) {
+static void WriteShort(io::CodedOutputStream* out, uint16 val) {
uint8 p[2];
p[0] = static_cast<uint8>(val);
p[1] = static_cast<uint8>(val >> 8);
@@ -137,7 +136,7 @@
}
ZipWriter::ZipWriter(io::ZeroCopyOutputStream* raw_output)
- : raw_output_(raw_output) {}
+ : raw_output_(raw_output) {}
ZipWriter::~ZipWriter() {}
bool ZipWriter::Write(const std::string& filename,
@@ -155,18 +154,18 @@
// write file header
io::CodedOutputStream output(raw_output_);
output.WriteLittleEndian32(0x04034b50); // magic
- WriteShort(&output, 10); // version needed to extract
- WriteShort(&output, 0); // flags
- WriteShort(&output, 0); // compression method: stored
- WriteShort(&output, 0); // last modified time
- WriteShort(&output, kDosEpoch); // last modified date
+ WriteShort(&output, 10); // version needed to extract
+ WriteShort(&output, 0); // flags
+ WriteShort(&output, 0); // compression method: stored
+ WriteShort(&output, 0); // last modified time
+ WriteShort(&output, kDosEpoch); // last modified date
output.WriteLittleEndian32(info.crc32); // crc-32
- output.WriteLittleEndian32(info.size); // compressed size
- output.WriteLittleEndian32(info.size); // uncompressed size
- WriteShort(&output, filename_size); // file name length
- WriteShort(&output, 0); // extra field length
- output.WriteString(filename); // file name
- output.WriteString(contents); // file data
+ output.WriteLittleEndian32(info.size); // compressed size
+ output.WriteLittleEndian32(info.size); // uncompressed size
+ WriteShort(&output, filename_size); // file name length
+ WriteShort(&output, 0); // extra field length
+ output.WriteString(filename); // file name
+ output.WriteString(contents); // file data
return !output.HadError();
}
@@ -185,35 +184,35 @@
uint32 offset = files_[i].offset;
output.WriteLittleEndian32(0x02014b50); // magic
- WriteShort(&output, 10); // version made by
- WriteShort(&output, 10); // version needed to extract
- WriteShort(&output, 0); // flags
- WriteShort(&output, 0); // compression method: stored
- WriteShort(&output, 0); // last modified time
- WriteShort(&output, kDosEpoch); // last modified date
- output.WriteLittleEndian32(crc32); // crc-32
- output.WriteLittleEndian32(size); // compressed size
- output.WriteLittleEndian32(size); // uncompressed size
- WriteShort(&output, filename_size); // file name length
- WriteShort(&output, 0); // extra field length
- WriteShort(&output, 0); // file comment length
- WriteShort(&output, 0); // starting disk number
- WriteShort(&output, 0); // internal file attributes
- output.WriteLittleEndian32(0); // external file attributes
- output.WriteLittleEndian32(offset); // local header offset
- output.WriteString(filename); // file name
+ WriteShort(&output, 10); // version made by
+ WriteShort(&output, 10); // version needed to extract
+ WriteShort(&output, 0); // flags
+ WriteShort(&output, 0); // compression method: stored
+ WriteShort(&output, 0); // last modified time
+ WriteShort(&output, kDosEpoch); // last modified date
+ output.WriteLittleEndian32(crc32); // crc-32
+ output.WriteLittleEndian32(size); // compressed size
+ output.WriteLittleEndian32(size); // uncompressed size
+ WriteShort(&output, filename_size); // file name length
+ WriteShort(&output, 0); // extra field length
+ WriteShort(&output, 0); // file comment length
+ WriteShort(&output, 0); // starting disk number
+ WriteShort(&output, 0); // internal file attributes
+ output.WriteLittleEndian32(0); // external file attributes
+ output.WriteLittleEndian32(offset); // local header offset
+ output.WriteString(filename); // file name
}
uint32 dir_len = output.ByteCount();
// write end of central directory marker
output.WriteLittleEndian32(0x06054b50); // magic
- WriteShort(&output, 0); // disk number
- WriteShort(&output, 0); // disk with start of central directory
- WriteShort(&output, num_entries); // central directory entries (this disk)
- WriteShort(&output, num_entries); // central directory entries (total)
+ WriteShort(&output, 0); // disk number
+ WriteShort(&output, 0); // disk with start of central directory
+ WriteShort(&output, num_entries); // central directory entries (this disk)
+ WriteShort(&output, num_entries); // central directory entries (total)
output.WriteLittleEndian32(dir_len); // central directory byte size
output.WriteLittleEndian32(dir_ofs); // central directory offset
- WriteShort(&output, 0); // comment length
+ WriteShort(&output, 0); // comment length
return output.HadError();
}
diff --git a/src/google/protobuf/descriptor.cc b/src/google/protobuf/descriptor.cc
index d5c20ee..cc1c4bf 100644
--- a/src/google/protobuf/descriptor.cc
+++ b/src/google/protobuf/descriptor.cc
@@ -150,73 +150,73 @@
};
const FieldDescriptor::CppType
-FieldDescriptor::kTypeToCppTypeMap[MAX_TYPE + 1] = {
- static_cast<CppType>(0), // 0 is reserved for errors
+ FieldDescriptor::kTypeToCppTypeMap[MAX_TYPE + 1] = {
+ static_cast<CppType>(0), // 0 is reserved for errors
- CPPTYPE_DOUBLE, // TYPE_DOUBLE
- CPPTYPE_FLOAT, // TYPE_FLOAT
- CPPTYPE_INT64, // TYPE_INT64
- CPPTYPE_UINT64, // TYPE_UINT64
- CPPTYPE_INT32, // TYPE_INT32
- CPPTYPE_UINT64, // TYPE_FIXED64
- CPPTYPE_UINT32, // TYPE_FIXED32
- CPPTYPE_BOOL, // TYPE_BOOL
- CPPTYPE_STRING, // TYPE_STRING
- CPPTYPE_MESSAGE, // TYPE_GROUP
- CPPTYPE_MESSAGE, // TYPE_MESSAGE
- CPPTYPE_STRING, // TYPE_BYTES
- CPPTYPE_UINT32, // TYPE_UINT32
- CPPTYPE_ENUM, // TYPE_ENUM
- CPPTYPE_INT32, // TYPE_SFIXED32
- CPPTYPE_INT64, // TYPE_SFIXED64
- CPPTYPE_INT32, // TYPE_SINT32
- CPPTYPE_INT64, // TYPE_SINT64
+ CPPTYPE_DOUBLE, // TYPE_DOUBLE
+ CPPTYPE_FLOAT, // TYPE_FLOAT
+ CPPTYPE_INT64, // TYPE_INT64
+ CPPTYPE_UINT64, // TYPE_UINT64
+ CPPTYPE_INT32, // TYPE_INT32
+ CPPTYPE_UINT64, // TYPE_FIXED64
+ CPPTYPE_UINT32, // TYPE_FIXED32
+ CPPTYPE_BOOL, // TYPE_BOOL
+ CPPTYPE_STRING, // TYPE_STRING
+ CPPTYPE_MESSAGE, // TYPE_GROUP
+ CPPTYPE_MESSAGE, // TYPE_MESSAGE
+ CPPTYPE_STRING, // TYPE_BYTES
+ CPPTYPE_UINT32, // TYPE_UINT32
+ CPPTYPE_ENUM, // TYPE_ENUM
+ CPPTYPE_INT32, // TYPE_SFIXED32
+ CPPTYPE_INT64, // TYPE_SFIXED64
+ CPPTYPE_INT32, // TYPE_SINT32
+ CPPTYPE_INT64, // TYPE_SINT64
};
-const char * const FieldDescriptor::kTypeToName[MAX_TYPE + 1] = {
- "ERROR", // 0 is reserved for errors
+const char* const FieldDescriptor::kTypeToName[MAX_TYPE + 1] = {
+ "ERROR", // 0 is reserved for errors
- "double", // TYPE_DOUBLE
- "float", // TYPE_FLOAT
- "int64", // TYPE_INT64
- "uint64", // TYPE_UINT64
- "int32", // TYPE_INT32
- "fixed64", // TYPE_FIXED64
- "fixed32", // TYPE_FIXED32
- "bool", // TYPE_BOOL
- "string", // TYPE_STRING
- "group", // TYPE_GROUP
- "message", // TYPE_MESSAGE
- "bytes", // TYPE_BYTES
- "uint32", // TYPE_UINT32
- "enum", // TYPE_ENUM
- "sfixed32", // TYPE_SFIXED32
- "sfixed64", // TYPE_SFIXED64
- "sint32", // TYPE_SINT32
- "sint64", // TYPE_SINT64
+ "double", // TYPE_DOUBLE
+ "float", // TYPE_FLOAT
+ "int64", // TYPE_INT64
+ "uint64", // TYPE_UINT64
+ "int32", // TYPE_INT32
+ "fixed64", // TYPE_FIXED64
+ "fixed32", // TYPE_FIXED32
+ "bool", // TYPE_BOOL
+ "string", // TYPE_STRING
+ "group", // TYPE_GROUP
+ "message", // TYPE_MESSAGE
+ "bytes", // TYPE_BYTES
+ "uint32", // TYPE_UINT32
+ "enum", // TYPE_ENUM
+ "sfixed32", // TYPE_SFIXED32
+ "sfixed64", // TYPE_SFIXED64
+ "sint32", // TYPE_SINT32
+ "sint64", // TYPE_SINT64
};
-const char * const FieldDescriptor::kCppTypeToName[MAX_CPPTYPE + 1] = {
- "ERROR", // 0 is reserved for errors
+const char* const FieldDescriptor::kCppTypeToName[MAX_CPPTYPE + 1] = {
+ "ERROR", // 0 is reserved for errors
- "int32", // CPPTYPE_INT32
- "int64", // CPPTYPE_INT64
- "uint32", // CPPTYPE_UINT32
- "uint64", // CPPTYPE_UINT64
- "double", // CPPTYPE_DOUBLE
- "float", // CPPTYPE_FLOAT
- "bool", // CPPTYPE_BOOL
- "enum", // CPPTYPE_ENUM
- "string", // CPPTYPE_STRING
- "message", // CPPTYPE_MESSAGE
+ "int32", // CPPTYPE_INT32
+ "int64", // CPPTYPE_INT64
+ "uint32", // CPPTYPE_UINT32
+ "uint64", // CPPTYPE_UINT64
+ "double", // CPPTYPE_DOUBLE
+ "float", // CPPTYPE_FLOAT
+ "bool", // CPPTYPE_BOOL
+ "enum", // CPPTYPE_ENUM
+ "string", // CPPTYPE_STRING
+ "message", // CPPTYPE_MESSAGE
};
-const char * const FieldDescriptor::kLabelToName[MAX_LABEL + 1] = {
- "ERROR", // 0 is reserved for errors
+const char* const FieldDescriptor::kLabelToName[MAX_LABEL + 1] = {
+ "ERROR", // 0 is reserved for errors
- "optional", // LABEL_OPTIONAL
- "required", // LABEL_REQUIRED
- "repeated", // LABEL_REPEATED
+ "optional", // LABEL_OPTIONAL
+ "required", // LABEL_REQUIRED
+ "repeated", // LABEL_REPEATED
};
const char* FileDescriptor::SyntaxName(FileDescriptor::Syntax syntax) {
@@ -232,7 +232,7 @@
return NULL;
}
-static const char * const kNonLinkedWeakMessageReplacementName = "google.protobuf.Empty";
+static const char* const kNonLinkedWeakMessageReplacementName = "google.protobuf.Empty";
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int FieldDescriptor::kMaxNumber;
@@ -406,7 +406,7 @@
#define HASH_SET std::unordered_set
#define HASH_FXN hash
-template<typename PairType>
+template <typename PairType>
struct PointerIntegerPairHash {
size_t operator()(const PairType& p) const {
static const size_t prime1 = 16777499;
@@ -421,8 +421,7 @@
static const size_t min_buckets = 8;
#endif
inline bool operator()(const PairType& a, const PairType& b) const {
- return a.first < b.first ||
- (a.first == b.first && a.second < b.second);
+ return a.first < b.first || (a.first == b.first && a.second < b.second);
}
};
@@ -467,26 +466,26 @@
typedef HASH_MAP<DescriptorIntPair, const FieldDescriptor*,
PointerIntegerPairHash<DescriptorIntPair>,
- std::equal_to<DescriptorIntPair> >
+ std::equal_to<DescriptorIntPair>>
FieldsByNumberMap;
typedef HASH_MAP<EnumIntPair, const EnumValueDescriptor*,
PointerIntegerPairHash<EnumIntPair>,
- std::equal_to<EnumIntPair> >
+ std::equal_to<EnumIntPair>>
EnumValuesByNumberMap;
// This is a map rather than a hash-map, since we use it to iterate
// through all the extensions that extend a given Descriptor, and an
// ordered data structure that implements lower_bound is convenient
// for that.
typedef std::map<DescriptorIntPair, const FieldDescriptor*>
- ExtensionsGroupedByDescriptorMap;
+ ExtensionsGroupedByDescriptorMap;
typedef HASH_MAP<std::string, const SourceCodeInfo_Location*>
LocationsByPathMap;
std::set<std::string>* NewAllowedProto3Extendee() {
auto allowed_proto3_extendees = new std::set<std::string>;
const char* kOptionNames[] = {
- "FileOptions", "MessageOptions", "FieldOptions", "EnumOptions",
+ "FileOptions", "MessageOptions", "FieldOptions", "EnumOptions",
"EnumValueOptions", "ServiceOptions", "MethodOptions", "OneofOptions"};
for (int i = 0; i < GOOGLE_ARRAYSIZE(kOptionNames); ++i) {
// descriptor.proto has a different package name in opensource. We allow
@@ -620,11 +619,13 @@
// destroyed. Note that the object's destructor will never be called,
// so its fields must be plain old data (primitive data types and
// pointers). All of the descriptor types are such objects.
- template<typename Type> Type* Allocate();
+ template <typename Type>
+ Type* Allocate();
// Allocate an array of objects which will be reclaimed when the
// pool in destroyed. Again, destructors are never called.
- template<typename Type> Type* AllocateArray(int count);
+ template <typename Type>
+ Type* AllocateArray(int count);
// Allocate a string which will be destroyed when the pool is destroyed.
// The string is initialized to the given value for convenience.
@@ -638,22 +639,23 @@
// trouble understanding explicit template instantiations in some cases, so
// in those cases we have to pass a dummy pointer of the right type as the
// parameter instead of specifying the type explicitly.
- template<typename Type> Type* AllocateMessage(Type* dummy = NULL);
+ template <typename Type>
+ Type* AllocateMessage(Type* dummy = NULL);
// Allocate a FileDescriptorTables object.
FileDescriptorTables* AllocateFileTables();
private:
std::vector<std::string*> strings_; // All strings in the pool.
- std::vector<Message*> messages_; // All messages in the pool.
+ std::vector<Message*> messages_; // All messages in the pool.
std::vector<internal::once_flag*>
once_dynamics_; // All internal::call_onces in the pool.
std::vector<FileDescriptorTables*>
file_tables_; // All file tables in the pool.
std::vector<void*> allocations_; // All other memory allocated in the pool.
- SymbolsByNameMap symbols_by_name_;
- FilesByNameMap files_by_name_;
+ SymbolsByNameMap symbols_by_name_;
+ FilesByNameMap files_by_name_;
ExtensionsGroupedByDescriptorMap extensions_;
struct CheckPoint {
@@ -679,8 +681,8 @@
int pending_extensions_before_checkpoint;
};
std::vector<CheckPoint> checkpoints_;
- std::vector<const char* > symbols_after_checkpoint_;
- std::vector<const char* > files_after_checkpoint_;
+ std::vector<const char*> symbols_after_checkpoint_;
+ std::vector<const char*> files_after_checkpoint_;
std::vector<DescriptorIntPair> extensions_after_checkpoint_;
// Allocate some bytes which will be reclaimed when the pool is
@@ -717,14 +719,14 @@
const Symbol::Type type) const;
// These return NULL if not found.
- inline const FieldDescriptor* FindFieldByNumber(
- const Descriptor* parent, int number) const;
+ inline const FieldDescriptor* FindFieldByNumber(const Descriptor* parent,
+ int number) const;
inline const FieldDescriptor* FindFieldByLowercaseName(
const void* parent, const std::string& lowercase_name) const;
inline const FieldDescriptor* FindFieldByCamelcaseName(
const void* parent, const std::string& camelcase_name) const;
inline const EnumValueDescriptor* FindEnumValueByNumber(
- const EnumDescriptor* parent, int number) const;
+ const EnumDescriptor* parent, int number) const;
// This creates a new EnumValueDescriptor if not found, in a thread-safe way.
inline const EnumValueDescriptor* FindEnumValueByNumberCreatingIfUnknown(
const EnumDescriptor* parent, int number) const;
@@ -853,18 +855,15 @@
const CheckPoint& checkpoint = checkpoints_.back();
for (int i = checkpoint.pending_symbols_before_checkpoint;
- i < symbols_after_checkpoint_.size();
- i++) {
+ i < symbols_after_checkpoint_.size(); i++) {
symbols_by_name_.erase(symbols_after_checkpoint_[i]);
}
for (int i = checkpoint.pending_files_before_checkpoint;
- i < files_after_checkpoint_.size();
- i++) {
+ i < files_after_checkpoint_.size(); i++) {
files_by_name_.erase(files_after_checkpoint_[i]);
}
for (int i = checkpoint.pending_extensions_before_checkpoint;
- i < extensions_after_checkpoint_.size();
- i++) {
+ i < extensions_after_checkpoint_.size(); i++) {
extensions_.erase(extensions_after_checkpoint_[i]);
}
@@ -886,8 +885,7 @@
file_tables_.begin() + checkpoint.file_tables_before_checkpoint,
file_tables_.end());
for (int i = checkpoint.allocations_before_checkpoint;
- i < allocations_.size();
- i++) {
+ i < allocations_.size(); i++) {
operator delete(allocations_[i]);
}
@@ -940,8 +938,7 @@
if (result.IsNull() && pool->underlay_ != NULL) {
// Symbol not found; check the underlay.
- result =
- pool->underlay_->tables_->FindByNameHelper(pool->underlay_, name);
+ result = pool->underlay_->tables_->FindByNameHelper(pool->underlay_, name);
}
if (result.IsNull()) {
@@ -1067,13 +1064,12 @@
// later.
std::string enum_value_name = StringPrintf("UNKNOWN_ENUM_VALUE_%s_%d",
parent->name().c_str(), number);
- DescriptorPool::Tables* tables =
- const_cast<DescriptorPool::Tables*>(DescriptorPool::generated_pool()->
- tables_.get());
+ DescriptorPool::Tables* tables = const_cast<DescriptorPool::Tables*>(
+ DescriptorPool::generated_pool()->tables_.get());
EnumValueDescriptor* result = tables->Allocate<EnumValueDescriptor>();
result->name_ = tables->AllocateString(enum_value_name);
- result->full_name_ = tables->AllocateString(parent->full_name() +
- "." + enum_value_name);
+ result->full_name_ =
+ tables->AllocateString(parent->full_name() + "." + enum_value_name);
result->number_ = number;
result->type_ = parent;
result->options_ = &EnumValueOptions::default_instance();
@@ -1083,7 +1079,6 @@
}
}
-
inline const FieldDescriptor* DescriptorPool::Tables::FindExtension(
const Descriptor* extendee, int number) const {
return FindPtrOrNull(extensions_, std::make_pair(extendee, number));
@@ -1184,12 +1179,12 @@
// -------------------------------------------------------------------
-template<typename Type>
+template <typename Type>
Type* DescriptorPool::Tables::Allocate() {
return reinterpret_cast<Type*>(AllocateBytes(sizeof(Type)));
}
-template<typename Type>
+template <typename Type>
Type* DescriptorPool::Tables::AllocateArray(int count) {
return reinterpret_cast<Type*>(AllocateBytes(sizeof(Type) * count));
}
@@ -1206,7 +1201,7 @@
return result;
}
-template<typename Type>
+template <typename Type>
Type* DescriptorPool::Tables::AllocateMessage(Type* /* dummy */) {
Type* result = new Type;
messages_.push_back(result);
@@ -1254,42 +1249,41 @@
DescriptorPool::ErrorCollector::~ErrorCollector() {}
DescriptorPool::DescriptorPool()
- : mutex_(NULL),
- fallback_database_(NULL),
- default_error_collector_(NULL),
- underlay_(NULL),
- tables_(new Tables),
- enforce_dependencies_(true),
- lazily_build_dependencies_(false),
- allow_unknown_(false),
- enforce_weak_(false),
- disallow_enforce_utf8_(false) {}
+ : mutex_(NULL),
+ fallback_database_(NULL),
+ default_error_collector_(NULL),
+ underlay_(NULL),
+ tables_(new Tables),
+ enforce_dependencies_(true),
+ lazily_build_dependencies_(false),
+ allow_unknown_(false),
+ enforce_weak_(false),
+ disallow_enforce_utf8_(false) {}
DescriptorPool::DescriptorPool(DescriptorDatabase* fallback_database,
ErrorCollector* error_collector)
- : mutex_(new internal::WrappedMutex),
- fallback_database_(fallback_database),
- default_error_collector_(error_collector),
- underlay_(NULL),
- tables_(new Tables),
- enforce_dependencies_(true),
- lazily_build_dependencies_(false),
- allow_unknown_(false),
- enforce_weak_(false),
- disallow_enforce_utf8_(false) {
-}
+ : mutex_(new internal::WrappedMutex),
+ fallback_database_(fallback_database),
+ default_error_collector_(error_collector),
+ underlay_(NULL),
+ tables_(new Tables),
+ enforce_dependencies_(true),
+ lazily_build_dependencies_(false),
+ allow_unknown_(false),
+ enforce_weak_(false),
+ disallow_enforce_utf8_(false) {}
DescriptorPool::DescriptorPool(const DescriptorPool* underlay)
- : mutex_(NULL),
- fallback_database_(NULL),
- default_error_collector_(NULL),
- underlay_(underlay),
- tables_(new Tables),
- enforce_dependencies_(true),
- lazily_build_dependencies_(false),
- allow_unknown_(false),
- enforce_weak_(false),
- disallow_enforce_utf8_(false) {}
+ : mutex_(NULL),
+ fallback_database_(NULL),
+ default_error_collector_(NULL),
+ underlay_(underlay),
+ tables_(new Tables),
+ enforce_dependencies_(true),
+ lazily_build_dependencies_(false),
+ allow_unknown_(false),
+ enforce_weak_(false),
+ disallow_enforce_utf8_(false) {}
DescriptorPool::~DescriptorPool() {
if (mutex_ != NULL) delete mutex_;
@@ -1411,7 +1405,7 @@
if (!result.IsNull()) return result.GetFile();
if (underlay_ != NULL) {
const FileDescriptor* file_result =
- underlay_->FindFileContainingSymbol(symbol_name);
+ underlay_->FindFileContainingSymbol(symbol_name);
if (file_result != NULL) return file_result;
}
if (TryFindSymbolInFallbackDatabase(symbol_name)) {
@@ -1441,8 +1435,7 @@
const FieldDescriptor* DescriptorPool::FindExtensionByName(
const std::string& name) const {
Symbol result = tables_->FindByNameHelper(this, name);
- if (result.type == Symbol::FIELD &&
- result.field_descriptor->is_extension()) {
+ if (result.type == Symbol::FIELD && result.field_descriptor->is_extension()) {
return result.field_descriptor;
} else {
return NULL;
@@ -1464,8 +1457,8 @@
const EnumValueDescriptor* DescriptorPool::FindEnumValueByName(
const std::string& name) const {
Symbol result = tables_->FindByNameHelper(this, name);
- return (result.type == Symbol::ENUM_VALUE) ?
- result.enum_value_descriptor : NULL;
+ return (result.type == Symbol::ENUM_VALUE) ? result.enum_value_descriptor
+ : NULL;
}
const ServiceDescriptor* DescriptorPool::FindServiceByName(
@@ -1548,10 +1541,8 @@
// -------------------------------------------------------------------
-const FieldDescriptor*
-Descriptor::FindFieldByNumber(int key) const {
- const FieldDescriptor* result =
- file()->tables_->FindFieldByNumber(this, key);
+const FieldDescriptor* Descriptor::FindFieldByNumber(int key) const {
+ const FieldDescriptor* result = file()->tables_->FindFieldByNumber(this, key);
if (result == NULL || result->is_extension()) {
return NULL;
} else {
@@ -1562,7 +1553,7 @@
const FieldDescriptor* Descriptor::FindFieldByLowercaseName(
const std::string& key) const {
const FieldDescriptor* result =
- file()->tables_->FindFieldByLowercaseName(this, key);
+ file()->tables_->FindFieldByLowercaseName(this, key);
if (result == NULL || result->is_extension()) {
return NULL;
} else {
@@ -1573,7 +1564,7 @@
const FieldDescriptor* Descriptor::FindFieldByCamelcaseName(
const std::string& key) const {
const FieldDescriptor* result =
- file()->tables_->FindFieldByCamelcaseName(this, key);
+ file()->tables_->FindFieldByCamelcaseName(this, key);
if (result == NULL || result->is_extension()) {
return NULL;
} else {
@@ -1584,7 +1575,7 @@
const FieldDescriptor* Descriptor::FindFieldByName(
const std::string& key) const {
Symbol result =
- file()->tables_->FindNestedSymbolOfType(this, key, Symbol::FIELD);
+ file()->tables_->FindNestedSymbolOfType(this, key, Symbol::FIELD);
if (!result.IsNull() && !result.field_descriptor->is_extension()) {
return result.field_descriptor;
} else {
@@ -1595,7 +1586,7 @@
const OneofDescriptor* Descriptor::FindOneofByName(
const std::string& key) const {
Symbol result =
- file()->tables_->FindNestedSymbolOfType(this, key, Symbol::ONEOF);
+ file()->tables_->FindNestedSymbolOfType(this, key, Symbol::ONEOF);
if (!result.IsNull()) {
return result.oneof_descriptor;
} else {
@@ -1606,7 +1597,7 @@
const FieldDescriptor* Descriptor::FindExtensionByName(
const std::string& key) const {
Symbol result =
- file()->tables_->FindNestedSymbolOfType(this, key, Symbol::FIELD);
+ file()->tables_->FindNestedSymbolOfType(this, key, Symbol::FIELD);
if (!result.IsNull() && result.field_descriptor->is_extension()) {
return result.field_descriptor;
} else {
@@ -1617,7 +1608,7 @@
const FieldDescriptor* Descriptor::FindExtensionByLowercaseName(
const std::string& key) const {
const FieldDescriptor* result =
- file()->tables_->FindFieldByLowercaseName(this, key);
+ file()->tables_->FindFieldByLowercaseName(this, key);
if (result == NULL || !result->is_extension()) {
return NULL;
} else {
@@ -1628,7 +1619,7 @@
const FieldDescriptor* Descriptor::FindExtensionByCamelcaseName(
const std::string& key) const {
const FieldDescriptor* result =
- file()->tables_->FindFieldByCamelcaseName(this, key);
+ file()->tables_->FindFieldByCamelcaseName(this, key);
if (result == NULL || !result->is_extension()) {
return NULL;
} else {
@@ -1639,7 +1630,7 @@
const Descriptor* Descriptor::FindNestedTypeByName(
const std::string& key) const {
Symbol result =
- file()->tables_->FindNestedSymbolOfType(this, key, Symbol::MESSAGE);
+ file()->tables_->FindNestedSymbolOfType(this, key, Symbol::MESSAGE);
if (!result.IsNull()) {
return result.descriptor;
} else {
@@ -1650,7 +1641,7 @@
const EnumDescriptor* Descriptor::FindEnumTypeByName(
const std::string& key) const {
Symbol result =
- file()->tables_->FindNestedSymbolOfType(this, key, Symbol::ENUM);
+ file()->tables_->FindNestedSymbolOfType(this, key, Symbol::ENUM);
if (!result.IsNull()) {
return result.enum_descriptor;
} else {
@@ -1661,7 +1652,7 @@
const EnumValueDescriptor* Descriptor::FindEnumValueByName(
const std::string& key) const {
Symbol result =
- file()->tables_->FindNestedSymbolOfType(this, key, Symbol::ENUM_VALUE);
+ file()->tables_->FindNestedSymbolOfType(this, key, Symbol::ENUM_VALUE);
if (!result.IsNull()) {
return result.enum_value_descriptor;
} else {
@@ -1672,7 +1663,7 @@
const EnumValueDescriptor* EnumDescriptor::FindValueByName(
const std::string& key) const {
Symbol result =
- file()->tables_->FindNestedSymbolOfType(this, key, Symbol::ENUM_VALUE);
+ file()->tables_->FindNestedSymbolOfType(this, key, Symbol::ENUM_VALUE);
if (!result.IsNull()) {
return result.enum_value_descriptor;
} else {
@@ -1680,20 +1671,19 @@
}
}
-const EnumValueDescriptor*
-EnumDescriptor::FindValueByNumber(int key) const {
+const EnumValueDescriptor* EnumDescriptor::FindValueByNumber(int key) const {
return file()->tables_->FindEnumValueByNumber(this, key);
}
-const EnumValueDescriptor*
-EnumDescriptor::FindValueByNumberCreatingIfUnknown(int key) const {
+const EnumValueDescriptor* EnumDescriptor::FindValueByNumberCreatingIfUnknown(
+ int key) const {
return file()->tables_->FindEnumValueByNumberCreatingIfUnknown(this, key);
}
const MethodDescriptor* ServiceDescriptor::FindMethodByName(
const std::string& key) const {
Symbol result =
- file()->tables_->FindNestedSymbolOfType(this, key, Symbol::METHOD);
+ file()->tables_->FindNestedSymbolOfType(this, key, Symbol::METHOD);
if (!result.IsNull()) {
return result.method_descriptor;
} else {
@@ -1724,7 +1714,7 @@
const EnumValueDescriptor* FileDescriptor::FindEnumValueByName(
const std::string& key) const {
Symbol result =
- tables_->FindNestedSymbolOfType(this, key, Symbol::ENUM_VALUE);
+ tables_->FindNestedSymbolOfType(this, key, Symbol::ENUM_VALUE);
if (!result.IsNull()) {
return result.enum_value_descriptor;
} else {
@@ -1787,19 +1777,18 @@
// more than a couple extension ranges.
for (int i = 0; i < extension_range_count(); i++) {
if (number >= extension_range(i)->start &&
- number < extension_range(i)->end) {
+ number < extension_range(i)->end) {
return extension_range(i);
}
}
return NULL;
}
-const Descriptor::ReservedRange*
-Descriptor::FindReservedRangeContainingNumber(int number) const {
+const Descriptor::ReservedRange* Descriptor::FindReservedRangeContainingNumber(
+ int number) const {
// TODO(chrisn): Consider a non-linear search.
for (int i = 0; i < reserved_range_count(); i++) {
- if (number >= reserved_range(i)->start &&
- number < reserved_range(i)->end) {
+ if (number >= reserved_range(i)->start && number < reserved_range(i)->end) {
return reserved_range(i);
}
}
@@ -1864,22 +1853,22 @@
if (tables_->known_bad_symbols_.count(name) > 0) return false;
FileDescriptorProto file_proto;
- if (// We skip looking in the fallback database if the name is a sub-symbol
- // of any descriptor that already exists in the descriptor pool (except
- // for package descriptors). This is valid because all symbols except
- // for packages are defined in a single file, so if the symbol exists
- // then we should already have its definition.
- //
- // The other reason to do this is to support "overriding" type
- // definitions by merging two databases that define the same type. (Yes,
- // people do this.) The main difficulty with making this work is that
- // FindFileContainingSymbol() is allowed to return both false positives
- // (e.g., SimpleDescriptorDatabase, UpgradedDescriptorDatabase) and false
- // negatives (e.g. ProtoFileParser, SourceTreeDescriptorDatabase).
- // When two such databases are merged, looking up a non-existent
- // sub-symbol of a type that already exists in the descriptor pool can
- // result in an attempt to load multiple definitions of the same type.
- // The check below avoids this.
+ if ( // We skip looking in the fallback database if the name is a sub-symbol
+ // of any descriptor that already exists in the descriptor pool (except
+ // for package descriptors). This is valid because all symbols except
+ // for packages are defined in a single file, so if the symbol exists
+ // then we should already have its definition.
+ //
+ // The other reason to do this is to support "overriding" type
+ // definitions by merging two databases that define the same type. (Yes,
+ // people do this.) The main difficulty with making this work is that
+ // FindFileContainingSymbol() is allowed to return both false positives
+ // (e.g., SimpleDescriptorDatabase, UpgradedDescriptorDatabase) and
+ // false negatives (e.g. ProtoFileParser, SourceTreeDescriptorDatabase).
+ // When two such databases are merged, looking up a non-existent
+ // sub-symbol of a type that already exists in the descriptor pool can
+ // result in an attempt to load multiple definitions of the same type.
+ // The check below avoids this.
IsSubSymbolOfBuiltType(name)
// Look up file containing this symbol in fallback database.
@@ -1905,7 +1894,7 @@
FileDescriptorProto file_proto;
if (!fallback_database_->FindFileContainingExtension(
- containing_type->full_name(), field_number, &file_proto)) {
+ containing_type->full_name(), field_number, &file_proto)) {
return false;
}
@@ -2241,8 +2230,8 @@
std::string tmp;
TextFormat::Printer printer;
printer.SetInitialIndentLevel(depth + 1);
- printer.PrintFieldValueToString(options, fields[i],
- repeated ? j : -1, &tmp);
+ printer.PrintFieldValueToString(options, fields[i], repeated ? j : -1,
+ &tmp);
fieldval.append("{\n");
fieldval.append(tmp);
fieldval.append(depth * 2, ' ');
@@ -2313,8 +2302,8 @@
std::vector<std::string> all_options;
if (RetrieveOptions(depth, options, pool, &all_options)) {
for (int i = 0; i < all_options.size(); i++) {
- strings::SubstituteAndAppend(output, "$0option $1;\n",
- prefix, all_options[i]);
+ strings::SubstituteAndAppend(output, "$0option $1;\n", prefix,
+ all_options[i]);
}
}
return !all_options.empty();
@@ -2328,8 +2317,8 @@
: options_(options), prefix_(prefix) {
// Perform the SourceLocation lookup only if we're including user comments,
// because the lookup is fairly expensive.
- have_source_loc_ = options.include_comments &&
- desc->GetSourceLocation(&source_loc_);
+ have_source_loc_ =
+ options.include_comments && desc->GetSourceLocation(&source_loc_);
}
SourceLocationCommentPrinter(const FileDescriptor* file,
const std::vector<int>& path,
@@ -2338,13 +2327,13 @@
: options_(options), prefix_(prefix) {
// Perform the SourceLocation lookup only if we're including user comments,
// because the lookup is fairly expensive.
- have_source_loc_ = options.include_comments &&
- file->GetSourceLocation(path, &source_loc_);
+ have_source_loc_ =
+ options.include_comments && file->GetSourceLocation(path, &source_loc_);
}
void AddPreComment(std::string* output) {
if (have_source_loc_) {
// Detached leading comments.
- for (int i = 0 ; i < source_loc_.leading_detached_comments.size(); ++i) {
+ for (int i = 0; i < source_loc_.leading_detached_comments.size(); ++i) {
*output += FormatComment(source_loc_.leading_detached_comments[i]);
*output += "\n";
}
@@ -2395,16 +2384,15 @@
{
std::vector<int> path;
path.push_back(FileDescriptorProto::kSyntaxFieldNumber);
- SourceLocationCommentPrinter syntax_comment(
- this, path, "", debug_string_options);
+ SourceLocationCommentPrinter syntax_comment(this, path, "",
+ debug_string_options);
syntax_comment.AddPreComment(&contents);
strings::SubstituteAndAppend(&contents, "syntax = \"$0\";\n\n",
SyntaxName(syntax()));
syntax_comment.AddPostComment(&contents);
}
- SourceLocationCommentPrinter
- comment_printer(this, "", debug_string_options);
+ SourceLocationCommentPrinter comment_printer(this, "", debug_string_options);
comment_printer.AddPreComment(&contents);
std::set<int> public_dependencies;
@@ -2430,8 +2418,8 @@
if (!package().empty()) {
std::vector<int> path;
path.push_back(FileDescriptorProto::kPackageFieldNumber);
- SourceLocationCommentPrinter package_comment(
- this, path, "", debug_string_options);
+ SourceLocationCommentPrinter package_comment(this, path, "",
+ debug_string_options);
package_comment.AddPreComment(&contents);
strings::SubstituteAndAppend(&contents, "package $0;\n\n", package());
package_comment.AddPostComment(&contents);
@@ -2508,8 +2496,8 @@
std::string prefix(depth * 2, ' ');
++depth;
- SourceLocationCommentPrinter
- comment_printer(this, prefix, debug_string_options);
+ SourceLocationCommentPrinter comment_printer(this, prefix,
+ debug_string_options);
comment_printer.AddPreComment(contents);
if (include_opening_clause) {
@@ -2555,8 +2543,7 @@
}
for (int i = 0; i < extension_range_count(); i++) {
- strings::SubstituteAndAppend(contents, "$0 extensions $1 to $2;\n",
- prefix,
+ strings::SubstituteAndAppend(contents, "$0 extensions $1 to $2;\n", prefix,
extension_range(i)->start,
extension_range(i)->end - 1);
}
@@ -2567,12 +2554,11 @@
if (extension(i)->containing_type() != containing_type) {
if (i > 0) strings::SubstituteAndAppend(contents, "$0 }\n", prefix);
containing_type = extension(i)->containing_type();
- strings::SubstituteAndAppend(contents, "$0 extend .$1 {\n",
- prefix, containing_type->full_name());
+ strings::SubstituteAndAppend(contents, "$0 extend .$1 {\n", prefix,
+ containing_type->full_name());
}
- extension(i)->DebugString(
- depth + 1, FieldDescriptor::PRINT_LABEL, contents,
- debug_string_options);
+ extension(i)->DebugString(depth + 1, FieldDescriptor::PRINT_LABEL, contents,
+ debug_string_options);
}
if (extension_count() > 0)
strings::SubstituteAndAppend(contents, "$0 }\n", prefix);
@@ -2584,8 +2570,8 @@
if (range->end == range->start + 1) {
strings::SubstituteAndAppend(contents, "$0, ", range->start);
} else {
- strings::SubstituteAndAppend(contents, "$0 to $1, ",
- range->start, range->end - 1);
+ strings::SubstituteAndAppend(contents, "$0 to $1, ", range->start,
+ range->end - 1);
}
}
contents->replace(contents->size() - 2, 2, ";\n");
@@ -2627,7 +2613,7 @@
// The field type string used in FieldDescriptor::DebugString()
std::string FieldDescriptor::FieldTypeNameDebugString() const {
- switch(type()) {
+ switch (type()) {
case TYPE_MESSAGE:
return "." + message_type()->full_name();
case TYPE_ENUM:
@@ -2669,17 +2655,13 @@
label.push_back(' ');
}
- SourceLocationCommentPrinter
- comment_printer(this, prefix, debug_string_options);
+ SourceLocationCommentPrinter comment_printer(this, prefix,
+ debug_string_options);
comment_printer.AddPreComment(contents);
- strings::SubstituteAndAppend(contents, "$0$1$2 $3 = $4",
- prefix,
- label,
- field_type,
- type() == TYPE_GROUP ? message_type()->name() :
- name(),
- number());
+ strings::SubstituteAndAppend(
+ contents, "$0$1$2 $3 = $4", prefix, label, field_type,
+ type() == TYPE_GROUP ? message_type()->name() : name(), number());
bool bracketed = false;
if (has_default_value()) {
@@ -2742,8 +2724,8 @@
const DebugStringOptions& debug_string_options) const {
std::string prefix(depth * 2, ' ');
++depth;
- SourceLocationCommentPrinter
- comment_printer(this, prefix, debug_string_options);
+ SourceLocationCommentPrinter comment_printer(this, prefix,
+ debug_string_options);
comment_printer.AddPreComment(contents);
strings::SubstituteAndAppend(contents, "$0oneof $1 {", prefix, name());
@@ -2781,12 +2763,11 @@
std::string prefix(depth * 2, ' ');
++depth;
- SourceLocationCommentPrinter
- comment_printer(this, prefix, debug_string_options);
+ SourceLocationCommentPrinter comment_printer(this, prefix,
+ debug_string_options);
comment_printer.AddPreComment(contents);
- strings::SubstituteAndAppend(contents, "$0enum $1 {\n",
- prefix, name());
+ strings::SubstituteAndAppend(contents, "$0enum $1 {\n", prefix, name());
FormatLineOptions(depth, options(), file()->pool(), contents);
@@ -2801,8 +2782,8 @@
if (range->end == range->start) {
strings::SubstituteAndAppend(contents, "$0, ", range->start);
} else {
- strings::SubstituteAndAppend(contents, "$0 to $1, ",
- range->start, range->end);
+ strings::SubstituteAndAppend(contents, "$0 to $1, ", range->start,
+ range->end);
}
}
contents->replace(contents->size() - 2, 2, ";\n");
@@ -2839,12 +2820,11 @@
const DebugStringOptions& debug_string_options) const {
std::string prefix(depth * 2, ' ');
- SourceLocationCommentPrinter
- comment_printer(this, prefix, debug_string_options);
+ SourceLocationCommentPrinter comment_printer(this, prefix,
+ debug_string_options);
comment_printer.AddPreComment(contents);
- strings::SubstituteAndAppend(contents, "$0$1 = $2",
- prefix, name(), number());
+ strings::SubstituteAndAppend(contents, "$0$1 = $2", prefix, name(), number());
std::string formatted_options;
if (FormatBracketedOptions(depth, options(), type()->file()->pool(),
@@ -2871,8 +2851,8 @@
void ServiceDescriptor::DebugString(
std::string* contents,
const DebugStringOptions& debug_string_options) const {
- SourceLocationCommentPrinter
- comment_printer(this, /* prefix */ "", debug_string_options);
+ SourceLocationCommentPrinter comment_printer(this, /* prefix */ "",
+ debug_string_options);
comment_printer.AddPreComment(contents);
strings::SubstituteAndAppend(contents, "service $0 {\n", name());
@@ -2906,22 +2886,20 @@
std::string prefix(depth * 2, ' ');
++depth;
- SourceLocationCommentPrinter
- comment_printer(this, prefix, debug_string_options);
+ SourceLocationCommentPrinter comment_printer(this, prefix,
+ debug_string_options);
comment_printer.AddPreComment(contents);
- strings::SubstituteAndAppend(contents, "$0rpc $1($4.$2) returns ($5.$3)",
- prefix, name(),
- input_type()->full_name(),
- output_type()->full_name(),
- client_streaming() ? "stream " : "",
- server_streaming() ? "stream " : "");
+ strings::SubstituteAndAppend(
+ contents, "$0rpc $1($4.$2) returns ($5.$3)", prefix, name(),
+ input_type()->full_name(), output_type()->full_name(),
+ client_streaming() ? "stream " : "", server_streaming() ? "stream " : "");
std::string formatted_options;
if (FormatLineOptions(depth, options(), service()->file()->pool(),
&formatted_options)) {
- strings::SubstituteAndAppend(contents, " {\n$0$1}\n",
- formatted_options, prefix);
+ strings::SubstituteAndAppend(contents, " {\n$0$1}\n", formatted_options,
+ prefix);
} else {
contents->append(";\n");
}
@@ -2937,13 +2915,13 @@
GOOGLE_CHECK(out_location != nullptr);
if (source_code_info_) {
if (const SourceCodeInfo_Location* loc =
- tables_->GetSourceLocation(path, source_code_info_)) {
+ tables_->GetSourceLocation(path, source_code_info_)) {
const RepeatedField<int32>& span = loc->span();
if (span.size() == 3 || span.size() == 4) {
- out_location->start_line = span.Get(0);
+ out_location->start_line = span.Get(0);
out_location->start_column = span.Get(1);
- out_location->end_line = span.Get(span.size() == 3 ? 0 : 2);
- out_location->end_column = span.Get(span.size() - 1);
+ out_location->end_line = span.Get(span.size() == 3 ? 0 : 2);
+ out_location->end_column = span.Get(span.size() - 1);
out_location->leading_comments = loc->leading_comments();
out_location->trailing_comments = loc->trailing_comments();
@@ -3105,8 +3083,7 @@
class DescriptorBuilder {
public:
- DescriptorBuilder(const DescriptorPool* pool,
- DescriptorPool::Tables* tables,
+ DescriptorBuilder(const DescriptorPool* pool, DescriptorPool::Tables* tables,
DescriptorPool::ErrorCollector* error_collector);
~DescriptorBuilder();
@@ -3212,9 +3189,7 @@
// that LookupSymbol may still return a non-type symbol in LOOKUP_TYPES mode,
// if it believes that's all it could refer to. The caller should always
// check that it receives the type of symbol it was expecting.
- enum ResolveMode {
- LOOKUP_ALL, LOOKUP_TYPES
- };
+ enum ResolveMode { LOOKUP_ALL, LOOKUP_TYPES };
Symbol LookupSymbol(const std::string& name, const std::string& relative_to,
DescriptorPool::PlaceholderType placeholder_type =
DescriptorPool::PLACEHOLDER_MESSAGE,
@@ -3274,49 +3249,41 @@
// These methods all have the same signature for the sake of the BUILD_ARRAY
// macro, below.
- void BuildMessage(const DescriptorProto& proto,
- const Descriptor* parent,
+ void BuildMessage(const DescriptorProto& proto, const Descriptor* parent,
Descriptor* result);
void BuildFieldOrExtension(const FieldDescriptorProto& proto,
- const Descriptor* parent,
- FieldDescriptor* result,
+ const Descriptor* parent, FieldDescriptor* result,
bool is_extension);
- void BuildField(const FieldDescriptorProto& proto,
- const Descriptor* parent,
+ void BuildField(const FieldDescriptorProto& proto, const Descriptor* parent,
FieldDescriptor* result) {
BuildFieldOrExtension(proto, parent, result, false);
}
void BuildExtension(const FieldDescriptorProto& proto,
- const Descriptor* parent,
- FieldDescriptor* result) {
+ const Descriptor* parent, FieldDescriptor* result) {
BuildFieldOrExtension(proto, parent, result, true);
}
void BuildExtensionRange(const DescriptorProto::ExtensionRange& proto,
const Descriptor* parent,
Descriptor::ExtensionRange* result);
void BuildReservedRange(const DescriptorProto::ReservedRange& proto,
- const Descriptor* parent,
- Descriptor::ReservedRange* result);
+ const Descriptor* parent,
+ Descriptor::ReservedRange* result);
void BuildReservedRange(const EnumDescriptorProto::EnumReservedRange& proto,
const EnumDescriptor* parent,
EnumDescriptor::ReservedRange* result);
- void BuildOneof(const OneofDescriptorProto& proto,
- Descriptor* parent,
+ void BuildOneof(const OneofDescriptorProto& proto, Descriptor* parent,
OneofDescriptor* result);
void CheckEnumValueUniqueness(const EnumDescriptorProto& proto,
const EnumDescriptor* result);
- void BuildEnum(const EnumDescriptorProto& proto,
- const Descriptor* parent,
+ void BuildEnum(const EnumDescriptorProto& proto, const Descriptor* parent,
EnumDescriptor* result);
void BuildEnumValue(const EnumValueDescriptorProto& proto,
const EnumDescriptor* parent,
EnumValueDescriptor* result);
- void BuildService(const ServiceDescriptorProto& proto,
- const void* dummy,
+ void BuildService(const ServiceDescriptorProto& proto, const void* dummy,
ServiceDescriptor* result);
void BuildMethod(const MethodDescriptorProto& proto,
- const ServiceDescriptor* parent,
- MethodDescriptor* result);
+ const ServiceDescriptor* parent, MethodDescriptor* result);
void LogUnusedDependency(const FileDescriptorProto& proto,
const FileDescriptor* result);
@@ -3512,10 +3479,8 @@
const ServiceDescriptorProto& proto);
void ValidateMethodOptions(MethodDescriptor* method,
const MethodDescriptorProto& proto);
- void ValidateProto3(FileDescriptor* file,
- const FileDescriptorProto& proto);
- void ValidateProto3Message(Descriptor* message,
- const DescriptorProto& proto);
+ void ValidateProto3(FileDescriptor* file, const FileDescriptorProto& proto);
+ void ValidateProto3Message(Descriptor* message, const DescriptorProto& proto);
void ValidateProto3Field(FieldDescriptor* field,
const FieldDescriptorProto& proto);
void ValidateProto3Enum(EnumDescriptor* enm,
@@ -3538,27 +3503,26 @@
const FileDescriptor* DescriptorPool::BuildFile(
const FileDescriptorProto& proto) {
GOOGLE_CHECK(fallback_database_ == NULL)
- << "Cannot call BuildFile on a DescriptorPool that uses a "
- "DescriptorDatabase. You must instead find a way to get your file "
- "into the underlying database.";
- GOOGLE_CHECK(mutex_ == NULL); // Implied by the above GOOGLE_CHECK.
+ << "Cannot call BuildFile on a DescriptorPool that uses a "
+ "DescriptorDatabase. You must instead find a way to get your file "
+ "into the underlying database.";
+ GOOGLE_CHECK(mutex_ == NULL); // Implied by the above GOOGLE_CHECK.
tables_->known_bad_symbols_.clear();
tables_->known_bad_files_.clear();
return DescriptorBuilder(this, tables_.get(), NULL).BuildFile(proto);
}
const FileDescriptor* DescriptorPool::BuildFileCollectingErrors(
- const FileDescriptorProto& proto,
- ErrorCollector* error_collector) {
+ const FileDescriptorProto& proto, ErrorCollector* error_collector) {
GOOGLE_CHECK(fallback_database_ == NULL)
- << "Cannot call BuildFile on a DescriptorPool that uses a "
- "DescriptorDatabase. You must instead find a way to get your file "
- "into the underlying database.";
- GOOGLE_CHECK(mutex_ == NULL); // Implied by the above GOOGLE_CHECK.
+ << "Cannot call BuildFile on a DescriptorPool that uses a "
+ "DescriptorDatabase. You must instead find a way to get your file "
+ "into the underlying database.";
+ GOOGLE_CHECK(mutex_ == NULL); // Implied by the above GOOGLE_CHECK.
tables_->known_bad_symbols_.clear();
tables_->known_bad_files_.clear();
- return DescriptorBuilder(this, tables_.get(),
- error_collector).BuildFile(proto);
+ return DescriptorBuilder(this, tables_.get(), error_collector)
+ .BuildFile(proto);
}
const FileDescriptor* DescriptorPool::BuildFileFromDatabase(
@@ -3568,8 +3532,8 @@
return NULL;
}
const FileDescriptor* result =
- DescriptorBuilder(this, tables_.get(),
- default_error_collector_).BuildFile(proto);
+ DescriptorBuilder(this, tables_.get(), default_error_collector_)
+ .BuildFile(proto);
if (result == NULL) {
tables_->known_bad_files_.insert(proto.name());
}
@@ -3577,15 +3541,14 @@
}
DescriptorBuilder::DescriptorBuilder(
- const DescriptorPool* pool,
- DescriptorPool::Tables* tables,
+ const DescriptorPool* pool, DescriptorPool::Tables* tables,
DescriptorPool::ErrorCollector* error_collector)
- : pool_(pool),
- tables_(tables),
- error_collector_(error_collector),
- had_errors_(false),
- possible_undeclared_dependency_(NULL),
- undefine_resolved_name_("") {}
+ : pool_(pool),
+ tables_(tables),
+ error_collector_(error_collector),
+ had_errors_(false),
+ possible_undeclared_dependency_(NULL),
+ undefine_resolved_name_("") {}
DescriptorBuilder::~DescriptorBuilder() {}
@@ -3600,8 +3563,8 @@
}
GOOGLE_LOG(ERROR) << " " << element_name << ": " << error;
} else {
- error_collector_->AddError(filename_, element_name,
- &descriptor, location, error);
+ error_collector_->AddError(filename_, element_name, &descriptor, location,
+ error);
}
had_errors_ = true;
}
@@ -3624,19 +3587,22 @@
if (possible_undeclared_dependency_ != NULL) {
AddError(element_name, descriptor, location,
"\"" + possible_undeclared_dependency_name_ +
- "\" seems to be defined in \"" +
- possible_undeclared_dependency_->name() + "\", which is not "
- "imported by \"" + filename_ + "\". To use it here, please "
- "add the necessary import.");
+ "\" seems to be defined in \"" +
+ possible_undeclared_dependency_->name() +
+ "\", which is not "
+ "imported by \"" +
+ filename_ +
+ "\". To use it here, please "
+ "add the necessary import.");
}
if (!undefine_resolved_name_.empty()) {
AddError(element_name, descriptor, location,
"\"" + undefined_symbol + "\" is resolved to \"" +
- undefine_resolved_name_ + "\", which is not defined. "
- "The innermost scope is searched first in name resolution. "
- "Consider using a leading '.'(i.e., \"."
- + undefined_symbol +
- "\") to start from the outermost scope.");
+ undefine_resolved_name_ +
+ "\", which is not defined. "
+ "The innermost scope is searched first in name resolution. "
+ "Consider using a leading '.'(i.e., \"." +
+ undefined_symbol + "\") to start from the outermost scope.");
}
}
}
@@ -3875,10 +3841,10 @@
std::string::size_type dotpos = placeholder_full_name->find_last_of('.');
if (dotpos != std::string::npos) {
- placeholder_package = tables_->AllocateString(
- placeholder_full_name->substr(0, dotpos));
- placeholder_name = tables_->AllocateString(
- placeholder_full_name->substr(dotpos + 1));
+ placeholder_package =
+ tables_->AllocateString(placeholder_full_name->substr(0, dotpos));
+ placeholder_name =
+ tables_->AllocateString(placeholder_full_name->substr(dotpos + 1));
} else {
placeholder_package = &internal::GetEmptyString();
placeholder_name = placeholder_full_name;
@@ -3891,8 +3857,7 @@
if (placeholder_type == PLACEHOLDER_ENUM) {
placeholder_file->enum_type_count_ = 1;
- placeholder_file->enum_types_ =
- tables_->AllocateArray<EnumDescriptor>(1);
+ placeholder_file->enum_types_ = tables_->AllocateArray<EnumDescriptor>(1);
EnumDescriptor* placeholder_enum = &placeholder_file->enum_types_[0];
memset(placeholder_enum, 0, sizeof(*placeholder_enum));
@@ -3914,8 +3879,10 @@
placeholder_value->name_ = tables_->AllocateString("PLACEHOLDER_VALUE");
// Note that enum value names are siblings of their type, not children.
placeholder_value->full_name_ =
- placeholder_package->empty() ? placeholder_value->name_ :
- tables_->AllocateString(*placeholder_package + ".PLACEHOLDER_VALUE");
+ placeholder_package->empty()
+ ? placeholder_value->name_
+ : tables_->AllocateString(*placeholder_package +
+ ".PLACEHOLDER_VALUE");
placeholder_value->number_ = 0;
placeholder_value->type_ = placeholder_enum;
@@ -3924,8 +3891,7 @@
return Symbol(placeholder_enum);
} else {
placeholder_file->message_type_count_ = 1;
- placeholder_file->message_types_ =
- tables_->AllocateArray<Descriptor>(1);
+ placeholder_file->message_types_ = tables_->AllocateArray<Descriptor>(1);
Descriptor* placeholder_message = &placeholder_file->message_types_[0];
memset(placeholder_message, 0, sizeof(*placeholder_message));
@@ -3940,11 +3906,11 @@
if (placeholder_type == PLACEHOLDER_EXTENDABLE_MESSAGE) {
placeholder_message->extension_range_count_ = 1;
placeholder_message->extension_ranges_ =
- tables_->AllocateArray<Descriptor::ExtensionRange>(1);
+ tables_->AllocateArray<Descriptor::ExtensionRange>(1);
placeholder_message->extension_ranges_->start = 1;
// kMaxNumber + 1 because ExtensionRange::end is exclusive.
placeholder_message->extension_ranges_->end =
- FieldDescriptor::kMaxNumber + 1;
+ FieldDescriptor::kMaxNumber + 1;
}
return Symbol(placeholder_message);
@@ -3991,7 +3957,8 @@
// This is only possible if there was already an error adding something of
// the same name.
if (!had_errors_) {
- GOOGLE_LOG(DFATAL) << "\"" << full_name << "\" not previously defined in "
+ GOOGLE_LOG(DFATAL) << "\"" << full_name
+ << "\" not previously defined in "
"symbols_by_name_, but was defined in "
"symbols_by_parent_; this shouldn't be possible.";
}
@@ -4008,14 +3975,14 @@
} else {
AddError(full_name, proto, DescriptorPool::ErrorCollector::NAME,
"\"" + full_name.substr(dot_pos + 1) +
- "\" is already defined in \"" +
- full_name.substr(0, dot_pos) + "\".");
+ "\" is already defined in \"" +
+ full_name.substr(0, dot_pos) + "\".");
}
} else {
// Symbol seems to have been defined in a different file.
AddError(full_name, proto, DescriptorPool::ErrorCollector::NAME,
"\"" + full_name + "\" is already defined in file \"" +
- other_file->name() + "\".");
+ other_file->name() + "\".");
}
return false;
}
@@ -4043,9 +4010,10 @@
if (existing_symbol.type != Symbol::PACKAGE) {
// Symbol seems to have been defined in a different file.
AddError(name, proto, DescriptorPool::ErrorCollector::NAME,
- "\"" + name + "\" is already defined (as something other than "
- "a package) in file \"" + existing_symbol.GetFile()->name() +
- "\".");
+ "\"" + name +
+ "\" is already defined (as something other than "
+ "a package) in file \"" +
+ existing_symbol.GetFile()->name() + "\".");
}
}
}
@@ -4061,8 +4029,7 @@
// I don't trust isalnum() due to locales. :(
if ((name[i] < 'a' || 'z' < name[i]) &&
(name[i] < 'A' || 'Z' < name[i]) &&
- (name[i] < '0' || '9' < name[i]) &&
- (name[i] != '_')) {
+ (name[i] < '0' || '9' < name[i]) && (name[i] != '_')) {
AddError(full_name, proto, DescriptorPool::ErrorCollector::NAME,
"\"" + name + "\" is not a valid identifier.");
}
@@ -4136,11 +4103,11 @@
// A common pattern: We want to convert a repeated field in the descriptor
// to an array of values, calling some method to build each value.
-#define BUILD_ARRAY(INPUT, OUTPUT, NAME, METHOD, PARENT) \
- OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \
- AllocateArray(INPUT.NAME##_size(), &OUTPUT->NAME##s_); \
- for (int i = 0; i < INPUT.NAME##_size(); i++) { \
- METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i); \
+#define BUILD_ARRAY(INPUT, OUTPUT, NAME, METHOD, PARENT) \
+ OUTPUT->NAME##_count_ = INPUT.NAME##_size(); \
+ AllocateArray(INPUT.NAME##_size(), &OUTPUT->NAME##s_); \
+ for (int i = 0; i < INPUT.NAME##_size(); i++) { \
+ METHOD(INPUT.NAME(i), PARENT, OUTPUT->NAME##s_ + i); \
}
void DescriptorBuilder::AddRecursiveImportError(
@@ -4152,13 +4119,19 @@
}
error_message.append(proto.name());
- AddError(proto.name(), proto, DescriptorPool::ErrorCollector::OTHER,
- error_message);
+ if (from_here < tables_->pending_files_.size() - 1) {
+ AddError(tables_->pending_files_[from_here + 1], proto,
+ DescriptorPool::ErrorCollector::IMPORT, error_message);
+ } else {
+ AddError(proto.name(), proto, DescriptorPool::ErrorCollector::IMPORT,
+ error_message);
+ }
}
void DescriptorBuilder::AddTwiceListedError(const FileDescriptorProto& proto,
int index) {
- AddError(proto.name(), proto, DescriptorPool::ErrorCollector::OTHER,
+ AddError(proto.dependency(index), proto,
+ DescriptorPool::ErrorCollector::IMPORT,
"Import \"" + proto.dependency(index) + "\" was listed twice.");
}
@@ -4166,13 +4139,13 @@
int index) {
std::string message;
if (pool_->fallback_database_ == NULL) {
- message = "Import \"" + proto.dependency(index) +
- "\" has not been loaded.";
+ message = "Import \"" + proto.dependency(index) + "\" has not been loaded.";
} else {
message = "Import \"" + proto.dependency(index) +
"\" was not found or had errors.";
}
- AddError(proto.name(), proto, DescriptorPool::ErrorCollector::OTHER, message);
+ AddError(proto.dependency(index), proto,
+ DescriptorPool::ErrorCollector::IMPORT, message);
}
static bool ExistingFileMatchesProto(const FileDescriptor* existing_file,
@@ -4389,8 +4362,8 @@
// Check public dependencies.
int public_dependency_count = 0;
- result->public_dependencies_ = tables_->AllocateArray<int>(
- proto.public_dependency_size());
+ result->public_dependencies_ =
+ tables_->AllocateArray<int>(proto.public_dependency_size());
for (int i = 0; i < proto.public_dependency_size(); i++) {
// Only put valid public dependency indexes.
int index = proto.public_dependency(i);
@@ -4404,8 +4377,7 @@
unused_dependency_.erase(result->dependency(index));
}
} else {
- AddError(proto.name(), proto,
- DescriptorPool::ErrorCollector::OTHER,
+ AddError(proto.name(), proto, DescriptorPool::ErrorCollector::OTHER,
"Invalid public dependency index.");
}
}
@@ -4424,25 +4396,24 @@
// Check weak dependencies.
int weak_dependency_count = 0;
- result->weak_dependencies_ = tables_->AllocateArray<int>(
- proto.weak_dependency_size());
+ result->weak_dependencies_ =
+ tables_->AllocateArray<int>(proto.weak_dependency_size());
for (int i = 0; i < proto.weak_dependency_size(); i++) {
int index = proto.weak_dependency(i);
if (index >= 0 && index < proto.dependency_size()) {
result->weak_dependencies_[weak_dependency_count++] = index;
} else {
- AddError(proto.name(), proto,
- DescriptorPool::ErrorCollector::OTHER,
+ AddError(proto.name(), proto, DescriptorPool::ErrorCollector::OTHER,
"Invalid weak dependency index.");
}
}
result->weak_dependency_count_ = weak_dependency_count;
// Convert children.
- BUILD_ARRAY(proto, result, message_type, BuildMessage , NULL);
- BUILD_ARRAY(proto, result, enum_type , BuildEnum , NULL);
- BUILD_ARRAY(proto, result, service , BuildService , NULL);
- BUILD_ARRAY(proto, result, extension , BuildExtension, NULL);
+ BUILD_ARRAY(proto, result, message_type, BuildMessage, NULL);
+ BUILD_ARRAY(proto, result, enum_type, BuildEnum, NULL);
+ BUILD_ARRAY(proto, result, service, BuildService, NULL);
+ BUILD_ARRAY(proto, result, extension, BuildExtension, NULL);
// Copy options.
if (!proto.has_options()) {
@@ -4512,21 +4483,21 @@
ValidateSymbolName(proto.name(), *full_name, proto);
- result->name_ = tables_->AllocateString(proto.name());
- result->full_name_ = full_name;
- result->file_ = file_;
+ result->name_ = tables_->AllocateString(proto.name());
+ result->full_name_ = full_name;
+ result->file_ = file_;
result->containing_type_ = parent;
- result->is_placeholder_ = false;
+ result->is_placeholder_ = false;
result->is_unqualified_placeholder_ = false;
// Build oneofs first so that fields and extension ranges can refer to them.
- BUILD_ARRAY(proto, result, oneof_decl , BuildOneof , result);
- BUILD_ARRAY(proto, result, field , BuildField , result);
- BUILD_ARRAY(proto, result, nested_type , BuildMessage , result);
- BUILD_ARRAY(proto, result, enum_type , BuildEnum , result);
+ BUILD_ARRAY(proto, result, oneof_decl, BuildOneof, result);
+ BUILD_ARRAY(proto, result, field, BuildField, result);
+ BUILD_ARRAY(proto, result, nested_type, BuildMessage, result);
+ BUILD_ARRAY(proto, result, enum_type, BuildEnum, result);
BUILD_ARRAY(proto, result, extension_range, BuildExtensionRange, result);
- BUILD_ARRAY(proto, result, extension , BuildExtension , result);
- BUILD_ARRAY(proto, result, reserved_range , BuildReservedRange , result);
+ BUILD_ARRAY(proto, result, extension, BuildExtension, result);
+ BUILD_ARRAY(proto, result, reserved_range, BuildReservedRange, result);
// Copy reserved names.
int reserved_name_count = proto.reserved_name_size();
@@ -4546,8 +4517,7 @@
DescriptorProto::kOptionsFieldNumber);
}
- AddSymbol(result->full_name(), parent, result->name(),
- proto, Symbol(result));
+ AddSymbol(result->full_name(), parent, result->name(), proto, Symbol(result));
for (int i = 0; i < proto.reserved_range_size(); i++) {
@@ -4573,8 +4543,7 @@
} else {
AddError(name, proto, DescriptorPool::ErrorCollector::NAME,
strings::Substitute(
- "Field name \"$0\" is reserved multiple times.",
- name));
+ "Field name \"$0\" is reserved multiple times.", name));
}
}
@@ -4583,12 +4552,12 @@
for (int j = 0; j < result->extension_range_count(); j++) {
const Descriptor::ExtensionRange* range = result->extension_range(j);
if (range->start <= field->number() && field->number() < range->end) {
- AddError(field->full_name(), proto.extension_range(j),
- DescriptorPool::ErrorCollector::NUMBER,
- strings::Substitute(
- "Extension range $0 to $1 includes field \"$2\" ($3).",
- range->start, range->end - 1,
- field->name(), field->number()));
+ AddError(
+ field->full_name(), proto.extension_range(j),
+ DescriptorPool::ErrorCollector::NUMBER,
+ strings::Substitute(
+ "Extension range $0 to $1 includes field \"$2\" ($3).",
+ range->start, range->end - 1, field->name(), field->number()));
}
}
for (int j = 0; j < result->reserved_range_count(); j++) {
@@ -4596,16 +4565,15 @@
if (range->start <= field->number() && field->number() < range->end) {
AddError(field->full_name(), proto.reserved_range(j),
DescriptorPool::ErrorCollector::NUMBER,
- strings::Substitute(
- "Field \"$0\" uses reserved number $1.",
- field->name(), field->number()));
+ strings::Substitute("Field \"$0\" uses reserved number $1.",
+ field->name(), field->number()));
}
}
if (reserved_name_set.find(field->name()) != reserved_name_set.end()) {
- AddError(field->full_name(), proto.field(i),
- DescriptorPool::ErrorCollector::NAME,
- strings::Substitute(
- "Field name \"$0\" is reserved.", field->name()));
+ AddError(
+ field->full_name(), proto.field(i),
+ DescriptorPool::ErrorCollector::NAME,
+ strings::Substitute("Field name \"$0\" is reserved.", field->name()));
}
}
@@ -4650,10 +4618,10 @@
ValidateSymbolName(proto.name(), *full_name, proto);
- result->name_ = tables_->AllocateString(proto.name());
- result->full_name_ = full_name;
- result->file_ = file_;
- result->number_ = proto.number();
+ result->name_ = tables_->AllocateString(proto.name());
+ result->full_name_ = full_name;
+ result->file_ = file_;
+ result->number_ = proto.number();
result->is_extension_ = is_extension;
// If .proto files follow the style guide then the name should already be
@@ -4725,19 +4693,19 @@
switch (result->cpp_type()) {
case FieldDescriptor::CPPTYPE_INT32:
result->default_value_int32_ =
- strtol(proto.default_value().c_str(), &end_pos, 0);
+ strtol(proto.default_value().c_str(), &end_pos, 0);
break;
case FieldDescriptor::CPPTYPE_INT64:
result->default_value_int64_ =
- strto64(proto.default_value().c_str(), &end_pos, 0);
+ strto64(proto.default_value().c_str(), &end_pos, 0);
break;
case FieldDescriptor::CPPTYPE_UINT32:
result->default_value_uint32_ =
- strtoul(proto.default_value().c_str(), &end_pos, 0);
+ strtoul(proto.default_value().c_str(), &end_pos, 0);
break;
case FieldDescriptor::CPPTYPE_UINT64:
result->default_value_uint64_ =
- strtou64(proto.default_value().c_str(), &end_pos, 0);
+ strtou64(proto.default_value().c_str(), &end_pos, 0);
break;
case FieldDescriptor::CPPTYPE_FLOAT:
if (proto.default_value() == "inf") {
@@ -4749,7 +4717,7 @@
} else if (proto.default_value() == "nan") {
result->default_value_float_ =
std::numeric_limits<float>::quiet_NaN();
- } else {
+ } else {
result->default_value_float_ = io::SafeDoubleToFloat(
io::NoLocaleStrtod(proto.default_value().c_str(), &end_pos));
}
@@ -4764,7 +4732,7 @@
} else if (proto.default_value() == "nan") {
result->default_value_double_ =
std::numeric_limits<double>::quiet_NaN();
- } else {
+ } else {
result->default_value_double_ =
io::NoLocaleStrtod(proto.default_value().c_str(), &end_pos);
}
@@ -4787,7 +4755,7 @@
case FieldDescriptor::CPPTYPE_STRING:
if (result->type() == FieldDescriptor::TYPE_BYTES) {
result->default_value_string_ = tables_->AllocateString(
- UnescapeCEscapeString(proto.default_value()));
+ UnescapeCEscapeString(proto.default_value()));
} else {
result->default_value_string_ =
tables_->AllocateString(proto.default_value());
@@ -4809,7 +4777,7 @@
AddError(result->full_name(), proto,
DescriptorPool::ErrorCollector::DEFAULT_VALUE,
"Couldn't parse default value \"" + proto.default_value() +
- "\".");
+ "\".");
}
}
} else {
@@ -4868,10 +4836,10 @@
result->number() <= FieldDescriptor::kLastReservedNumber) {
AddError(result->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER,
strings::Substitute(
- "Field numbers $0 through $1 are reserved for the protocol "
- "buffer library implementation.",
- FieldDescriptor::kFirstReservedNumber,
- FieldDescriptor::kLastReservedNumber));
+ "Field numbers $0 through $1 are reserved for the protocol "
+ "buffer library implementation.",
+ FieldDescriptor::kFirstReservedNumber,
+ FieldDescriptor::kLastReservedNumber));
}
if (is_extension) {
@@ -4884,8 +4852,7 @@
result->extension_scope_ = parent;
if (proto.has_oneof_index()) {
- AddError(result->full_name(), proto,
- DescriptorPool::ErrorCollector::OTHER,
+ AddError(result->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
"FieldDescriptorProto.oneof_index should not be set for "
"extensions.");
}
@@ -4905,11 +4872,10 @@
if (proto.oneof_index() < 0 ||
proto.oneof_index() >= parent->oneof_decl_count()) {
AddError(result->full_name(), proto,
- DescriptorPool::ErrorCollector::OTHER,
+ DescriptorPool::ErrorCollector::TYPE,
strings::Substitute("FieldDescriptorProto.oneof_index $0 is "
"out of range for type \"$1\".",
- proto.oneof_index(),
- parent->name()));
+ proto.oneof_index(), parent->name()));
result->containing_oneof_ = NULL;
} else {
result->containing_oneof_ = parent->oneof_decl(proto.oneof_index());
@@ -4928,19 +4894,16 @@
}
- AddSymbol(result->full_name(), parent, result->name(),
- proto, Symbol(result));
+ AddSymbol(result->full_name(), parent, result->name(), proto, Symbol(result));
}
void DescriptorBuilder::BuildExtensionRange(
- const DescriptorProto::ExtensionRange& proto,
- const Descriptor* parent,
+ const DescriptorProto::ExtensionRange& proto, const Descriptor* parent,
Descriptor::ExtensionRange* result) {
result->start = proto.start();
result->end = proto.end();
if (result->start <= 0) {
- AddError(parent->full_name(), proto,
- DescriptorPool::ErrorCollector::NUMBER,
+ AddError(parent->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER,
"Extension numbers must be positive integers.");
}
@@ -4950,8 +4913,7 @@
// numbers are actually used as int32s in the message_set_wire_format.
if (result->start >= result->end) {
- AddError(parent->full_name(), proto,
- DescriptorPool::ErrorCollector::NUMBER,
+ AddError(parent->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER,
"Extension range end number must be greater than start number.");
}
@@ -4973,14 +4935,12 @@
}
void DescriptorBuilder::BuildReservedRange(
- const DescriptorProto::ReservedRange& proto,
- const Descriptor* parent,
+ const DescriptorProto::ReservedRange& proto, const Descriptor* parent,
Descriptor::ReservedRange* result) {
result->start = proto.start();
result->end = proto.end();
if (result->start <= 0) {
- AddError(parent->full_name(), proto,
- DescriptorPool::ErrorCollector::NUMBER,
+ AddError(parent->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER,
"Reserved numbers must be positive integers.");
}
}
@@ -4992,8 +4952,7 @@
result->end = proto.end();
if (result->start > result->end) {
- AddError(parent->full_name(), proto,
- DescriptorPool::ErrorCollector::NUMBER,
+ AddError(parent->full_name(), proto, DescriptorPool::ErrorCollector::NUMBER,
"Reserved range end number must be greater than start number.");
}
}
@@ -5024,8 +4983,7 @@
OneofDescriptorProto::kOptionsFieldNumber);
}
- AddSymbol(result->full_name(), parent, result->name(),
- proto, Symbol(result));
+ AddSymbol(result->full_name(), parent, result->name(), proto, Symbol(result));
}
void DescriptorBuilder::CheckEnumValueUniqueness(
@@ -5105,18 +5063,17 @@
ValidateSymbolName(proto.name(), *full_name, proto);
- result->name_ = tables_->AllocateString(proto.name());
- result->full_name_ = full_name;
- result->file_ = file_;
+ result->name_ = tables_->AllocateString(proto.name());
+ result->full_name_ = full_name;
+ result->file_ = file_;
result->containing_type_ = parent;
- result->is_placeholder_ = false;
+ result->is_placeholder_ = false;
result->is_unqualified_placeholder_ = false;
if (proto.value_size() == 0) {
// We cannot allow enums with no values because this would mean there
// would be no valid default value for fields of this type.
- AddError(result->full_name(), proto,
- DescriptorPool::ErrorCollector::NAME,
+ AddError(result->full_name(), proto, DescriptorPool::ErrorCollector::NAME,
"Enums must contain at least one value.");
}
@@ -5143,8 +5100,7 @@
EnumDescriptorProto::kOptionsFieldNumber);
}
- AddSymbol(result->full_name(), parent, result->name(),
- proto, Symbol(result));
+ AddSymbol(result->full_name(), parent, result->name(), proto, Symbol(result));
for (int i = 0; i < proto.reserved_range_size(); i++) {
const EnumDescriptorProto_EnumReservedRange& range1 =
@@ -5171,8 +5127,7 @@
} else {
AddError(name, proto, DescriptorPool::ErrorCollector::NAME,
strings::Substitute(
- "Enum value \"$0\" is reserved multiple times.",
- name));
+ "Enum value \"$0\" is reserved multiple times.", name));
}
}
@@ -5181,18 +5136,18 @@
for (int j = 0; j < result->reserved_range_count(); j++) {
const EnumDescriptor::ReservedRange* range = result->reserved_range(j);
if (range->start <= value->number() && value->number() <= range->end) {
- AddError(value->full_name(), proto.reserved_range(j),
- DescriptorPool::ErrorCollector::NUMBER,
- strings::Substitute(
- "Enum value \"$0\" uses reserved number $1.",
- value->name(), value->number()));
+ AddError(
+ value->full_name(), proto.reserved_range(j),
+ DescriptorPool::ErrorCollector::NUMBER,
+ strings::Substitute("Enum value \"$0\" uses reserved number $1.",
+ value->name(), value->number()));
}
}
if (reserved_name_set.find(value->name()) != reserved_name_set.end()) {
- AddError(value->full_name(), proto.value(i),
- DescriptorPool::ErrorCollector::NAME,
- strings::Substitute(
- "Enum value \"$0\" is reserved.", value->name()));
+ AddError(
+ value->full_name(), proto.value(i),
+ DescriptorPool::ErrorCollector::NAME,
+ strings::Substitute("Enum value \"$0\" is reserved.", value->name()));
}
}
}
@@ -5200,9 +5155,9 @@
void DescriptorBuilder::BuildEnumValue(const EnumValueDescriptorProto& proto,
const EnumDescriptor* parent,
EnumValueDescriptor* result) {
- result->name_ = tables_->AllocateString(proto.name());
+ result->name_ = tables_->AllocateString(proto.name());
result->number_ = proto.number();
- result->type_ = parent;
+ result->type_ = parent;
// Note: full_name for enum values is a sibling to the parent's name, not a
// child of it.
@@ -5225,15 +5180,15 @@
// of the enum type instead of children of it. So, we use
// parent->containing_type() as the value's parent.
bool added_to_outer_scope =
- AddSymbol(result->full_name(), parent->containing_type(), result->name(),
- proto, Symbol(result));
+ AddSymbol(result->full_name(), parent->containing_type(), result->name(),
+ proto, Symbol(result));
// However, we also want to be able to search for values within a single
// enum type, so we add it as a child of the enum type itself, too.
// Note: This could fail, but if it does, the error has already been
// reported by the above AddSymbol() call, so we ignore the return code.
bool added_to_inner_scope =
- file_tables_->AddAliasUnderParent(parent, result->name(), Symbol(result));
+ file_tables_->AddAliasUnderParent(parent, result->name(), Symbol(result));
if (added_to_inner_scope && !added_to_outer_scope) {
// This value did not conflict with any values defined in the same enum,
@@ -5252,12 +5207,12 @@
outer_scope = "\"" + outer_scope + "\"";
}
- AddError(result->full_name(), proto,
- DescriptorPool::ErrorCollector::NAME,
+ AddError(result->full_name(), proto, DescriptorPool::ErrorCollector::NAME,
"Note that enum values use C++ scoping rules, meaning that "
"enum values are siblings of their type, not children of it. "
- "Therefore, \"" + result->name() + "\" must be unique within "
- + outer_scope + ", not just within \"" + parent->name() + "\".");
+ "Therefore, \"" +
+ result->name() + "\" must be unique within " + outer_scope +
+ ", not just within \"" + parent->name() + "\".");
}
// An enum is allowed to define two numbers that refer to the same value.
@@ -5275,9 +5230,9 @@
ValidateSymbolName(proto.name(), *full_name, proto);
- result->name_ = tables_->AllocateString(proto.name());
+ result->name_ = tables_->AllocateString(proto.name());
result->full_name_ = full_name;
- result->file_ = file_;
+ result->file_ = file_;
BUILD_ARRAY(proto, result, method, BuildMethod, result);
@@ -5289,14 +5244,13 @@
ServiceDescriptorProto::kOptionsFieldNumber);
}
- AddSymbol(result->full_name(), NULL, result->name(),
- proto, Symbol(result));
+ AddSymbol(result->full_name(), NULL, result->name(), proto, Symbol(result));
}
void DescriptorBuilder::BuildMethod(const MethodDescriptorProto& proto,
const ServiceDescriptor* parent,
MethodDescriptor* result) {
- result->name_ = tables_->AllocateString(proto.name());
+ result->name_ = tables_->AllocateString(proto.name());
result->service_ = parent;
std::string* full_name = tables_->AllocateString(parent->full_name());
@@ -5321,16 +5275,15 @@
result->client_streaming_ = proto.client_streaming();
result->server_streaming_ = proto.server_streaming();
- AddSymbol(result->full_name(), parent, result->name(),
- proto, Symbol(result));
+ AddSymbol(result->full_name(), parent, result->name(), proto, Symbol(result));
}
#undef BUILD_ARRAY
// -------------------------------------------------------------------
-void DescriptorBuilder::CrossLinkFile(
- FileDescriptor* file, const FileDescriptorProto& proto) {
+void DescriptorBuilder::CrossLinkFile(FileDescriptor* file,
+ const FileDescriptorProto& proto) {
if (file->options_ == NULL) {
file->options_ = &FileOptions::default_instance();
}
@@ -5352,8 +5305,8 @@
}
}
-void DescriptorBuilder::CrossLinkMessage(
- Descriptor* message, const DescriptorProto& proto) {
+void DescriptorBuilder::CrossLinkMessage(Descriptor* message,
+ const DescriptorProto& proto) {
if (message->options_ == NULL) {
message->options_ = &MessageOptions::default_instance();
}
@@ -5393,14 +5346,13 @@
// safe.
if (oneof_decl->field_count() > 0 &&
message->field(i - 1)->containing_oneof() != oneof_decl) {
- AddError(
- message->full_name() + "." + message->field(i - 1)->name(),
- proto.field(i - 1), DescriptorPool::ErrorCollector::OTHER,
- strings::Substitute(
- "Fields in the same oneof must be defined consecutively. "
- "\"$0\" cannot be defined before the completion of the "
- "\"$1\" oneof definition.",
- message->field(i - 1)->name(), oneof_decl->name()));
+ AddError(message->full_name() + "." + message->field(i - 1)->name(),
+ proto.field(i - 1), DescriptorPool::ErrorCollector::TYPE,
+ strings::Substitute(
+ "Fields in the same oneof must be defined consecutively. "
+ "\"$0\" cannot be defined before the completion of the "
+ "\"$1\" oneof definition.",
+ message->field(i - 1)->name(), oneof_decl->name()));
}
// Must go through oneof_decls_ array to get a non-const version of the
// OneofDescriptor.
@@ -5414,13 +5366,12 @@
if (oneof_decl->field_count() == 0) {
AddError(message->full_name() + "." + oneof_decl->name(),
- proto.oneof_decl(i),
- DescriptorPool::ErrorCollector::NAME,
+ proto.oneof_decl(i), DescriptorPool::ErrorCollector::NAME,
"Oneof must have at least one field.");
}
- oneof_decl->fields_ =
- tables_->AllocateArray<const FieldDescriptor*>(oneof_decl->field_count_);
+ oneof_decl->fields_ = tables_->AllocateArray<const FieldDescriptor*>(
+ oneof_decl->field_count_);
oneof_decl->field_count_ = 0;
if (oneof_decl->options_ == NULL) {
@@ -5449,8 +5400,8 @@
}
}
-void DescriptorBuilder::CrossLinkField(
- FieldDescriptor* field, const FieldDescriptorProto& proto) {
+void DescriptorBuilder::CrossLinkField(FieldDescriptor* field,
+ const FieldDescriptorProto& proto) {
if (field->options_ == NULL) {
field->options_ = &FieldOptions::default_instance();
}
@@ -5475,8 +5426,9 @@
}
field->containing_type_ = extendee.descriptor;
- const Descriptor::ExtensionRange* extension_range = field->containing_type()
- ->FindExtensionRangeContainingNumber(field->number());
+ const Descriptor::ExtensionRange* extension_range =
+ field->containing_type()->FindExtensionRangeContainingNumber(
+ field->number());
if (extension_range == NULL) {
AddError(field->full_name(), proto,
@@ -5493,8 +5445,7 @@
// Note that this error will never happen when parsing .proto files.
// It can only happen if you manually construct a FileDescriptorProto
// that is incorrect.
- AddError(field->full_name(), proto,
- DescriptorPool::ErrorCollector::NAME,
+ AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::NAME,
"Fields of oneofs must themselves have label LABEL_OPTIONAL.");
}
}
@@ -5615,20 +5566,19 @@
// We can't just use field->enum_type()->FindValueByName() here
// because that locks the pool's mutex, which we have already locked
// at this point.
- Symbol default_value =
- LookupSymbolNoPlaceholder(proto.default_value(),
- field->enum_type()->full_name());
+ Symbol default_value = LookupSymbolNoPlaceholder(
+ proto.default_value(), field->enum_type()->full_name());
if (default_value.type == Symbol::ENUM_VALUE &&
default_value.enum_value_descriptor->type() ==
- field->enum_type()) {
+ field->enum_type()) {
field->default_value_enum_ = default_value.enum_value_descriptor;
} else {
AddError(field->full_name(), proto,
DescriptorPool::ErrorCollector::DEFAULT_VALUE,
"Enum type \"" + field->enum_type()->full_name() +
- "\" has no value named \"" + proto.default_value() +
- "\".");
+ "\" has no value named \"" + proto.default_value() +
+ "\".");
}
}
} else if (field->enum_type()->value_count() > 0) {
@@ -5656,9 +5606,8 @@
// risk to calling containing_type() or other accessors that will build
// dependencies.
if (!file_tables_->AddFieldByNumber(field)) {
- const FieldDescriptor* conflicting_field =
- file_tables_->FindFieldByNumber(field->containing_type(),
- field->number());
+ const FieldDescriptor* conflicting_field = file_tables_->FindFieldByNumber(
+ field->containing_type(), field->number());
std::string containing_type_name =
field->containing_type() == NULL
? "unknown"
@@ -5668,16 +5617,14 @@
DescriptorPool::ErrorCollector::NUMBER,
strings::Substitute("Extension number $0 has already been used "
"in \"$1\" by extension \"$2\".",
- field->number(),
- containing_type_name,
+ field->number(), containing_type_name,
conflicting_field->full_name()));
} else {
AddError(field->full_name(), proto,
DescriptorPool::ErrorCollector::NUMBER,
strings::Substitute("Field number $0 has already been used in "
"\"$1\" by field \"$2\".",
- field->number(),
- containing_type_name,
+ field->number(), containing_type_name,
conflicting_field->name()));
}
} else {
@@ -5705,8 +5652,8 @@
}
}
-void DescriptorBuilder::CrossLinkEnum(
- EnumDescriptor* enum_type, const EnumDescriptorProto& proto) {
+void DescriptorBuilder::CrossLinkEnum(EnumDescriptor* enum_type,
+ const EnumDescriptorProto& proto) {
if (enum_type->options_ == NULL) {
enum_type->options_ = &EnumOptions::default_instance();
}
@@ -5724,8 +5671,8 @@
}
}
-void DescriptorBuilder::CrossLinkService(
- ServiceDescriptor* service, const ServiceDescriptorProto& proto) {
+void DescriptorBuilder::CrossLinkService(ServiceDescriptor* service,
+ const ServiceDescriptorProto& proto) {
if (service->options_ == NULL) {
service->options_ = &ServiceOptions::default_instance();
}
@@ -5735,8 +5682,8 @@
}
}
-void DescriptorBuilder::CrossLinkMethod(
- MethodDescriptor* method, const MethodDescriptorProto& proto) {
+void DescriptorBuilder::CrossLinkMethod(MethodDescriptor* method,
+ const MethodDescriptorProto& proto) {
if (method->options_ == NULL) {
method->options_ = &MethodOptions::default_instance();
}
@@ -5784,10 +5731,10 @@
// -------------------------------------------------------------------
-#define VALIDATE_OPTIONS_FROM_ARRAY(descriptor, array_name, type) \
- for (int i = 0; i < descriptor->array_name##_count(); ++i) { \
- Validate##type##Options(descriptor->array_name##s_ + i, \
- proto.array_name(i)); \
+#define VALIDATE_OPTIONS_FROM_ARRAY(descriptor, array_name, type) \
+ for (int i = 0; i < descriptor->array_name##_count(); ++i) { \
+ Validate##type##Options(descriptor->array_name##s_ + i, \
+ proto.array_name(i)); \
}
// Determine if the file uses optimize_for = LITE_RUNTIME, being careful to
@@ -5795,8 +5742,7 @@
static bool IsLite(const FileDescriptor* file) {
// TODO(kenton): I don't even remember how many of these conditions are
// actually possible. I'm just being super-safe.
- return file != NULL &&
- &file->options() != &FileOptions::default_instance() &&
+ return file != NULL && &file->options() != &FileOptions::default_instance() &&
file->options().optimize_for() == FileOptions::LITE_RUNTIME;
}
@@ -5812,11 +5758,12 @@
for (int i = 0; i < file->dependency_count(); i++) {
if (IsLite(file->dependency(i))) {
AddError(
- file->name(), proto,
- DescriptorPool::ErrorCollector::OTHER,
- "Files that do not use optimize_for = LITE_RUNTIME cannot import "
- "files which do use this option. This file is not lite, but it "
- "imports \"" + file->dependency(i)->name() + "\" which is.");
+ file->dependency(i)->name(), proto,
+ DescriptorPool::ErrorCollector::IMPORT,
+ "Files that do not use optimize_for = LITE_RUNTIME cannot import "
+ "files which do use this option. This file is not lite, but it "
+ "imports \"" +
+ file->dependency(i)->name() + "\" which is.");
break;
}
}
@@ -5826,8 +5773,8 @@
}
}
-void DescriptorBuilder::ValidateProto3(
- FileDescriptor* file, const FileDescriptorProto& proto) {
+void DescriptorBuilder::ValidateProto3(FileDescriptor* file,
+ const FileDescriptorProto& proto) {
for (int i = 0; i < file->extension_count(); ++i) {
ValidateProto3Field(file->extensions_ + i, proto.extension(i));
}
@@ -5853,31 +5800,28 @@
return result;
}
-void DescriptorBuilder::ValidateProto3Message(
- Descriptor* message, const DescriptorProto& proto) {
+void DescriptorBuilder::ValidateProto3Message(Descriptor* message,
+ const DescriptorProto& proto) {
for (int i = 0; i < message->nested_type_count(); ++i) {
- ValidateProto3Message(message->nested_types_ + i,
- proto.nested_type(i));
+ ValidateProto3Message(message->nested_types_ + i, proto.nested_type(i));
}
for (int i = 0; i < message->enum_type_count(); ++i) {
- ValidateProto3Enum(message->enum_types_ + i,
- proto.enum_type(i));
+ ValidateProto3Enum(message->enum_types_ + i, proto.enum_type(i));
}
for (int i = 0; i < message->field_count(); ++i) {
ValidateProto3Field(message->fields_ + i, proto.field(i));
}
for (int i = 0; i < message->extension_count(); ++i) {
- ValidateProto3Field(message->extensions_ +i, proto.extension(i));
+ ValidateProto3Field(message->extensions_ + i, proto.extension(i));
}
if (message->extension_range_count() > 0) {
- AddError(message->full_name(), proto,
- DescriptorPool::ErrorCollector::OTHER,
+ AddError(message->full_name(), proto.extension_range(0),
+ DescriptorPool::ErrorCollector::NUMBER,
"Extension ranges are not allowed in proto3.");
}
if (message->options().message_set_wire_format()) {
// Using MessageSet doesn't make sense since we disallow extensions.
- AddError(message->full_name(), proto,
- DescriptorPool::ErrorCollector::OTHER,
+ AddError(message->full_name(), proto, DescriptorPool::ErrorCollector::NAME,
"MessageSet is not supported in proto3.");
}
@@ -5889,61 +5833,58 @@
std::string lowercase_name =
ToLowercaseWithoutUnderscores(message->field(i)->name());
if (name_to_field.find(lowercase_name) != name_to_field.end()) {
- AddError(message->full_name(), proto,
- DescriptorPool::ErrorCollector::OTHER,
+ AddError(message->full_name(), proto.field(i),
+ DescriptorPool::ErrorCollector::NAME,
"The JSON camel-case name of field \"" +
- message->field(i)->name() + "\" conflicts with field \"" +
- name_to_field[lowercase_name]->name() + "\". This is not " +
- "allowed in proto3.");
+ message->field(i)->name() + "\" conflicts with field \"" +
+ name_to_field[lowercase_name]->name() + "\". This is not " +
+ "allowed in proto3.");
} else {
name_to_field[lowercase_name] = message->field(i);
}
}
}
-void DescriptorBuilder::ValidateProto3Field(
- FieldDescriptor* field, const FieldDescriptorProto& proto) {
+void DescriptorBuilder::ValidateProto3Field(FieldDescriptor* field,
+ const FieldDescriptorProto& proto) {
if (field->is_extension() &&
!AllowedExtendeeInProto3(field->containing_type()->full_name())) {
AddError(field->full_name(), proto,
- DescriptorPool::ErrorCollector::OTHER,
+ DescriptorPool::ErrorCollector::EXTENDEE,
"Extensions in proto3 are only allowed for defining options.");
}
if (field->is_required()) {
- AddError(field->full_name(), proto,
- DescriptorPool::ErrorCollector::OTHER,
+ AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
"Required fields are not allowed in proto3.");
}
if (field->has_default_value()) {
- AddError(
- field->full_name(), proto, DescriptorPool::ErrorCollector::OTHER,
- "Explicit default values are not allowed in proto3.");
+ AddError(field->full_name(), proto,
+ DescriptorPool::ErrorCollector::DEFAULT_VALUE,
+ "Explicit default values are not allowed in proto3.");
}
if (field->cpp_type() == FieldDescriptor::CPPTYPE_ENUM &&
field->enum_type() &&
field->enum_type()->file()->syntax() != FileDescriptor::SYNTAX_PROTO3) {
// Proto3 messages can only use Proto3 enum types; otherwise we can't
// guarantee that the default value is zero.
- AddError(field->full_name(), proto,
- DescriptorPool::ErrorCollector::TYPE,
+ AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
"Enum type \"" + field->enum_type()->full_name() +
- "\" is not a proto3 enum, but is used in \"" +
- field->containing_type()->full_name() +
- "\" which is a proto3 message type.");
+ "\" is not a proto3 enum, but is used in \"" +
+ field->containing_type()->full_name() +
+ "\" which is a proto3 message type.");
}
if (field->type() == FieldDescriptor::TYPE_GROUP) {
- AddError(field->full_name(), proto,
- DescriptorPool::ErrorCollector::TYPE,
+ AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
"Groups are not supported in proto3 syntax.");
}
}
-void DescriptorBuilder::ValidateProto3Enum(
- EnumDescriptor* enm, const EnumDescriptorProto& proto) {
+void DescriptorBuilder::ValidateProto3Enum(EnumDescriptor* enm,
+ const EnumDescriptorProto& proto) {
if (enm->value_count() > 0 && enm->value(0)->number() != 0) {
- AddError(
- enm->full_name(), proto, DescriptorPool::ErrorCollector::OTHER,
- "The first enum value must be zero in proto3.");
+ AddError(enm->full_name(), proto.value(0),
+ DescriptorPool::ErrorCollector::NUMBER,
+ "The first enum value must be zero in proto3.");
}
}
@@ -5955,9 +5896,9 @@
VALIDATE_OPTIONS_FROM_ARRAY(message, extension, Field);
const int64 max_extension_range =
- static_cast<int64>(message->options().message_set_wire_format() ?
- kint32max :
- FieldDescriptor::kMaxNumber);
+ static_cast<int64>(message->options().message_set_wire_format()
+ ? kint32max
+ : FieldDescriptor::kMaxNumber);
for (int i = 0; i < message->extension_range_count(); ++i) {
if (message->extension_range(i)->end > max_extension_range + 1) {
AddError(
@@ -5970,16 +5911,15 @@
}
-void DescriptorBuilder::ValidateFieldOptions(FieldDescriptor* field,
- const FieldDescriptorProto& proto) {
+void DescriptorBuilder::ValidateFieldOptions(
+ FieldDescriptor* field, const FieldDescriptorProto& proto) {
if (pool_->lazily_build_dependencies_ && (!field || !field->message_type())) {
return;
}
// Only message type fields may be lazy.
if (field->options().lazy()) {
if (field->type() != FieldDescriptor::TYPE_MESSAGE) {
- AddError(field->full_name(), proto,
- DescriptorPool::ErrorCollector::TYPE,
+ AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
"[lazy = true] can only be specified for submessage fields.");
}
}
@@ -5987,16 +5927,15 @@
// Only repeated primitive fields may be packed.
if (field->options().packed() && !field->is_packable()) {
AddError(
- field->full_name(), proto,
- DescriptorPool::ErrorCollector::TYPE,
- "[packed = true] can only be specified for repeated primitive fields.");
+ field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
+ "[packed = true] can only be specified for repeated primitive fields.");
}
// Note: Default instance may not yet be initialized here, so we have to
// avoid reading from it.
if (field->containing_type_ != NULL &&
&field->containing_type()->options() !=
- &MessageOptions::default_instance() &&
+ &MessageOptions::default_instance() &&
field->containing_type()->options().message_set_wire_format()) {
if (field->is_extension()) {
if (!field->is_optional() ||
@@ -6006,15 +5945,13 @@
"Extensions of MessageSets must be optional messages.");
}
} else {
- AddError(field->full_name(), proto,
- DescriptorPool::ErrorCollector::NAME,
+ AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::NAME,
"MessageSets cannot have fields, only extensions.");
}
}
// Lite extensions can only be of Lite types.
- if (IsLite(field->file()) &&
- field->containing_type_ != NULL &&
+ if (IsLite(field->file()) && field->containing_type_ != NULL &&
!IsLite(field->containing_type()->file())) {
AddError(field->full_name(), proto,
DescriptorPool::ErrorCollector::EXTENDEE,
@@ -6026,8 +5963,7 @@
// Validate map types.
if (field->is_map()) {
if (!ValidateMapEntry(field, proto)) {
- AddError(field->full_name(), proto,
- DescriptorPool::ErrorCollector::OTHER,
+ AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
"map_entry should not be set explicitly. Use map<KeyType, "
"ValueType> instead.");
}
@@ -6070,13 +6006,8 @@
"'option allow_alias = true;' to the enum definition.";
if (!enm->options().allow_alias()) {
// Generate error if duplicated enum values are explicitly disallowed.
- AddError(enm->full_name(), proto,
- DescriptorPool::ErrorCollector::NUMBER,
- error);
- } else {
- // Generate warning if duplicated values are found but the option
- // isn't set.
- GOOGLE_LOG(ERROR) << error;
+ AddError(enm->full_name(), proto.value(i),
+ DescriptorPool::ErrorCollector::NUMBER, error);
}
} else {
used_values[enum_value->number()] = enum_value->full_name();
@@ -6090,13 +6021,12 @@
const EnumValueDescriptorProto& /* proto */) {
// Nothing to do so far.
}
-void DescriptorBuilder::ValidateServiceOptions(ServiceDescriptor* service,
- const ServiceDescriptorProto& proto) {
+void DescriptorBuilder::ValidateServiceOptions(
+ ServiceDescriptor* service, const ServiceDescriptorProto& proto) {
if (IsLite(service->file()) &&
(service->file()->options().cc_generic_services() ||
service->file()->options().java_generic_services())) {
- AddError(service->full_name(), proto,
- DescriptorPool::ErrorCollector::NAME,
+ AddError(service->full_name(), proto, DescriptorPool::ErrorCollector::NAME,
"Files with optimize_for = LITE_RUNTIME cannot define services "
"unless you set both options cc_generic_services and "
"java_generic_sevices to false.");
@@ -6105,16 +6035,16 @@
VALIDATE_OPTIONS_FROM_ARRAY(service, method, Method);
}
-void DescriptorBuilder::ValidateMethodOptions(MethodDescriptor* /* method */,
- const MethodDescriptorProto& /* proto */) {
+void DescriptorBuilder::ValidateMethodOptions(
+ MethodDescriptor* /* method */, const MethodDescriptorProto& /* proto */) {
// Nothing to do so far.
}
bool DescriptorBuilder::ValidateMapEntry(FieldDescriptor* field,
const FieldDescriptorProto& proto) {
const Descriptor* message = field->message_type();
- if (// Must not contain extensions, extension range or nested message or
- // enums
+ if ( // Must not contain extensions, extension range or nested message or
+ // enums
message->extension_count() != 0 ||
field->label() != FieldDescriptor::LABEL_REPEATED ||
message->extension_range_count() != 0 ||
@@ -6142,9 +6072,8 @@
// Check key types are legal.
switch (key->type()) {
case FieldDescriptor::TYPE_ENUM:
- AddError(
- field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
- "Key in map fields cannot be enum types.");
+ AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
+ "Key in map fields cannot be enum types.");
break;
case FieldDescriptor::TYPE_FLOAT:
case FieldDescriptor::TYPE_DOUBLE:
@@ -6169,15 +6098,14 @@
case FieldDescriptor::TYPE_SFIXED64:
// Legal cases
break;
- // Do not add a default, so that the compiler will complain when new types
- // are added.
+ // Do not add a default, so that the compiler will complain when new types
+ // are added.
}
if (value->type() == FieldDescriptor::TYPE_ENUM) {
if (value->enum_type()->value(0)->number() != 0) {
- AddError(
- field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
- "Enum value in map must define 0 as the first value.");
+ AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
+ "Enum value in map must define 0 as the first value.");
}
}
@@ -6197,7 +6125,7 @@
AddError(message->full_name(), proto,
DescriptorPool::ErrorCollector::NAME,
"Expanded map entry type " + nested->name() +
- " conflicts with an existing nested message type.");
+ " conflicts with an existing nested message type.");
}
}
// Recursively test on the nested types.
@@ -6212,7 +6140,7 @@
AddError(message->full_name(), proto,
DescriptorPool::ErrorCollector::NAME,
"Expanded map entry type " + iter->second->name() +
- " conflicts with an existing field.");
+ " conflicts with an existing field.");
}
}
// Check for conflicted enum names.
@@ -6224,7 +6152,7 @@
AddError(message->full_name(), proto,
DescriptorPool::ErrorCollector::NAME,
"Expanded map entry type " + iter->second->name() +
- " conflicts with an existing enum type.");
+ " conflicts with an existing enum type.");
}
}
// Check for conflicted oneof names.
@@ -6236,7 +6164,7 @@
AddError(message->full_name(), proto,
DescriptorPool::ErrorCollector::NAME,
"Expanded map entry type " + iter->second->name() +
- " conflicts with an existing oneof type.");
+ " conflicts with an existing oneof type.");
}
}
}
@@ -6264,7 +6192,7 @@
AddError(field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
"Illegal jstype for int64, uint64, sint64, fixed64 "
"or sfixed64 field: " +
- FieldOptions_JSType_descriptor()->value(jstype)->name());
+ FieldOptions_JSType_descriptor()->value(jstype)->name());
break;
// No other types permit a jstype option.
@@ -6281,12 +6209,12 @@
// -------------------------------------------------------------------
DescriptorBuilder::OptionInterpreter::OptionInterpreter(
- DescriptorBuilder* builder) : builder_(builder) {
+ DescriptorBuilder* builder)
+ : builder_(builder) {
GOOGLE_CHECK(builder_);
}
-DescriptorBuilder::OptionInterpreter::~OptionInterpreter() {
-}
+DescriptorBuilder::OptionInterpreter::~OptionInterpreter() {}
bool DescriptorBuilder::OptionInterpreter::InterpretOptions(
OptionsToInterpret* options_to_interpret) {
@@ -6311,13 +6239,14 @@
// Find the uninterpreted_option field in the original options.
const FieldDescriptor* original_uninterpreted_options_field =
- original_options->GetDescriptor()->
- FindFieldByName("uninterpreted_option");
+ original_options->GetDescriptor()->FindFieldByName(
+ "uninterpreted_option");
GOOGLE_CHECK(original_uninterpreted_options_field != NULL)
<< "No field named \"uninterpreted_option\" in the Options proto.";
- const int num_uninterpreted_options = original_options->GetReflection()->
- FieldSize(*original_options, original_uninterpreted_options_field);
+ const int num_uninterpreted_options =
+ original_options->GetReflection()->FieldSize(
+ *original_options, original_uninterpreted_options_field);
for (int i = 0; i < num_uninterpreted_options; ++i) {
src_path.push_back(i);
uninterpreted_option_ = down_cast<const UninterpretedOption*>(
@@ -6357,8 +6286,11 @@
DescriptorPool::ErrorCollector::OTHER,
"Some options could not be correctly parsed using the proto "
"descriptors compiled into this binary.\n"
- "Unparsed options: " + unparsed_options->ShortDebugString() + "\n"
- "Parsing attempt: " + options->ShortDebugString());
+ "Unparsed options: " +
+ unparsed_options->ShortDebugString() +
+ "\n"
+ "Parsing attempt: " +
+ options->ShortDebugString());
// Restore the unparsed options.
options->GetReflection()->Swap(unparsed_options.get(), options);
}
@@ -6376,8 +6308,9 @@
return AddNameError("Option must have a name.");
}
if (uninterpreted_option_->name(0).name_part() == "uninterpreted_option") {
- return AddNameError("Option must not use reserved name "
- "\"uninterpreted_option\".");
+ return AddNameError(
+ "Option must not use reserved name "
+ "\"uninterpreted_option\".");
}
const Descriptor* options_descriptor = NULL;
@@ -6392,7 +6325,7 @@
// FindSymbol() because files that use custom options only need to depend on
// the file that defines the option, not descriptor.proto itself.
Symbol symbol = builder_->FindSymbolNotEnforcingDeps(
- options->GetDescriptor()->full_name());
+ options->GetDescriptor()->full_name());
if (!symbol.IsNull() && symbol.type == Symbol::MESSAGE) {
options_descriptor = symbol.descriptor;
} else {
@@ -6428,8 +6361,8 @@
// DescriptorPool::FindExtensionByName(), for two reasons: 1) It allows
// relative lookups, and 2) because we're already holding the pool's
// mutex, and the latter method locks it again.
- symbol = builder_->LookupSymbol(name_part,
- options_to_interpret_->name_scope);
+ symbol =
+ builder_->LookupSymbol(name_part, options_to_interpret_->name_scope);
if (!symbol.IsNull() && symbol.type == Symbol::FIELD) {
field = symbol.field_descriptor;
}
@@ -6460,8 +6393,9 @@
"\") to start from the outermost scope.");
} else {
return AddNameError(
- "Option \"" + debug_msg_name + "\" unknown. Ensure that your proto" +
- " definition file imports the proto which defines the option.");
+ "Option \"" + debug_msg_name +
+ "\" unknown. Ensure that your proto" +
+ " definition file imports the proto which defines the option.");
}
} else if (field->containing_type() != descriptor) {
if (get_is_placeholder(field->containing_type())) {
@@ -6510,10 +6444,10 @@
// known will populate them correctly.
// First see if the option is already set.
- if (!field->is_repeated() && !ExamineIfOptionIsSet(
- intermediate_fields.begin(),
- intermediate_fields.end(),
- field, debug_msg_name,
+ if (!field->is_repeated() &&
+ !ExamineIfOptionIsSet(
+ intermediate_fields.begin(), intermediate_fields.end(), field,
+ debug_msg_name,
options->GetReflection()->GetUnknownFields(*options))) {
return false; // ExamineIfOptionIsSet() already added the error.
}
@@ -6545,8 +6479,8 @@
}
case FieldDescriptor::TYPE_GROUP: {
- parent_unknown_fields->AddGroup((*iter)->number())
- ->MergeFrom(*unknown_fields);
+ parent_unknown_fields->AddGroup((*iter)->number())
+ ->MergeFrom(*unknown_fields);
break;
}
@@ -6669,11 +6603,12 @@
void DescriptorBuilder::OptionInterpreter::AddWithoutInterpreting(
const UninterpretedOption& uninterpreted_option, Message* options) {
const FieldDescriptor* field =
- options->GetDescriptor()->FindFieldByName("uninterpreted_option");
+ options->GetDescriptor()->FindFieldByName("uninterpreted_option");
GOOGLE_CHECK(field != NULL);
- options->GetReflection()->AddMessage(options, field)
- ->CopyFrom(uninterpreted_option);
+ options->GetReflection()
+ ->AddMessage(options, field)
+ ->CopyFrom(uninterpreted_option);
}
bool DescriptorBuilder::OptionInterpreter::ExamineIfOptionIsSet(
@@ -6710,8 +6645,8 @@
if (intermediate_unknown_fields.ParseFromString(
unknown_field->length_delimited()) &&
!ExamineIfOptionIsSet(intermediate_fields_iter + 1,
- intermediate_fields_end,
- innermost_field, debug_msg_name,
+ intermediate_fields_end, innermost_field,
+ debug_msg_name,
intermediate_unknown_fields)) {
return false; // Error already added.
}
@@ -6721,9 +6656,8 @@
case FieldDescriptor::TYPE_GROUP:
if (unknown_field->type() == UnknownField::TYPE_GROUP) {
if (!ExamineIfOptionIsSet(intermediate_fields_iter + 1,
- intermediate_fields_end,
- innermost_field, debug_msg_name,
- unknown_field->group())) {
+ intermediate_fields_end, innermost_field,
+ debug_msg_name, unknown_field->group())) {
return false; // Error already added.
}
}
@@ -6739,11 +6673,9 @@
}
bool DescriptorBuilder::OptionInterpreter::SetOptionValue(
- const FieldDescriptor* option_field,
- UnknownFieldSet* unknown_fields) {
+ const FieldDescriptor* option_field, UnknownFieldSet* unknown_fields) {
// We switch on the CppType to validate.
switch (option_field->cpp_type()) {
-
case FieldDescriptor::CPPTYPE_INT32:
if (uninterpreted_option_->has_positive_int_value()) {
if (uninterpreted_option_->positive_int_value() >
@@ -6803,8 +6735,10 @@
option_field->type(), unknown_fields);
}
} else {
- return AddValueError("Value must be non-negative integer for uint32 "
- "option \"" + option_field->full_name() + "\".");
+ return AddValueError(
+ "Value must be non-negative integer for uint32 "
+ "option \"" +
+ option_field->full_name() + "\".");
}
break;
@@ -6814,8 +6748,10 @@
uninterpreted_option_->positive_int_value(),
option_field->type(), unknown_fields);
} else {
- return AddValueError("Value must be non-negative integer for uint64 "
- "option \"" + option_field->full_name() + "\".");
+ return AddValueError(
+ "Value must be non-negative integer for uint64 "
+ "option \"" +
+ option_field->full_name() + "\".");
}
break;
@@ -6856,24 +6792,30 @@
case FieldDescriptor::CPPTYPE_BOOL:
uint64 value;
if (!uninterpreted_option_->has_identifier_value()) {
- return AddValueError("Value must be identifier for boolean option "
- "\"" + option_field->full_name() + "\".");
+ return AddValueError(
+ "Value must be identifier for boolean option "
+ "\"" +
+ option_field->full_name() + "\".");
}
if (uninterpreted_option_->identifier_value() == "true") {
value = 1;
} else if (uninterpreted_option_->identifier_value() == "false") {
value = 0;
} else {
- return AddValueError("Value must be \"true\" or \"false\" for boolean "
- "option \"" + option_field->full_name() + "\".");
+ return AddValueError(
+ "Value must be \"true\" or \"false\" for boolean "
+ "option \"" +
+ option_field->full_name() + "\".");
}
unknown_fields->AddVarint(option_field->number(), value);
break;
case FieldDescriptor::CPPTYPE_ENUM: {
if (!uninterpreted_option_->has_identifier_value()) {
- return AddValueError("Value must be identifier for enum-valued option "
- "\"" + option_field->full_name() + "\".");
+ return AddValueError(
+ "Value must be identifier for enum-valued option "
+ "\"" +
+ option_field->full_name() + "\".");
}
const EnumDescriptor* enum_type = option_field->enum_type();
const std::string& value_name = uninterpreted_option_->identifier_value();
@@ -6892,10 +6834,11 @@
// DescriptorPool::FindEnumValueByName() because we're already holding
// the pool's mutex, and the latter method locks it again.
Symbol symbol =
- builder_->FindSymbolNotEnforcingDeps(fully_qualified_name);
+ builder_->FindSymbolNotEnforcingDeps(fully_qualified_name);
if (!symbol.IsNull() && symbol.type == Symbol::ENUM_VALUE) {
if (symbol.enum_value_descriptor->type() != enum_type) {
- return AddValueError("Enum type \"" + enum_type->full_name() +
+ return AddValueError(
+ "Enum type \"" + enum_type->full_name() +
"\" has no value named \"" + value_name + "\" for option \"" +
option_field->full_name() +
"\". This appears to be a value from a sibling type.");
@@ -6912,13 +6855,16 @@
if (enum_value == NULL) {
return AddValueError("Enum type \"" +
option_field->enum_type()->full_name() +
- "\" has no value named \"" + value_name + "\" for "
- "option \"" + option_field->full_name() + "\".");
+ "\" has no value named \"" + value_name +
+ "\" for "
+ "option \"" +
+ option_field->full_name() + "\".");
} else {
// Sign-extension is not a problem, since we cast directly from int32 to
// uint64, without first going through uint32.
- unknown_fields->AddVarint(option_field->number(),
- static_cast<uint64>(static_cast<int64>(enum_value->number())));
+ unknown_fields->AddVarint(
+ option_field->number(),
+ static_cast<uint64>(static_cast<int64>(enum_value->number())));
}
break;
}
@@ -6932,7 +6878,7 @@
}
// The string has already been unquoted and unescaped by the parser.
unknown_fields->AddLengthDelimited(option_field->number(),
- uninterpreted_option_->string_value());
+ uninterpreted_option_->string_value());
break;
case FieldDescriptor::CPPTYPE_MESSAGE:
@@ -6954,8 +6900,8 @@
const std::string& name) const override {
assert_mutex_held(builder_->pool_);
const Descriptor* descriptor = message->GetDescriptor();
- Symbol result = builder_->LookupSymbolNoPlaceholder(
- name, descriptor->full_name());
+ Symbol result =
+ builder_->LookupSymbolNoPlaceholder(name, descriptor->full_name());
if (result.type == Symbol::FIELD &&
result.field_descriptor->is_extension()) {
return result.field_descriptor;
@@ -7007,16 +6953,16 @@
// option_field, parse the supplied text-format string into this
// message, and serialize the resulting message to produce the value.
bool DescriptorBuilder::OptionInterpreter::SetAggregateOption(
- const FieldDescriptor* option_field,
- UnknownFieldSet* unknown_fields) {
+ const FieldDescriptor* option_field, UnknownFieldSet* unknown_fields) {
if (!uninterpreted_option_->has_aggregate_value()) {
return AddValueError("Option \"" + option_field->full_name() +
"\" is a message. To set the entire message, use "
- "syntax like \"" + option_field->name() +
+ "syntax like \"" +
+ option_field->name() +
" = { <proto text format> }\". "
"To set fields within it, use "
- "syntax like \"" + option_field->name() +
- ".foo = value\".");
+ "syntax like \"" +
+ option_field->name() + ".foo = value\".");
}
const Descriptor* type = option_field->message_type();
@@ -7041,7 +6987,7 @@
if (option_field->type() == FieldDescriptor::TYPE_MESSAGE) {
unknown_fields->AddLengthDelimited(option_field->number(), serial);
} else {
- GOOGLE_CHECK_EQ(option_field->type(), FieldDescriptor::TYPE_GROUP);
+ GOOGLE_CHECK_EQ(option_field->type(), FieldDescriptor::TYPE_GROUP);
UnknownFieldSet* group = unknown_fields->AddGroup(option_field->number());
group->ParseFromString(serial);
}
@@ -7049,12 +6995,13 @@
}
}
-void DescriptorBuilder::OptionInterpreter::SetInt32(int number, int32 value,
- FieldDescriptor::Type type, UnknownFieldSet* unknown_fields) {
+void DescriptorBuilder::OptionInterpreter::SetInt32(
+ int number, int32 value, FieldDescriptor::Type type,
+ UnknownFieldSet* unknown_fields) {
switch (type) {
case FieldDescriptor::TYPE_INT32:
unknown_fields->AddVarint(number,
- static_cast<uint64>(static_cast<int64>(value)));
+ static_cast<uint64>(static_cast<int64>(value)));
break;
case FieldDescriptor::TYPE_SFIXED32:
@@ -7072,8 +7019,9 @@
}
}
-void DescriptorBuilder::OptionInterpreter::SetInt64(int number, int64 value,
- FieldDescriptor::Type type, UnknownFieldSet* unknown_fields) {
+void DescriptorBuilder::OptionInterpreter::SetInt64(
+ int number, int64 value, FieldDescriptor::Type type,
+ UnknownFieldSet* unknown_fields) {
switch (type) {
case FieldDescriptor::TYPE_INT64:
unknown_fields->AddVarint(number, static_cast<uint64>(value));
@@ -7094,8 +7042,9 @@
}
}
-void DescriptorBuilder::OptionInterpreter::SetUInt32(int number, uint32 value,
- FieldDescriptor::Type type, UnknownFieldSet* unknown_fields) {
+void DescriptorBuilder::OptionInterpreter::SetUInt32(
+ int number, uint32 value, FieldDescriptor::Type type,
+ UnknownFieldSet* unknown_fields) {
switch (type) {
case FieldDescriptor::TYPE_UINT32:
unknown_fields->AddVarint(number, static_cast<uint64>(value));
@@ -7111,8 +7060,9 @@
}
}
-void DescriptorBuilder::OptionInterpreter::SetUInt64(int number, uint64 value,
- FieldDescriptor::Type type, UnknownFieldSet* unknown_fields) {
+void DescriptorBuilder::OptionInterpreter::SetUInt64(
+ int number, uint64 value, FieldDescriptor::Type type,
+ UnknownFieldSet* unknown_fields) {
switch (type) {
case FieldDescriptor::TYPE_UINT64:
unknown_fields->AddVarint(number, value);
@@ -7142,15 +7092,15 @@
annotation_extensions.insert("google.protobuf.ServiceOptions");
annotation_extensions.insert("google.protobuf.MethodOptions");
annotation_extensions.insert("google.protobuf.StreamOptions");
- for (std::set<const FileDescriptor*>::const_iterator
- it = unused_dependency_.begin();
+ for (std::set<const FileDescriptor*>::const_iterator it =
+ unused_dependency_.begin();
it != unused_dependency_.end(); ++it) {
// Do not log warnings for proto files which extend annotations.
int i;
- for (i = 0 ; i < (*it)->extension_count(); ++i) {
+ for (i = 0; i < (*it)->extension_count(); ++i) {
if (annotation_extensions.find(
- (*it)->extension(i)->containing_type()->full_name())
- != annotation_extensions.end()) {
+ (*it)->extension(i)->containing_type()->full_name()) !=
+ annotation_extensions.end()) {
break;
}
}
@@ -7158,7 +7108,7 @@
if (i == (*it)->extension_count()) {
std::string error_message =
"Import " + (*it)->name() + " but not used.";
- AddWarning((*it)->name(), proto, DescriptorPool::ErrorCollector::OTHER,
+ AddWarning((*it)->name(), proto, DescriptorPool::ErrorCollector::IMPORT,
error_message);
}
}
diff --git a/src/google/protobuf/descriptor.h b/src/google/protobuf/descriptor.h
index add275c..424bd84 100644
--- a/src/google/protobuf/descriptor.h
+++ b/src/google/protobuf/descriptor.h
@@ -174,7 +174,8 @@
DebugStringOptions()
: include_comments(false),
elide_group_body(false),
- elide_oneof_body(false) {}
+ elide_oneof_body(false) {
+ }
};
// A class to handle the simplest cases of a lazily linked descriptor
@@ -523,62 +524,62 @@
// Identifies a field type. 0 is reserved for errors. The order is weird
// for historical reasons. Types 12 and up are new in proto2.
enum Type {
- TYPE_DOUBLE = 1, // double, exactly eight bytes on the wire.
- TYPE_FLOAT = 2, // float, exactly four bytes on the wire.
- TYPE_INT64 = 3, // int64, varint on the wire. Negative numbers
- // take 10 bytes. Use TYPE_SINT64 if negative
- // values are likely.
- TYPE_UINT64 = 4, // uint64, varint on the wire.
- TYPE_INT32 = 5, // int32, varint on the wire. Negative numbers
- // take 10 bytes. Use TYPE_SINT32 if negative
- // values are likely.
- TYPE_FIXED64 = 6, // uint64, exactly eight bytes on the wire.
- TYPE_FIXED32 = 7, // uint32, exactly four bytes on the wire.
- TYPE_BOOL = 8, // bool, varint on the wire.
- TYPE_STRING = 9, // UTF-8 text.
- TYPE_GROUP = 10, // Tag-delimited message. Deprecated.
- TYPE_MESSAGE = 11, // Length-delimited message.
+ TYPE_DOUBLE = 1, // double, exactly eight bytes on the wire.
+ TYPE_FLOAT = 2, // float, exactly four bytes on the wire.
+ TYPE_INT64 = 3, // int64, varint on the wire. Negative numbers
+ // take 10 bytes. Use TYPE_SINT64 if negative
+ // values are likely.
+ TYPE_UINT64 = 4, // uint64, varint on the wire.
+ TYPE_INT32 = 5, // int32, varint on the wire. Negative numbers
+ // take 10 bytes. Use TYPE_SINT32 if negative
+ // values are likely.
+ TYPE_FIXED64 = 6, // uint64, exactly eight bytes on the wire.
+ TYPE_FIXED32 = 7, // uint32, exactly four bytes on the wire.
+ TYPE_BOOL = 8, // bool, varint on the wire.
+ TYPE_STRING = 9, // UTF-8 text.
+ TYPE_GROUP = 10, // Tag-delimited message. Deprecated.
+ TYPE_MESSAGE = 11, // Length-delimited message.
- TYPE_BYTES = 12, // Arbitrary byte array.
- TYPE_UINT32 = 13, // uint32, varint on the wire
- TYPE_ENUM = 14, // Enum, varint on the wire
- TYPE_SFIXED32 = 15, // int32, exactly four bytes on the wire
- TYPE_SFIXED64 = 16, // int64, exactly eight bytes on the wire
- TYPE_SINT32 = 17, // int32, ZigZag-encoded varint on the wire
- TYPE_SINT64 = 18, // int64, ZigZag-encoded varint on the wire
+ TYPE_BYTES = 12, // Arbitrary byte array.
+ TYPE_UINT32 = 13, // uint32, varint on the wire
+ TYPE_ENUM = 14, // Enum, varint on the wire
+ TYPE_SFIXED32 = 15, // int32, exactly four bytes on the wire
+ TYPE_SFIXED64 = 16, // int64, exactly eight bytes on the wire
+ TYPE_SINT32 = 17, // int32, ZigZag-encoded varint on the wire
+ TYPE_SINT64 = 18, // int64, ZigZag-encoded varint on the wire
- MAX_TYPE = 18, // Constant useful for defining lookup tables
- // indexed by Type.
+ MAX_TYPE = 18, // Constant useful for defining lookup tables
+ // indexed by Type.
};
// Specifies the C++ data type used to represent the field. There is a
// fixed mapping from Type to CppType where each Type maps to exactly one
// CppType. 0 is reserved for errors.
enum CppType {
- CPPTYPE_INT32 = 1, // TYPE_INT32, TYPE_SINT32, TYPE_SFIXED32
- CPPTYPE_INT64 = 2, // TYPE_INT64, TYPE_SINT64, TYPE_SFIXED64
- CPPTYPE_UINT32 = 3, // TYPE_UINT32, TYPE_FIXED32
- CPPTYPE_UINT64 = 4, // TYPE_UINT64, TYPE_FIXED64
- CPPTYPE_DOUBLE = 5, // TYPE_DOUBLE
- CPPTYPE_FLOAT = 6, // TYPE_FLOAT
- CPPTYPE_BOOL = 7, // TYPE_BOOL
- CPPTYPE_ENUM = 8, // TYPE_ENUM
- CPPTYPE_STRING = 9, // TYPE_STRING, TYPE_BYTES
- CPPTYPE_MESSAGE = 10, // TYPE_MESSAGE, TYPE_GROUP
+ CPPTYPE_INT32 = 1, // TYPE_INT32, TYPE_SINT32, TYPE_SFIXED32
+ CPPTYPE_INT64 = 2, // TYPE_INT64, TYPE_SINT64, TYPE_SFIXED64
+ CPPTYPE_UINT32 = 3, // TYPE_UINT32, TYPE_FIXED32
+ CPPTYPE_UINT64 = 4, // TYPE_UINT64, TYPE_FIXED64
+ CPPTYPE_DOUBLE = 5, // TYPE_DOUBLE
+ CPPTYPE_FLOAT = 6, // TYPE_FLOAT
+ CPPTYPE_BOOL = 7, // TYPE_BOOL
+ CPPTYPE_ENUM = 8, // TYPE_ENUM
+ CPPTYPE_STRING = 9, // TYPE_STRING, TYPE_BYTES
+ CPPTYPE_MESSAGE = 10, // TYPE_MESSAGE, TYPE_GROUP
- MAX_CPPTYPE = 10, // Constant useful for defining lookup tables
- // indexed by CppType.
+ MAX_CPPTYPE = 10, // Constant useful for defining lookup tables
+ // indexed by CppType.
};
// Identifies whether the field is optional, required, or repeated. 0 is
// reserved for errors.
enum Label {
- LABEL_OPTIONAL = 1, // optional
- LABEL_REQUIRED = 2, // required
- LABEL_REPEATED = 3, // repeated
+ LABEL_OPTIONAL = 1, // optional
+ LABEL_REQUIRED = 2, // required
+ LABEL_REPEATED = 3, // repeated
- MAX_LABEL = 3, // Constant useful for defining lookup tables
- // indexed by Label.
+ MAX_LABEL = 3, // Constant useful for defining lookup tables
+ // indexed by Label.
};
// Valid field numbers are positive integers up to kMaxNumber.
@@ -589,14 +590,14 @@
static const int kFirstReservedNumber = 19000;
// Last field number reserved for the protocol buffer library implementation.
// Users may not declare fields that use reserved numbers.
- static const int kLastReservedNumber = 19999;
+ static const int kLastReservedNumber = 19999;
const std::string& name() const; // Name of this field within the message.
const std::string& full_name() const; // Fully-qualified name of the field.
const std::string& json_name() const; // JSON name of this field.
- const FileDescriptor* file() const;// File in which this field was defined.
- bool is_extension() const; // Is this an extension field?
- int number() const; // Declared tag number.
+ const FileDescriptor* file() const; // File in which this field was defined.
+ bool is_extension() const; // Is this an extension field?
+ int number() const; // Declared tag number.
// Same as name() except converted to lower-case. This (and especially the
// FindFieldByLowercaseName() method) can be useful when parsing formats
@@ -623,15 +624,15 @@
const char* cpp_type_name() const; // Name of the C++ type.
Label label() const; // optional/required/repeated
- bool is_required() const; // shorthand for label() == LABEL_REQUIRED
- bool is_optional() const; // shorthand for label() == LABEL_OPTIONAL
- bool is_repeated() const; // shorthand for label() == LABEL_REPEATED
- bool is_packable() const; // shorthand for is_repeated() &&
- // IsTypePackable(type())
- bool is_packed() const; // shorthand for is_packable() &&
- // options().packed()
- bool is_map() const; // shorthand for type() == TYPE_MESSAGE &&
- // message_type()->options().map_entry()
+ bool is_required() const; // shorthand for label() == LABEL_REQUIRED
+ bool is_optional() const; // shorthand for label() == LABEL_OPTIONAL
+ bool is_repeated() const; // shorthand for label() == LABEL_REPEATED
+ bool is_packable() const; // shorthand for is_repeated() &&
+ // IsTypePackable(type())
+ bool is_packed() const; // shorthand for is_packable() &&
+ // options().packed()
+ bool is_map() const; // shorthand for type() == TYPE_MESSAGE &&
+ // message_type()->options().map_entry()
// Index of this field within the message's field array, or the file or
// extension scope's extensions array.
@@ -798,13 +799,13 @@
// descriptor.cc and update them to initialize the field.
union {
- int32 default_value_int32_;
- int64 default_value_int64_;
+ int32 default_value_int32_;
+ int64 default_value_int64_;
uint32 default_value_uint32_;
uint64 default_value_uint64_;
- float default_value_float_;
+ float default_value_float_;
double default_value_double_;
- bool default_value_bool_;
+ bool default_value_bool_;
mutable const EnumValueDescriptor* default_value_enum_;
const std::string* default_value_string_;
@@ -812,11 +813,11 @@
static const CppType kTypeToCppTypeMap[MAX_TYPE + 1];
- static const char * const kTypeToName[MAX_TYPE + 1];
+ static const char* const kTypeToName[MAX_TYPE + 1];
- static const char * const kCppTypeToName[MAX_CPPTYPE + 1];
+ static const char* const kCppTypeToName[MAX_CPPTYPE + 1];
- static const char * const kLabelToName[MAX_LABEL + 1];
+ static const char* const kLabelToName[MAX_LABEL + 1];
// Must be constructed using DescriptorPool.
FieldDescriptor() {}
@@ -977,8 +978,8 @@
bool IsReservedNumber(int number) const;
// Returns NULL if no reserved range contains the given number.
- const EnumDescriptor::ReservedRange*
- FindReservedRangeContainingNumber(int number) const;
+ const EnumDescriptor::ReservedRange* FindReservedRangeContainingNumber(
+ int number) const;
// The number of reserved field names in this message type.
int reserved_name_count() const;
@@ -1011,9 +1012,8 @@
// This is private but is used by GeneratedMessageReflection (which is
// friended below) to return a valid EnumValueDescriptor from GetEnum() when
// this feature is enabled.
- const EnumValueDescriptor*
- FindValueByNumberCreatingIfUnknown(int number) const;
-
+ const EnumValueDescriptor* FindValueByNumberCreatingIfUnknown(
+ int number) const;
// See Descriptor::DebugString().
void DebugString(int depth, std::string* contents,
@@ -1068,8 +1068,8 @@
typedef EnumValueDescriptorProto Proto;
const std::string& name() const; // Name of this enum constant.
- int index() const; // Index within the enums's Descriptor.
- int number() const; // Numeric value of this enum constant.
+ int index() const; // Index within the enums's Descriptor.
+ int number() const; // Numeric value of this enum constant.
// The full_name of an enum value is a sibling symbol of the enum type.
// e.g. the full name of FieldDescriptorProto::TYPE_INT32 is actually
@@ -1381,8 +1381,8 @@
// Syntax of this file.
enum Syntax {
SYNTAX_UNKNOWN = 0,
- SYNTAX_PROTO2 = 2,
- SYNTAX_PROTO3 = 3,
+ SYNTAX_PROTO2 = 2,
+ SYNTAX_PROTO3 = 3,
};
Syntax syntax() const;
static const char* SyntaxName(Syntax syntax);
@@ -1618,16 +1618,17 @@
// This is useful e.g. for mapping the error back to an exact location
// in a .proto file.
enum ErrorLocation {
- NAME, // the symbol name, or the package name for files
- NUMBER, // field or extension range number
- TYPE, // field type
- EXTENDEE, // field extendee
- DEFAULT_VALUE, // field default value
- INPUT_TYPE, // method input type
- OUTPUT_TYPE, // method output type
- OPTION_NAME, // name in assignment
- OPTION_VALUE, // value in option assignment
- OTHER // some other problem
+ NAME, // the symbol name, or the package name for files
+ NUMBER, // field or extension range number
+ TYPE, // field type
+ EXTENDEE, // field extendee
+ DEFAULT_VALUE, // field default value
+ INPUT_TYPE, // method input type
+ OUTPUT_TYPE, // method output type
+ OPTION_NAME, // name in assignment
+ OPTION_VALUE, // value in option assignment
+ IMPORT, // import error
+ OTHER // some other problem
};
// Reports an error in the FileDescriptorProto. Use this function if the
@@ -1665,8 +1666,7 @@
// Same as BuildFile() except errors are sent to the given ErrorCollector.
const FileDescriptor* BuildFileCollectingErrors(
- const FileDescriptorProto& proto,
- ErrorCollector* error_collector);
+ const FileDescriptorProto& proto, ErrorCollector* error_collector);
// By default, it is an error if a FileDescriptorProto contains references
// to types or other files that are not found in the DescriptorPool (or its
@@ -1721,8 +1721,8 @@
// Called by generated classes at init time to add their descriptors to
// generated_pool. Do NOT call this in your own code! filename must be a
// permanent string (e.g. a string literal).
- static void InternalAddGeneratedFile(
- const void* encoded_file_descriptor, int size);
+ static void InternalAddGeneratedFile(const void* encoded_file_descriptor,
+ int size);
// Disallow [enforce_utf8 = false] in .proto files.
void DisallowEnforceUtf8() { disallow_enforce_utf8_ = true; }
@@ -1799,7 +1799,7 @@
// fallback_database_. Declared const because it is called by (semantically)
// const methods.
const FileDescriptor* BuildFileFromDatabase(
- const FileDescriptorProto& proto) const;
+ const FileDescriptorProto& proto) const;
// Helper for when lazily_build_dependencies_ is set, can look up a symbol
// after the file's descriptor is built, and can build the file where that
@@ -1886,8 +1886,7 @@
PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_count, int)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension_range,
const Descriptor::ExtensionRange*)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension,
- const FieldDescriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension, const FieldDescriptor*)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_range_count, int)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, reserved_range,
@@ -1914,13 +1913,13 @@
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FieldDescriptor, FieldOptions)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_default_value, bool)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_json_name, bool)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int32 , int32 )
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int64 , int64 )
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int32, int32)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int64, int64)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint32, uint32)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint64, uint64)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_float , float )
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_float, float)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_double, double)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_bool , bool )
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_bool, bool)
PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, default_value_string)
PROTOBUF_DEFINE_STRING_ACCESSOR(OneofDescriptor, name)
@@ -2151,14 +2150,11 @@
return dependency(public_dependencies_[index]);
}
-inline const FileDescriptor* FileDescriptor::weak_dependency(
- int index) const {
+inline const FileDescriptor* FileDescriptor::weak_dependency(int index) const {
return dependency(weak_dependencies_[index]);
}
-inline FileDescriptor::Syntax FileDescriptor::syntax() const {
- return syntax_;
-}
+inline FileDescriptor::Syntax FileDescriptor::syntax() const { return syntax_; }
// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because fields_ is actually an array
// of pointers rather than the usual array of objects.
diff --git a/src/google/protobuf/descriptor.pb.cc b/src/google/protobuf/descriptor.pb.cc
index 06d6ea0..f85087e 100644
--- a/src/google/protobuf/descriptor.pb.cc
+++ b/src/google/protobuf/descriptor.pb.cc
@@ -564,36 +564,6 @@
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsGeneratedCodeInfo_google_2fprotobuf_2fdescriptor_2eproto}, {
&scc_info_GeneratedCodeInfo_Annotation_google_2fprotobuf_2fdescriptor_2eproto.base,}};
-void InitDefaults_google_2fprotobuf_2fdescriptor_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FileDescriptorSet_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FileDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DescriptorProto_ExtensionRange_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DescriptorProto_ReservedRange_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ExtensionRangeOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_OneofDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumDescriptorProto_EnumReservedRange_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumValueDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ServiceDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MethodDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FileOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MessageOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_OneofOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumValueOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ServiceOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MethodOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UninterpretedOption_NamePart_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UninterpretedOption_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SourceCodeInfo_Location_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SourceCodeInfo_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GeneratedCodeInfo_Annotation_google_2fprotobuf_2fdescriptor_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GeneratedCodeInfo_google_2fprotobuf_2fdescriptor_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[27];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2fdescriptor_2eproto[6];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fdescriptor_2eproto = nullptr;
@@ -1203,8 +1173,7 @@
"le.Protobuf.Reflection"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fdescriptor_2eproto = {
- false, InitDefaults_google_2fprotobuf_2fdescriptor_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2fdescriptor_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2fdescriptor_2eproto,
"google/protobuf/descriptor.proto", &assign_descriptors_table_google_2fprotobuf_2fdescriptor_2eproto, 6022,
};
@@ -1212,6 +1181,33 @@
static constexpr ::PROTOBUF_NAMESPACE_ID::internal::InitFunc deps[1] =
{
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FileDescriptorSet_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FileDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DescriptorProto_ExtensionRange_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DescriptorProto_ReservedRange_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ExtensionRangeOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_OneofDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumDescriptorProto_EnumReservedRange_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumValueDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ServiceDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MethodDescriptorProto_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FileOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MessageOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_OneofOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumValueOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ServiceOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MethodOptions_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UninterpretedOption_NamePart_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UninterpretedOption_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SourceCodeInfo_Location_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SourceCodeInfo_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GeneratedCodeInfo_Annotation_google_2fprotobuf_2fdescriptor_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GeneratedCodeInfo_google_2fprotobuf_2fdescriptor_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto, deps, 0);
}
@@ -1393,6 +1389,7 @@
}
class FileDescriptorSet::HasBitSetters {
public:
+ using HasBits = decltype(std::declval<FileDescriptorSet>()._has_bits_);
};
#if !defined(_MSC_VER) || _MSC_VER >= 1900
@@ -1463,35 +1460,43 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* FileDescriptorSet::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// repeated .google.protobuf.FileDescriptorProto file = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_file(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 10 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 10) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool FileDescriptorSet::MergePartialFromCodedStream(
@@ -1695,22 +1700,23 @@
}
class FileDescriptorProto::HasBitSetters {
public:
- static void set_has_name(FileDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<FileDescriptorProto>()._has_bits_);
+ static void set_has_name(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_package(FileDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_package(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
static const PROTOBUF_NAMESPACE_ID::FileOptions& options(const FileDescriptorProto* msg);
- static void set_has_options(FileDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000008u;
+ static void set_has_options(HasBits* has_bits) {
+ (*has_bits)[0] |= 8u;
}
static const PROTOBUF_NAMESPACE_ID::SourceCodeInfo& source_code_info(const FileDescriptorProto* msg);
- static void set_has_source_code_info(FileDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000010u;
+ static void set_has_source_code_info(HasBits* has_bits) {
+ (*has_bits)[0] |= 16u;
}
- static void set_has_syntax(FileDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_syntax(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
};
@@ -1901,138 +1907,160 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* FileDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name(), ptr, ctx, "google.protobuf.FileDescriptorProto.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string package = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_package(), ptr, ctx, "google.protobuf.FileDescriptorProto.package");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated string dependency = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
- do {
+ while (true) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(add_dependency(), ptr, ctx, "google.protobuf.FileDescriptorProto.dependency");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 26 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 26) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.DescriptorProto message_type = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_message_type(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 34 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 34) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 42) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_enum_type(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 42 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 42) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.ServiceDescriptorProto service = 6;
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 50) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_service(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 50 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 50) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.FieldDescriptorProto extension = 7;
case 7: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_extension(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 58 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 58) break;
+ ptr += 1;
+ }
break;
}
// optional .google.protobuf.FileOptions options = 8;
case 8: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 66) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional .google.protobuf.SourceCodeInfo source_code_info = 9;
case 9: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 74) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_source_code_info(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated int32 public_dependency = 10;
case 10: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80) {
- do {
+ while (true) {
add_public_dependency(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 80 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 80) break;
+ ptr += 1;
+ }
break;
} else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 82) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(mutable_public_dependency(), ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated int32 weak_dependency = 11;
case 11: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88) {
- do {
+ while (true) {
add_weak_dependency(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 88 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 88) break;
+ ptr += 1;
+ }
break;
} else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 90) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(mutable_weak_dependency(), ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string syntax = 12;
case 12: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 98) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_syntax(), ptr, ctx, "google.protobuf.FileDescriptorProto.syntax");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool FileDescriptorProto::MergePartialFromCodedStream(
@@ -2705,15 +2733,16 @@
}
class DescriptorProto_ExtensionRange::HasBitSetters {
public:
- static void set_has_start(DescriptorProto_ExtensionRange* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ using HasBits = decltype(std::declval<DescriptorProto_ExtensionRange>()._has_bits_);
+ static void set_has_start(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
- static void set_has_end(DescriptorProto_ExtensionRange* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_end(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
static const PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& options(const DescriptorProto_ExtensionRange* msg);
- static void set_has_options(DescriptorProto_ExtensionRange* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ static void set_has_options(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
};
@@ -2823,46 +2852,56 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* DescriptorProto_ExtensionRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional int32 start = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_start(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_start(&has_bits);
+ start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional int32 end = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_end(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_end(&has_bits);
+ end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional .google.protobuf.ExtensionRangeOptions options = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool DescriptorProto_ExtensionRange::MergePartialFromCodedStream(
@@ -2878,7 +2917,7 @@
// optional int32 start = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
- HasBitSetters::set_has_start(this);
+ HasBitSetters::set_has_start(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &start_)));
@@ -2891,7 +2930,7 @@
// optional int32 end = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
- HasBitSetters::set_has_end(this);
+ HasBitSetters::set_has_end(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &end_)));
@@ -3135,11 +3174,12 @@
}
class DescriptorProto_ReservedRange::HasBitSetters {
public:
- static void set_has_start(DescriptorProto_ReservedRange* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<DescriptorProto_ReservedRange>()._has_bits_);
+ static void set_has_start(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_end(DescriptorProto_ReservedRange* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_end(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -3219,39 +3259,49 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* DescriptorProto_ReservedRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional int32 start = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_start(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_start(&has_bits);
+ start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional int32 end = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_end(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_end(&has_bits);
+ end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool DescriptorProto_ReservedRange::MergePartialFromCodedStream(
@@ -3267,7 +3317,7 @@
// optional int32 start = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
- HasBitSetters::set_has_start(this);
+ HasBitSetters::set_has_start(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &start_)));
@@ -3280,7 +3330,7 @@
// optional int32 end = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
- HasBitSetters::set_has_end(this);
+ HasBitSetters::set_has_end(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &end_)));
@@ -3488,12 +3538,13 @@
}
class DescriptorProto::HasBitSetters {
public:
- static void set_has_name(DescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<DescriptorProto>()._has_bits_);
+ static void set_has_name(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
static const PROTOBUF_NAMESPACE_ID::MessageOptions& options(const DescriptorProto* msg);
- static void set_has_options(DescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_options(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -3636,119 +3687,143 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* DescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name(), ptr, ctx, "google.protobuf.DescriptorProto.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.FieldDescriptorProto field = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_field(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 18 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 18) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.DescriptorProto nested_type = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_nested_type(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 26 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 26) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_enum_type(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 34 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 34) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 42) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_extension_range(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 42 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 42) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.FieldDescriptorProto extension = 6;
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 50) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_extension(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 50 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 50) break;
+ ptr += 1;
+ }
break;
}
// optional .google.protobuf.MessageOptions options = 7;
case 7: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
case 8: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 66) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_oneof_decl(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 66 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 66) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
case 9: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 74) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_reserved_range(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 74 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 74) break;
+ ptr += 1;
+ }
break;
}
// repeated string reserved_name = 10;
case 10: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 82) goto handle_unusual;
- do {
+ while (true) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(add_reserved_name(), ptr, ctx, "google.protobuf.DescriptorProto.reserved_name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 82 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 82) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool DescriptorProto::MergePartialFromCodedStream(
@@ -4339,6 +4414,7 @@
}
class ExtensionRangeOptions::HasBitSetters {
public:
+ using HasBits = decltype(std::declval<ExtensionRangeOptions>()._has_bits_);
};
#if !defined(_MSC_VER) || _MSC_VER >= 1900
@@ -4412,41 +4488,49 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* ExtensionRangeOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
case 999: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_uninterpreted_option(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 65535) == 16058 && (ptr += 2));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint16>(ptr) != 16058) break;
+ ptr += 2;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
if ((8000u <= tag)) {
ptr = _extensions_.ParseField(tag, ptr,
internal_default_instance(), &_internal_metadata_, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool ExtensionRangeOptions::MergePartialFromCodedStream(
@@ -4669,36 +4753,37 @@
}
class FieldDescriptorProto::HasBitSetters {
public:
- static void set_has_name(FieldDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<FieldDescriptorProto>()._has_bits_);
+ static void set_has_name(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_number(FieldDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000040u;
+ static void set_has_number(HasBits* has_bits) {
+ (*has_bits)[0] |= 64u;
}
- static void set_has_label(FieldDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000100u;
+ static void set_has_label(HasBits* has_bits) {
+ (*has_bits)[0] |= 256u;
}
- static void set_has_type(FieldDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000200u;
+ static void set_has_type(HasBits* has_bits) {
+ (*has_bits)[0] |= 512u;
}
- static void set_has_type_name(FieldDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_type_name(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
- static void set_has_extendee(FieldDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_extendee(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
- static void set_has_default_value(FieldDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000008u;
+ static void set_has_default_value(HasBits* has_bits) {
+ (*has_bits)[0] |= 8u;
}
- static void set_has_oneof_index(FieldDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000080u;
+ static void set_has_oneof_index(HasBits* has_bits) {
+ (*has_bits)[0] |= 128u;
}
- static void set_has_json_name(FieldDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000010u;
+ static void set_has_json_name(HasBits* has_bits) {
+ (*has_bits)[0] |= 16u;
}
static const PROTOBUF_NAMESPACE_ID::FieldOptions& options(const FieldDescriptorProto* msg);
- static void set_has_options(FieldDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000020u;
+ static void set_has_options(HasBits* has_bits) {
+ (*has_bits)[0] |= 32u;
}
};
@@ -4873,38 +4958,41 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* FieldDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name(), ptr, ctx, "google.protobuf.FieldDescriptorProto.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string extendee = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_extendee(), ptr, ctx, "google.protobuf.FieldDescriptorProto.extendee");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional int32 number = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 24) goto handle_unusual;
- set_number(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_number(&has_bits);
+ number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional .google.protobuf.FieldDescriptorProto.Label label = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 32) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
if (!PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label_IsValid(val)) {
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
break;
@@ -4916,7 +5004,7 @@
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 40) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
if (!PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type_IsValid(val)) {
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
break;
@@ -4928,50 +5016,57 @@
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 50) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_type_name(), ptr, ctx, "google.protobuf.FieldDescriptorProto.type_name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string default_value = 7;
case 7: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_default_value(), ptr, ctx, "google.protobuf.FieldDescriptorProto.default_value");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional .google.protobuf.FieldOptions options = 8;
case 8: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 66) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional int32 oneof_index = 9;
case 9: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 72) goto handle_unusual;
- set_oneof_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_oneof_index(&has_bits);
+ oneof_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional string json_name = 10;
case 10: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 82) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_json_name(), ptr, ctx, "google.protobuf.FieldDescriptorProto.json_name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool FieldDescriptorProto::MergePartialFromCodedStream(
@@ -5017,7 +5112,7 @@
// optional int32 number = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
- HasBitSetters::set_has_number(this);
+ HasBitSetters::set_has_number(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &number_)));
@@ -5109,7 +5204,7 @@
// optional int32 oneof_index = 9;
case 9: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (72 & 0xFF)) {
- HasBitSetters::set_has_oneof_index(this);
+ HasBitSetters::set_has_oneof_index(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &oneof_index_)));
@@ -5573,12 +5668,13 @@
}
class OneofDescriptorProto::HasBitSetters {
public:
- static void set_has_name(OneofDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<OneofDescriptorProto>()._has_bits_);
+ static void set_has_name(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
static const PROTOBUF_NAMESPACE_ID::OneofOptions& options(const OneofDescriptorProto* msg);
- static void set_has_options(OneofDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_options(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -5689,39 +5785,47 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* OneofDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name(), ptr, ctx, "google.protobuf.OneofDescriptorProto.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional .google.protobuf.OneofOptions options = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool OneofDescriptorProto::MergePartialFromCodedStream(
@@ -5973,11 +6077,12 @@
}
class EnumDescriptorProto_EnumReservedRange::HasBitSetters {
public:
- static void set_has_start(EnumDescriptorProto_EnumReservedRange* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<EnumDescriptorProto_EnumReservedRange>()._has_bits_);
+ static void set_has_start(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_end(EnumDescriptorProto_EnumReservedRange* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_end(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -6057,39 +6162,49 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* EnumDescriptorProto_EnumReservedRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional int32 start = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_start(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_start(&has_bits);
+ start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional int32 end = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_end(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_end(&has_bits);
+ end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool EnumDescriptorProto_EnumReservedRange::MergePartialFromCodedStream(
@@ -6105,7 +6220,7 @@
// optional int32 start = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
- HasBitSetters::set_has_start(this);
+ HasBitSetters::set_has_start(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &start_)));
@@ -6118,7 +6233,7 @@
// optional int32 end = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
- HasBitSetters::set_has_end(this);
+ HasBitSetters::set_has_end(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &end_)));
@@ -6326,12 +6441,13 @@
}
class EnumDescriptorProto::HasBitSetters {
public:
- static void set_has_name(EnumDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<EnumDescriptorProto>()._has_bits_);
+ static void set_has_name(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
static const PROTOBUF_NAMESPACE_ID::EnumOptions& options(const EnumDescriptorProto* msg);
- static void set_has_options(EnumDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_options(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -6454,69 +6570,83 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* EnumDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name(), ptr, ctx, "google.protobuf.EnumDescriptorProto.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.EnumValueDescriptorProto value = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_value(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 18 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 18) break;
+ ptr += 1;
+ }
break;
}
// optional .google.protobuf.EnumOptions options = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_reserved_range(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 34 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 34) break;
+ ptr += 1;
+ }
break;
}
// repeated string reserved_name = 5;
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 42) goto handle_unusual;
- do {
+ while (true) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(add_reserved_name(), ptr, ctx, "google.protobuf.EnumDescriptorProto.reserved_name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 42 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 42) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool EnumDescriptorProto::MergePartialFromCodedStream(
@@ -6899,15 +7029,16 @@
}
class EnumValueDescriptorProto::HasBitSetters {
public:
- static void set_has_name(EnumValueDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<EnumValueDescriptorProto>()._has_bits_);
+ static void set_has_name(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_number(EnumValueDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_number(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
static const PROTOBUF_NAMESPACE_ID::EnumValueOptions& options(const EnumValueDescriptorProto* msg);
- static void set_has_options(EnumValueDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_options(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -7023,46 +7154,55 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* EnumValueDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name(), ptr, ctx, "google.protobuf.EnumValueDescriptorProto.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional int32 number = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_number(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_number(&has_bits);
+ number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional .google.protobuf.EnumValueOptions options = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool EnumValueDescriptorProto::MergePartialFromCodedStream(
@@ -7093,7 +7233,7 @@
// optional int32 number = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
- HasBitSetters::set_has_number(this);
+ HasBitSetters::set_has_number(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &number_)));
@@ -7351,12 +7491,13 @@
}
class ServiceDescriptorProto::HasBitSetters {
public:
- static void set_has_name(ServiceDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<ServiceDescriptorProto>()._has_bits_);
+ static void set_has_name(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
static const PROTOBUF_NAMESPACE_ID::ServiceOptions& options(const ServiceDescriptorProto* msg);
- static void set_has_options(ServiceDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_options(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -7471,49 +7612,59 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* ServiceDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name(), ptr, ctx, "google.protobuf.ServiceDescriptorProto.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.MethodDescriptorProto method = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_method(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 18 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 18) break;
+ ptr += 1;
+ }
break;
}
// optional .google.protobuf.ServiceOptions options = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool ServiceDescriptorProto::MergePartialFromCodedStream(
@@ -7809,24 +7960,25 @@
}
class MethodDescriptorProto::HasBitSetters {
public:
- static void set_has_name(MethodDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<MethodDescriptorProto>()._has_bits_);
+ static void set_has_name(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_input_type(MethodDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_input_type(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
- static void set_has_output_type(MethodDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_output_type(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
static const PROTOBUF_NAMESPACE_ID::MethodOptions& options(const MethodDescriptorProto* msg);
- static void set_has_options(MethodDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000008u;
+ static void set_has_options(HasBits* has_bits) {
+ (*has_bits)[0] |= 8u;
}
- static void set_has_client_streaming(MethodDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000010u;
+ static void set_has_client_streaming(HasBits* has_bits) {
+ (*has_bits)[0] |= 16u;
}
- static void set_has_server_streaming(MethodDescriptorProto* msg) {
- msg->_has_bits_[0] |= 0x00000020u;
+ static void set_has_server_streaming(HasBits* has_bits) {
+ (*has_bits)[0] |= 32u;
}
};
@@ -7969,67 +8121,77 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* MethodDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name(), ptr, ctx, "google.protobuf.MethodDescriptorProto.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string input_type = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_input_type(), ptr, ctx, "google.protobuf.MethodDescriptorProto.input_type");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string output_type = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_output_type(), ptr, ctx, "google.protobuf.MethodDescriptorProto.output_type");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional .google.protobuf.MethodOptions options = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional bool client_streaming = 5 [default = false];
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 40) goto handle_unusual;
- set_client_streaming(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_client_streaming(&has_bits);
+ client_streaming_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool server_streaming = 6 [default = false];
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 48) goto handle_unusual;
- set_server_streaming(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_server_streaming(&has_bits);
+ server_streaming_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool MethodDescriptorProto::MergePartialFromCodedStream(
@@ -8101,7 +8263,7 @@
// optional bool client_streaming = 5 [default = false];
case 5: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
- HasBitSetters::set_has_client_streaming(this);
+ HasBitSetters::set_has_client_streaming(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &client_streaming_)));
@@ -8114,7 +8276,7 @@
// optional bool server_streaming = 6 [default = false];
case 6: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
- HasBitSetters::set_has_server_streaming(this);
+ HasBitSetters::set_has_server_streaming(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &server_streaming_)));
@@ -8442,65 +8604,66 @@
}
class FileOptions::HasBitSetters {
public:
- static void set_has_java_package(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<FileOptions>()._has_bits_);
+ static void set_has_java_package(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_java_outer_classname(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_java_outer_classname(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
- static void set_has_java_multiple_files(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000400u;
+ static void set_has_java_multiple_files(HasBits* has_bits) {
+ (*has_bits)[0] |= 1024u;
}
- static void set_has_java_generate_equals_and_hash(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000800u;
+ static void set_has_java_generate_equals_and_hash(HasBits* has_bits) {
+ (*has_bits)[0] |= 2048u;
}
- static void set_has_java_string_check_utf8(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00001000u;
+ static void set_has_java_string_check_utf8(HasBits* has_bits) {
+ (*has_bits)[0] |= 4096u;
}
- static void set_has_optimize_for(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00080000u;
+ static void set_has_optimize_for(HasBits* has_bits) {
+ (*has_bits)[0] |= 524288u;
}
- static void set_has_go_package(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_go_package(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
- static void set_has_cc_generic_services(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00002000u;
+ static void set_has_cc_generic_services(HasBits* has_bits) {
+ (*has_bits)[0] |= 8192u;
}
- static void set_has_java_generic_services(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00004000u;
+ static void set_has_java_generic_services(HasBits* has_bits) {
+ (*has_bits)[0] |= 16384u;
}
- static void set_has_py_generic_services(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00008000u;
+ static void set_has_py_generic_services(HasBits* has_bits) {
+ (*has_bits)[0] |= 32768u;
}
- static void set_has_php_generic_services(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00010000u;
+ static void set_has_php_generic_services(HasBits* has_bits) {
+ (*has_bits)[0] |= 65536u;
}
- static void set_has_deprecated(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00020000u;
+ static void set_has_deprecated(HasBits* has_bits) {
+ (*has_bits)[0] |= 131072u;
}
- static void set_has_cc_enable_arenas(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00040000u;
+ static void set_has_cc_enable_arenas(HasBits* has_bits) {
+ (*has_bits)[0] |= 262144u;
}
- static void set_has_objc_class_prefix(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000008u;
+ static void set_has_objc_class_prefix(HasBits* has_bits) {
+ (*has_bits)[0] |= 8u;
}
- static void set_has_csharp_namespace(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000010u;
+ static void set_has_csharp_namespace(HasBits* has_bits) {
+ (*has_bits)[0] |= 16u;
}
- static void set_has_swift_prefix(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000020u;
+ static void set_has_swift_prefix(HasBits* has_bits) {
+ (*has_bits)[0] |= 32u;
}
- static void set_has_php_class_prefix(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000040u;
+ static void set_has_php_class_prefix(HasBits* has_bits) {
+ (*has_bits)[0] |= 64u;
}
- static void set_has_php_namespace(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000080u;
+ static void set_has_php_namespace(HasBits* has_bits) {
+ (*has_bits)[0] |= 128u;
}
- static void set_has_php_metadata_namespace(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000100u;
+ static void set_has_php_metadata_namespace(HasBits* has_bits) {
+ (*has_bits)[0] |= 256u;
}
- static void set_has_ruby_package(FileOptions* msg) {
- msg->_has_bits_[0] |= 0x00000200u;
+ static void set_has_ruby_package(HasBits* has_bits) {
+ (*has_bits)[0] |= 512u;
}
};
@@ -8718,31 +8881,33 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* FileOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional string java_package = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_java_package(), ptr, ctx, "google.protobuf.FileOptions.java_package");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string java_outer_classname = 8;
case 8: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 66) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_java_outer_classname(), ptr, ctx, "google.protobuf.FileOptions.java_outer_classname");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
case 9: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 72) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
if (!PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode_IsValid(val)) {
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields());
break;
@@ -8753,151 +8918,168 @@
// optional bool java_multiple_files = 10 [default = false];
case 10: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 80) goto handle_unusual;
- set_java_multiple_files(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_java_multiple_files(&has_bits);
+ java_multiple_files_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional string go_package = 11;
case 11: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 90) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_go_package(), ptr, ctx, "google.protobuf.FileOptions.go_package");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional bool cc_generic_services = 16 [default = false];
case 16: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 128) goto handle_unusual;
- set_cc_generic_services(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_cc_generic_services(&has_bits);
+ cc_generic_services_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool java_generic_services = 17 [default = false];
case 17: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 136) goto handle_unusual;
- set_java_generic_services(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_java_generic_services(&has_bits);
+ java_generic_services_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool py_generic_services = 18 [default = false];
case 18: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 144) goto handle_unusual;
- set_py_generic_services(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_py_generic_services(&has_bits);
+ py_generic_services_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool java_generate_equals_and_hash = 20 [deprecated = true];
case 20: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 160) goto handle_unusual;
- set_java_generate_equals_and_hash(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_java_generate_equals_and_hash(&has_bits);
+ java_generate_equals_and_hash_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool deprecated = 23 [default = false];
case 23: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 184) goto handle_unusual;
- set_deprecated(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_deprecated(&has_bits);
+ deprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool java_string_check_utf8 = 27 [default = false];
case 27: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 216) goto handle_unusual;
- set_java_string_check_utf8(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_java_string_check_utf8(&has_bits);
+ java_string_check_utf8_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool cc_enable_arenas = 31 [default = false];
case 31: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 248) goto handle_unusual;
- set_cc_enable_arenas(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_cc_enable_arenas(&has_bits);
+ cc_enable_arenas_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional string objc_class_prefix = 36;
case 36: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_objc_class_prefix(), ptr, ctx, "google.protobuf.FileOptions.objc_class_prefix");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string csharp_namespace = 37;
case 37: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 42) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_csharp_namespace(), ptr, ctx, "google.protobuf.FileOptions.csharp_namespace");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string swift_prefix = 39;
case 39: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_swift_prefix(), ptr, ctx, "google.protobuf.FileOptions.swift_prefix");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string php_class_prefix = 40;
case 40: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 66) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_php_class_prefix(), ptr, ctx, "google.protobuf.FileOptions.php_class_prefix");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string php_namespace = 41;
case 41: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 74) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_php_namespace(), ptr, ctx, "google.protobuf.FileOptions.php_namespace");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional bool php_generic_services = 42 [default = false];
case 42: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 80) goto handle_unusual;
- set_php_generic_services(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_php_generic_services(&has_bits);
+ php_generic_services_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional string php_metadata_namespace = 44;
case 44: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 98) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_php_metadata_namespace(), ptr, ctx, "google.protobuf.FileOptions.php_metadata_namespace");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string ruby_package = 45;
case 45: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 106) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_ruby_package(), ptr, ctx, "google.protobuf.FileOptions.ruby_package");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
case 999: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_uninterpreted_option(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 65535) == 16058 && (ptr += 2));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint16>(ptr) != 16058) break;
+ ptr += 2;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
if ((8000u <= tag)) {
ptr = _extensions_.ParseField(tag, ptr,
internal_default_instance(), &_internal_metadata_, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool FileOptions::MergePartialFromCodedStream(
@@ -8962,7 +9144,7 @@
// optional bool java_multiple_files = 10 [default = false];
case 10: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (80 & 0xFF)) {
- HasBitSetters::set_has_java_multiple_files(this);
+ HasBitSetters::set_has_java_multiple_files(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &java_multiple_files_)));
@@ -8990,7 +9172,7 @@
// optional bool cc_generic_services = 16 [default = false];
case 16: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (128 & 0xFF)) {
- HasBitSetters::set_has_cc_generic_services(this);
+ HasBitSetters::set_has_cc_generic_services(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &cc_generic_services_)));
@@ -9003,7 +9185,7 @@
// optional bool java_generic_services = 17 [default = false];
case 17: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (136 & 0xFF)) {
- HasBitSetters::set_has_java_generic_services(this);
+ HasBitSetters::set_has_java_generic_services(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &java_generic_services_)));
@@ -9016,7 +9198,7 @@
// optional bool py_generic_services = 18 [default = false];
case 18: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (144 & 0xFF)) {
- HasBitSetters::set_has_py_generic_services(this);
+ HasBitSetters::set_has_py_generic_services(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &py_generic_services_)));
@@ -9029,7 +9211,7 @@
// optional bool java_generate_equals_and_hash = 20 [deprecated = true];
case 20: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (160 & 0xFF)) {
- HasBitSetters::set_has_java_generate_equals_and_hash(this);
+ HasBitSetters::set_has_java_generate_equals_and_hash(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &java_generate_equals_and_hash_)));
@@ -9042,7 +9224,7 @@
// optional bool deprecated = 23 [default = false];
case 23: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (184 & 0xFF)) {
- HasBitSetters::set_has_deprecated(this);
+ HasBitSetters::set_has_deprecated(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &deprecated_)));
@@ -9055,7 +9237,7 @@
// optional bool java_string_check_utf8 = 27 [default = false];
case 27: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (216 & 0xFF)) {
- HasBitSetters::set_has_java_string_check_utf8(this);
+ HasBitSetters::set_has_java_string_check_utf8(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &java_string_check_utf8_)));
@@ -9068,7 +9250,7 @@
// optional bool cc_enable_arenas = 31 [default = false];
case 31: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (248 & 0xFF)) {
- HasBitSetters::set_has_cc_enable_arenas(this);
+ HasBitSetters::set_has_cc_enable_arenas(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &cc_enable_arenas_)));
@@ -9156,7 +9338,7 @@
// optional bool php_generic_services = 42 [default = false];
case 42: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (336 & 0xFF)) {
- HasBitSetters::set_has_php_generic_services(this);
+ HasBitSetters::set_has_php_generic_services(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &php_generic_services_)));
@@ -9945,17 +10127,18 @@
}
class MessageOptions::HasBitSetters {
public:
- static void set_has_message_set_wire_format(MessageOptions* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<MessageOptions>()._has_bits_);
+ static void set_has_message_set_wire_format(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_no_standard_descriptor_accessor(MessageOptions* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_no_standard_descriptor_accessor(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
- static void set_has_deprecated(MessageOptions* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_deprecated(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
- static void set_has_map_entry(MessageOptions* msg) {
- msg->_has_bits_[0] |= 0x00000008u;
+ static void set_has_map_entry(HasBits* has_bits) {
+ (*has_bits)[0] |= 8u;
}
};
@@ -10043,69 +10226,83 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* MessageOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional bool message_set_wire_format = 1 [default = false];
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_message_set_wire_format(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_message_set_wire_format(&has_bits);
+ message_set_wire_format_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool no_standard_descriptor_accessor = 2 [default = false];
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_no_standard_descriptor_accessor(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_no_standard_descriptor_accessor(&has_bits);
+ no_standard_descriptor_accessor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool deprecated = 3 [default = false];
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 24) goto handle_unusual;
- set_deprecated(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_deprecated(&has_bits);
+ deprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool map_entry = 7;
case 7: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 56) goto handle_unusual;
- set_map_entry(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_map_entry(&has_bits);
+ map_entry_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
case 999: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_uninterpreted_option(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 65535) == 16058 && (ptr += 2));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint16>(ptr) != 16058) break;
+ ptr += 2;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
if ((8000u <= tag)) {
ptr = _extensions_.ParseField(tag, ptr,
internal_default_instance(), &_internal_metadata_, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool MessageOptions::MergePartialFromCodedStream(
@@ -10121,7 +10318,7 @@
// optional bool message_set_wire_format = 1 [default = false];
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
- HasBitSetters::set_has_message_set_wire_format(this);
+ HasBitSetters::set_has_message_set_wire_format(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &message_set_wire_format_)));
@@ -10134,7 +10331,7 @@
// optional bool no_standard_descriptor_accessor = 2 [default = false];
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
- HasBitSetters::set_has_no_standard_descriptor_accessor(this);
+ HasBitSetters::set_has_no_standard_descriptor_accessor(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &no_standard_descriptor_accessor_)));
@@ -10147,7 +10344,7 @@
// optional bool deprecated = 3 [default = false];
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
- HasBitSetters::set_has_deprecated(this);
+ HasBitSetters::set_has_deprecated(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &deprecated_)));
@@ -10160,7 +10357,7 @@
// optional bool map_entry = 7;
case 7: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {
- HasBitSetters::set_has_map_entry(this);
+ HasBitSetters::set_has_map_entry(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &map_entry_)));
@@ -10463,23 +10660,24 @@
}
class FieldOptions::HasBitSetters {
public:
- static void set_has_ctype(FieldOptions* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<FieldOptions>()._has_bits_);
+ static void set_has_ctype(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_packed(FieldOptions* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_packed(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
- static void set_has_jstype(FieldOptions* msg) {
- msg->_has_bits_[0] |= 0x00000020u;
+ static void set_has_jstype(HasBits* has_bits) {
+ (*has_bits)[0] |= 32u;
}
- static void set_has_lazy(FieldOptions* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_lazy(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
- static void set_has_deprecated(FieldOptions* msg) {
- msg->_has_bits_[0] |= 0x00000008u;
+ static void set_has_deprecated(HasBits* has_bits) {
+ (*has_bits)[0] |= 8u;
}
- static void set_has_weak(FieldOptions* msg) {
- msg->_has_bits_[0] |= 0x00000010u;
+ static void set_has_weak(HasBits* has_bits) {
+ (*has_bits)[0] |= 16u;
}
};
@@ -10572,17 +10770,19 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* FieldOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
if (!PROTOBUF_NAMESPACE_ID::FieldOptions_CType_IsValid(val)) {
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
break;
@@ -10593,29 +10793,32 @@
// optional bool packed = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_packed(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_packed(&has_bits);
+ packed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool deprecated = 3 [default = false];
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 24) goto handle_unusual;
- set_deprecated(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_deprecated(&has_bits);
+ deprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool lazy = 5 [default = false];
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 40) goto handle_unusual;
- set_lazy(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_lazy(&has_bits);
+ lazy_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 48) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
if (!PROTOBUF_NAMESPACE_ID::FieldOptions_JSType_IsValid(val)) {
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
break;
@@ -10626,39 +10829,48 @@
// optional bool weak = 10 [default = false];
case 10: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 80) goto handle_unusual;
- set_weak(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_weak(&has_bits);
+ weak_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
case 999: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_uninterpreted_option(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 65535) == 16058 && (ptr += 2));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint16>(ptr) != 16058) break;
+ ptr += 2;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
if ((8000u <= tag)) {
ptr = _extensions_.ParseField(tag, ptr,
internal_default_instance(), &_internal_metadata_, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool FieldOptions::MergePartialFromCodedStream(
@@ -10693,7 +10905,7 @@
// optional bool packed = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
- HasBitSetters::set_has_packed(this);
+ HasBitSetters::set_has_packed(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &packed_)));
@@ -10706,7 +10918,7 @@
// optional bool deprecated = 3 [default = false];
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
- HasBitSetters::set_has_deprecated(this);
+ HasBitSetters::set_has_deprecated(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &deprecated_)));
@@ -10719,7 +10931,7 @@
// optional bool lazy = 5 [default = false];
case 5: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
- HasBitSetters::set_has_lazy(this);
+ HasBitSetters::set_has_lazy(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &lazy_)));
@@ -10751,7 +10963,7 @@
// optional bool weak = 10 [default = false];
case 10: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (80 & 0xFF)) {
- HasBitSetters::set_has_weak(this);
+ HasBitSetters::set_has_weak(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &weak_)));
@@ -11098,6 +11310,7 @@
}
class OneofOptions::HasBitSetters {
public:
+ using HasBits = decltype(std::declval<OneofOptions>()._has_bits_);
};
#if !defined(_MSC_VER) || _MSC_VER >= 1900
@@ -11171,41 +11384,49 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* OneofOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
case 999: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_uninterpreted_option(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 65535) == 16058 && (ptr += 2));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint16>(ptr) != 16058) break;
+ ptr += 2;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
if ((8000u <= tag)) {
ptr = _extensions_.ParseField(tag, ptr,
internal_default_instance(), &_internal_metadata_, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool OneofOptions::MergePartialFromCodedStream(
@@ -11426,11 +11647,12 @@
}
class EnumOptions::HasBitSetters {
public:
- static void set_has_allow_alias(EnumOptions* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<EnumOptions>()._has_bits_);
+ static void set_has_allow_alias(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_deprecated(EnumOptions* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_deprecated(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -11516,55 +11738,67 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* EnumOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional bool allow_alias = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_allow_alias(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_allow_alias(&has_bits);
+ allow_alias_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional bool deprecated = 3 [default = false];
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 24) goto handle_unusual;
- set_deprecated(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_deprecated(&has_bits);
+ deprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
case 999: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_uninterpreted_option(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 65535) == 16058 && (ptr += 2));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint16>(ptr) != 16058) break;
+ ptr += 2;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
if ((8000u <= tag)) {
ptr = _extensions_.ParseField(tag, ptr,
internal_default_instance(), &_internal_metadata_, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool EnumOptions::MergePartialFromCodedStream(
@@ -11580,7 +11814,7 @@
// optional bool allow_alias = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
- HasBitSetters::set_has_allow_alias(this);
+ HasBitSetters::set_has_allow_alias(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &allow_alias_)));
@@ -11593,7 +11827,7 @@
// optional bool deprecated = 3 [default = false];
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
- HasBitSetters::set_has_deprecated(this);
+ HasBitSetters::set_has_deprecated(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &deprecated_)));
@@ -11858,8 +12092,9 @@
}
class EnumValueOptions::HasBitSetters {
public:
- static void set_has_deprecated(EnumValueOptions* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<EnumValueOptions>()._has_bits_);
+ static void set_has_deprecated(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
};
@@ -11938,48 +12173,59 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* EnumValueOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional bool deprecated = 1 [default = false];
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_deprecated(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_deprecated(&has_bits);
+ deprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
case 999: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_uninterpreted_option(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 65535) == 16058 && (ptr += 2));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint16>(ptr) != 16058) break;
+ ptr += 2;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
if ((8000u <= tag)) {
ptr = _extensions_.ParseField(tag, ptr,
internal_default_instance(), &_internal_metadata_, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool EnumValueOptions::MergePartialFromCodedStream(
@@ -11995,7 +12241,7 @@
// optional bool deprecated = 1 [default = false];
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
- HasBitSetters::set_has_deprecated(this);
+ HasBitSetters::set_has_deprecated(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &deprecated_)));
@@ -12235,8 +12481,9 @@
}
class ServiceOptions::HasBitSetters {
public:
- static void set_has_deprecated(ServiceOptions* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<ServiceOptions>()._has_bits_);
+ static void set_has_deprecated(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
};
@@ -12315,48 +12562,59 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* ServiceOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional bool deprecated = 33 [default = false];
case 33: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_deprecated(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_deprecated(&has_bits);
+ deprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
case 999: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_uninterpreted_option(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 65535) == 16058 && (ptr += 2));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint16>(ptr) != 16058) break;
+ ptr += 2;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
if ((8000u <= tag)) {
ptr = _extensions_.ParseField(tag, ptr,
internal_default_instance(), &_internal_metadata_, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool ServiceOptions::MergePartialFromCodedStream(
@@ -12372,7 +12630,7 @@
// optional bool deprecated = 33 [default = false];
case 33: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (264 & 0xFF)) {
- HasBitSetters::set_has_deprecated(this);
+ HasBitSetters::set_has_deprecated(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &deprecated_)));
@@ -12612,11 +12870,12 @@
}
class MethodOptions::HasBitSetters {
public:
- static void set_has_deprecated(MethodOptions* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<MethodOptions>()._has_bits_);
+ static void set_has_deprecated(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_idempotency_level(MethodOptions* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_idempotency_level(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -12705,24 +12964,27 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* MethodOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// optional bool deprecated = 33 [default = false];
case 33: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_deprecated(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_deprecated(&has_bits);
+ deprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN];
case 34: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
if (!PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel_IsValid(val)) {
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(34, val, mutable_unknown_fields());
break;
@@ -12733,32 +12995,40 @@
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
case 999: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_uninterpreted_option(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 65535) == 16058 && (ptr += 2));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint16>(ptr) != 16058) break;
+ ptr += 2;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
if ((8000u <= tag)) {
ptr = _extensions_.ParseField(tag, ptr,
internal_default_instance(), &_internal_metadata_, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool MethodOptions::MergePartialFromCodedStream(
@@ -12774,7 +13044,7 @@
// optional bool deprecated = 33 [default = false];
case 33: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (264 & 0xFF)) {
- HasBitSetters::set_has_deprecated(this);
+ HasBitSetters::set_has_deprecated(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &deprecated_)));
@@ -13061,11 +13331,12 @@
}
class UninterpretedOption_NamePart::HasBitSetters {
public:
- static void set_has_name_part(UninterpretedOption_NamePart* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<UninterpretedOption_NamePart>()._has_bits_);
+ static void set_has_name_part(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_is_extension(UninterpretedOption_NamePart* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_is_extension(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -13149,39 +13420,48 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* UninterpretedOption_NamePart::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// required string name_part = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_name_part(), ptr, ctx, "google.protobuf.UninterpretedOption.NamePart.name_part");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// required bool is_extension = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_is_extension(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_is_extension(&has_bits);
+ is_extension_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool UninterpretedOption_NamePart::MergePartialFromCodedStream(
@@ -13212,7 +13492,7 @@
// required bool is_extension = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
- HasBitSetters::set_has_is_extension(this);
+ HasBitSetters::set_has_is_extension(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &is_extension_)));
@@ -13444,23 +13724,24 @@
}
class UninterpretedOption::HasBitSetters {
public:
- static void set_has_identifier_value(UninterpretedOption* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<UninterpretedOption>()._has_bits_);
+ static void set_has_identifier_value(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_positive_int_value(UninterpretedOption* msg) {
- msg->_has_bits_[0] |= 0x00000008u;
+ static void set_has_positive_int_value(HasBits* has_bits) {
+ (*has_bits)[0] |= 8u;
}
- static void set_has_negative_int_value(UninterpretedOption* msg) {
- msg->_has_bits_[0] |= 0x00000010u;
+ static void set_has_negative_int_value(HasBits* has_bits) {
+ (*has_bits)[0] |= 16u;
}
- static void set_has_double_value(UninterpretedOption* msg) {
- msg->_has_bits_[0] |= 0x00000020u;
+ static void set_has_double_value(HasBits* has_bits) {
+ (*has_bits)[0] |= 32u;
}
- static void set_has_string_value(UninterpretedOption* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_string_value(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
- static void set_has_aggregate_value(UninterpretedOption* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_aggregate_value(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
};
@@ -13582,47 +13863,54 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* UninterpretedOption::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_name(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 18 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 18) break;
+ ptr += 1;
+ }
break;
}
// optional string identifier_value = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_identifier_value(), ptr, ctx, "google.protobuf.UninterpretedOption.identifier_value");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional uint64 positive_int_value = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 32) goto handle_unusual;
- set_positive_int_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_positive_int_value(&has_bits);
+ positive_int_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional int64 negative_int_value = 5;
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 40) goto handle_unusual;
- set_negative_int_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_negative_int_value(&has_bits);
+ negative_int_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional double double_value = 6;
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 49) goto handle_unusual;
- set_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
+ HasBitSetters::set_has_double_value(&has_bits);
+ double_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
ptr += sizeof(double);
break;
}
@@ -13630,29 +13918,35 @@
case 7: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 58) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_string_value(), ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string aggregate_value = 8;
case 8: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 66) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_aggregate_value(), ptr, ctx, "google.protobuf.UninterpretedOption.aggregate_value");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool UninterpretedOption::MergePartialFromCodedStream(
@@ -13694,7 +13988,7 @@
// optional uint64 positive_int_value = 4;
case 4: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
- HasBitSetters::set_has_positive_int_value(this);
+ HasBitSetters::set_has_positive_int_value(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
input, &positive_int_value_)));
@@ -13707,7 +14001,7 @@
// optional int64 negative_int_value = 5;
case 5: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
- HasBitSetters::set_has_negative_int_value(this);
+ HasBitSetters::set_has_negative_int_value(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
input, &negative_int_value_)));
@@ -13720,7 +14014,7 @@
// optional double double_value = 6;
case 6: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (49 & 0xFF)) {
- HasBitSetters::set_has_double_value(this);
+ HasBitSetters::set_has_double_value(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>(
input, &double_value_)));
@@ -14093,11 +14387,12 @@
}
class SourceCodeInfo_Location::HasBitSetters {
public:
- static void set_has_leading_comments(SourceCodeInfo_Location* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<SourceCodeInfo_Location>()._has_bits_);
+ static void set_has_leading_comments(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_trailing_comments(SourceCodeInfo_Location* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_trailing_comments(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
};
@@ -14202,77 +14497,91 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* SourceCodeInfo_Location::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// repeated int32 path = 1 [packed = true];
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(mutable_path(), ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
} else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- do {
+ while (true) {
add_path(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 8 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 8) break;
+ ptr += 1;
+ }
break;
}
// repeated int32 span = 2 [packed = true];
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(mutable_span(), ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
} else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- do {
+ while (true) {
add_span(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 16 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 16) break;
+ ptr += 1;
+ }
break;
}
// optional string leading_comments = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_leading_comments(), ptr, ctx, "google.protobuf.SourceCodeInfo.Location.leading_comments");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional string trailing_comments = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_trailing_comments(), ptr, ctx, "google.protobuf.SourceCodeInfo.Location.trailing_comments");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated string leading_detached_comments = 6;
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 50) goto handle_unusual;
- do {
+ while (true) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(add_leading_detached_comments(), ptr, ctx, "google.protobuf.SourceCodeInfo.Location.leading_detached_comments");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 50 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 50) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool SourceCodeInfo_Location::MergePartialFromCodedStream(
@@ -14694,6 +15003,7 @@
}
class SourceCodeInfo::HasBitSetters {
public:
+ using HasBits = decltype(std::declval<SourceCodeInfo>()._has_bits_);
};
#if !defined(_MSC_VER) || _MSC_VER >= 1900
@@ -14764,35 +15074,43 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* SourceCodeInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// repeated .google.protobuf.SourceCodeInfo.Location location = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_location(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 10 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 10) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool SourceCodeInfo::MergePartialFromCodedStream(
@@ -14991,14 +15309,15 @@
}
class GeneratedCodeInfo_Annotation::HasBitSetters {
public:
- static void set_has_source_file(GeneratedCodeInfo_Annotation* msg) {
- msg->_has_bits_[0] |= 0x00000001u;
+ using HasBits = decltype(std::declval<GeneratedCodeInfo_Annotation>()._has_bits_);
+ static void set_has_source_file(HasBits* has_bits) {
+ (*has_bits)[0] |= 1u;
}
- static void set_has_begin(GeneratedCodeInfo_Annotation* msg) {
- msg->_has_bits_[0] |= 0x00000002u;
+ static void set_has_begin(HasBits* has_bits) {
+ (*has_bits)[0] |= 2u;
}
- static void set_has_end(GeneratedCodeInfo_Annotation* msg) {
- msg->_has_bits_[0] |= 0x00000004u;
+ static void set_has_end(HasBits* has_bits) {
+ (*has_bits)[0] |= 4u;
}
};
@@ -15095,60 +15414,72 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* GeneratedCodeInfo_Annotation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ HasBitSetters::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// repeated int32 path = 1 [packed = true];
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(mutable_path(), ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
} else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- do {
+ while (true) {
add_path(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 8 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 8) break;
+ ptr += 1;
+ }
break;
}
// optional string source_file = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(mutable_source_file(), ptr, ctx, "google.protobuf.GeneratedCodeInfo.Annotation.source_file");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// optional int32 begin = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 24) goto handle_unusual;
- set_begin(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_begin(&has_bits);
+ begin_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// optional int32 end = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 32) goto handle_unusual;
- set_end(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ HasBitSetters::set_has_end(&has_bits);
+ end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
+ _has_bits_.Or(has_bits);
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool GeneratedCodeInfo_Annotation::MergePartialFromCodedStream(
@@ -15195,7 +15526,7 @@
// optional int32 begin = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
- HasBitSetters::set_has_begin(this);
+ HasBitSetters::set_has_begin(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &begin_)));
@@ -15208,7 +15539,7 @@
// optional int32 end = 4;
case 4: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
- HasBitSetters::set_has_end(this);
+ HasBitSetters::set_has_end(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &end_)));
@@ -15488,6 +15819,7 @@
}
class GeneratedCodeInfo::HasBitSetters {
public:
+ using HasBits = decltype(std::declval<GeneratedCodeInfo>()._has_bits_);
};
#if !defined(_MSC_VER) || _MSC_VER >= 1900
@@ -15558,35 +15890,43 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* GeneratedCodeInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// repeated .google.protobuf.GeneratedCodeInfo.Annotation annotation = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_annotation(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 10 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 10) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool GeneratedCodeInfo::MergePartialFromCodedStream(
diff --git a/src/google/protobuf/descriptor.pb.h b/src/google/protobuf/descriptor.pb.h
index bff027e..5fb18b8 100644
--- a/src/google/protobuf/descriptor.pb.h
+++ b/src/google/protobuf/descriptor.pb.h
@@ -168,7 +168,7 @@
PROTOBUF_NAMESPACE_CLOSE
PROTOBUF_NAMESPACE_OPEN
-enum FieldDescriptorProto_Type {
+enum FieldDescriptorProto_Type : int {
FieldDescriptorProto_Type_TYPE_DOUBLE = 1,
FieldDescriptorProto_Type_TYPE_FLOAT = 2,
FieldDescriptorProto_Type_TYPE_INT64 = 3,
@@ -194,16 +194,20 @@
constexpr int FieldDescriptorProto_Type_Type_ARRAYSIZE = FieldDescriptorProto_Type_Type_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldDescriptorProto_Type_descriptor();
-inline const std::string& FieldDescriptorProto_Type_Name(FieldDescriptorProto_Type value) {
+template<typename T>
+inline const std::string& FieldDescriptorProto_Type_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, FieldDescriptorProto_Type>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function FieldDescriptorProto_Type_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
- FieldDescriptorProto_Type_descriptor(), value);
+ FieldDescriptorProto_Type_descriptor(), enum_t_value);
}
inline bool FieldDescriptorProto_Type_Parse(
const std::string& name, FieldDescriptorProto_Type* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldDescriptorProto_Type>(
FieldDescriptorProto_Type_descriptor(), name, value);
}
-enum FieldDescriptorProto_Label {
+enum FieldDescriptorProto_Label : int {
FieldDescriptorProto_Label_LABEL_OPTIONAL = 1,
FieldDescriptorProto_Label_LABEL_REQUIRED = 2,
FieldDescriptorProto_Label_LABEL_REPEATED = 3
@@ -214,16 +218,20 @@
constexpr int FieldDescriptorProto_Label_Label_ARRAYSIZE = FieldDescriptorProto_Label_Label_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldDescriptorProto_Label_descriptor();
-inline const std::string& FieldDescriptorProto_Label_Name(FieldDescriptorProto_Label value) {
+template<typename T>
+inline const std::string& FieldDescriptorProto_Label_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, FieldDescriptorProto_Label>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function FieldDescriptorProto_Label_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
- FieldDescriptorProto_Label_descriptor(), value);
+ FieldDescriptorProto_Label_descriptor(), enum_t_value);
}
inline bool FieldDescriptorProto_Label_Parse(
const std::string& name, FieldDescriptorProto_Label* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldDescriptorProto_Label>(
FieldDescriptorProto_Label_descriptor(), name, value);
}
-enum FileOptions_OptimizeMode {
+enum FileOptions_OptimizeMode : int {
FileOptions_OptimizeMode_SPEED = 1,
FileOptions_OptimizeMode_CODE_SIZE = 2,
FileOptions_OptimizeMode_LITE_RUNTIME = 3
@@ -234,16 +242,20 @@
constexpr int FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = FileOptions_OptimizeMode_OptimizeMode_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FileOptions_OptimizeMode_descriptor();
-inline const std::string& FileOptions_OptimizeMode_Name(FileOptions_OptimizeMode value) {
+template<typename T>
+inline const std::string& FileOptions_OptimizeMode_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, FileOptions_OptimizeMode>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function FileOptions_OptimizeMode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
- FileOptions_OptimizeMode_descriptor(), value);
+ FileOptions_OptimizeMode_descriptor(), enum_t_value);
}
inline bool FileOptions_OptimizeMode_Parse(
const std::string& name, FileOptions_OptimizeMode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FileOptions_OptimizeMode>(
FileOptions_OptimizeMode_descriptor(), name, value);
}
-enum FieldOptions_CType {
+enum FieldOptions_CType : int {
FieldOptions_CType_STRING = 0,
FieldOptions_CType_CORD = 1,
FieldOptions_CType_STRING_PIECE = 2
@@ -254,16 +266,20 @@
constexpr int FieldOptions_CType_CType_ARRAYSIZE = FieldOptions_CType_CType_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldOptions_CType_descriptor();
-inline const std::string& FieldOptions_CType_Name(FieldOptions_CType value) {
+template<typename T>
+inline const std::string& FieldOptions_CType_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, FieldOptions_CType>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function FieldOptions_CType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
- FieldOptions_CType_descriptor(), value);
+ FieldOptions_CType_descriptor(), enum_t_value);
}
inline bool FieldOptions_CType_Parse(
const std::string& name, FieldOptions_CType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldOptions_CType>(
FieldOptions_CType_descriptor(), name, value);
}
-enum FieldOptions_JSType {
+enum FieldOptions_JSType : int {
FieldOptions_JSType_JS_NORMAL = 0,
FieldOptions_JSType_JS_STRING = 1,
FieldOptions_JSType_JS_NUMBER = 2
@@ -274,16 +290,20 @@
constexpr int FieldOptions_JSType_JSType_ARRAYSIZE = FieldOptions_JSType_JSType_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldOptions_JSType_descriptor();
-inline const std::string& FieldOptions_JSType_Name(FieldOptions_JSType value) {
+template<typename T>
+inline const std::string& FieldOptions_JSType_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, FieldOptions_JSType>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function FieldOptions_JSType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
- FieldOptions_JSType_descriptor(), value);
+ FieldOptions_JSType_descriptor(), enum_t_value);
}
inline bool FieldOptions_JSType_Parse(
const std::string& name, FieldOptions_JSType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldOptions_JSType>(
FieldOptions_JSType_descriptor(), name, value);
}
-enum MethodOptions_IdempotencyLevel {
+enum MethodOptions_IdempotencyLevel : int {
MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN = 0,
MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS = 1,
MethodOptions_IdempotencyLevel_IDEMPOTENT = 2
@@ -294,9 +314,13 @@
constexpr int MethodOptions_IdempotencyLevel_IdempotencyLevel_ARRAYSIZE = MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MethodOptions_IdempotencyLevel_descriptor();
-inline const std::string& MethodOptions_IdempotencyLevel_Name(MethodOptions_IdempotencyLevel value) {
+template<typename T>
+inline const std::string& MethodOptions_IdempotencyLevel_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, MethodOptions_IdempotencyLevel>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function MethodOptions_IdempotencyLevel_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
- MethodOptions_IdempotencyLevel_descriptor(), value);
+ MethodOptions_IdempotencyLevel_descriptor(), enum_t_value);
}
inline bool MethodOptions_IdempotencyLevel_Parse(
const std::string& name, MethodOptions_IdempotencyLevel* value) {
@@ -1657,8 +1681,12 @@
Type_descriptor() {
return FieldDescriptorProto_Type_descriptor();
}
- static inline const std::string& Type_Name(Type value) {
- return FieldDescriptorProto_Type_Name(value);
+ template<typename T>
+ static inline const std::string& Type_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Type>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function Type_Name.");
+ return FieldDescriptorProto_Type_Name(enum_t_value);
}
static inline bool Type_Parse(const std::string& name,
Type* value) {
@@ -1685,8 +1713,12 @@
Label_descriptor() {
return FieldDescriptorProto_Label_descriptor();
}
- static inline const std::string& Label_Name(Label value) {
- return FieldDescriptorProto_Label_Name(value);
+ template<typename T>
+ static inline const std::string& Label_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Label>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function Label_Name.");
+ return FieldDescriptorProto_Label_Name(enum_t_value);
}
static inline bool Label_Parse(const std::string& name,
Label* value) {
@@ -3102,8 +3134,12 @@
OptimizeMode_descriptor() {
return FileOptions_OptimizeMode_descriptor();
}
- static inline const std::string& OptimizeMode_Name(OptimizeMode value) {
- return FileOptions_OptimizeMode_Name(value);
+ template<typename T>
+ static inline const std::string& OptimizeMode_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, OptimizeMode>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function OptimizeMode_Name.");
+ return FileOptions_OptimizeMode_Name(enum_t_value);
}
static inline bool OptimizeMode_Parse(const std::string& name,
OptimizeMode* value) {
@@ -3762,8 +3798,12 @@
CType_descriptor() {
return FieldOptions_CType_descriptor();
}
- static inline const std::string& CType_Name(CType value) {
- return FieldOptions_CType_Name(value);
+ template<typename T>
+ static inline const std::string& CType_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, CType>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function CType_Name.");
+ return FieldOptions_CType_Name(enum_t_value);
}
static inline bool CType_Parse(const std::string& name,
CType* value) {
@@ -3790,8 +3830,12 @@
JSType_descriptor() {
return FieldOptions_JSType_descriptor();
}
- static inline const std::string& JSType_Name(JSType value) {
- return FieldOptions_JSType_Name(value);
+ template<typename T>
+ static inline const std::string& JSType_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, JSType>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function JSType_Name.");
+ return FieldOptions_JSType_Name(enum_t_value);
}
static inline bool JSType_Parse(const std::string& name,
JSType* value) {
@@ -4623,8 +4667,12 @@
IdempotencyLevel_descriptor() {
return MethodOptions_IdempotencyLevel_descriptor();
}
- static inline const std::string& IdempotencyLevel_Name(IdempotencyLevel value) {
- return MethodOptions_IdempotencyLevel_Name(value);
+ template<typename T>
+ static inline const std::string& IdempotencyLevel_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, IdempotencyLevel>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function IdempotencyLevel_Name.");
+ return MethodOptions_IdempotencyLevel_Name(enum_t_value);
}
static inline bool IdempotencyLevel_Parse(const std::string& name,
IdempotencyLevel* value) {
diff --git a/src/google/protobuf/descriptor_database.cc b/src/google/protobuf/descriptor_database.cc
index 55d6bb1..dbd0f4a 100644
--- a/src/google/protobuf/descriptor_database.cc
+++ b/src/google/protobuf/descriptor_database.cc
@@ -51,8 +51,7 @@
template <typename Value>
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::AddFile(
- const FileDescriptorProto& file,
- Value value) {
+ const FileDescriptorProto& file, Value value) {
if (!InsertIfNotPresent(&by_name_, file.name(), value)) {
GOOGLE_LOG(ERROR) << "File already exists in database: " << file.name();
return false;
@@ -108,8 +107,10 @@
}
if (IsSubSymbol(iter->first, name)) {
- GOOGLE_LOG(ERROR) << "Symbol name \"" << name << "\" conflicts with the existing "
- "symbol \"" << iter->first << "\".";
+ GOOGLE_LOG(ERROR) << "Symbol name \"" << name
+ << "\" conflicts with the existing "
+ "symbol \""
+ << iter->first << "\".";
return false;
}
@@ -121,8 +122,10 @@
++iter;
if (iter != by_symbol_.end() && IsSubSymbol(name, iter->first)) {
- GOOGLE_LOG(ERROR) << "Symbol name \"" << name << "\" conflicts with the existing "
- "symbol \"" << iter->first << "\".";
+ GOOGLE_LOG(ERROR) << "Symbol name \"" << name
+ << "\" conflicts with the existing "
+ "symbol \""
+ << iter->first << "\".";
return false;
}
@@ -138,8 +141,7 @@
template <typename Value>
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::AddNestedExtensions(
- const DescriptorProto& message_type,
- Value value) {
+ const DescriptorProto& message_type, Value value) {
for (int i = 0; i < message_type.nested_type_size(); i++) {
if (!AddNestedExtensions(message_type.nested_type(i), value)) return false;
}
@@ -151,8 +153,7 @@
template <typename Value>
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::AddExtension(
- const FieldDescriptorProto& field,
- Value value) {
+ const FieldDescriptorProto& field, Value value) {
if (!field.extendee().empty() && field.extendee()[0] == '.') {
// The extension is fully-qualified. We can use it as a lookup key in
// the by_symbol_ table.
@@ -161,8 +162,9 @@
std::make_pair(field.extendee().substr(1), field.number()),
value)) {
GOOGLE_LOG(ERROR) << "Extension conflicts with extension already in database: "
- "extend " << field.extendee() << " { "
- << field.name() << " = " << field.number() << " }";
+ "extend "
+ << field.extendee() << " { " << field.name() << " = "
+ << field.number() << " }";
return false;
}
} else {
@@ -185,8 +187,9 @@
typename std::map<std::string, Value>::iterator iter =
FindLastLessOrEqual(name);
- return (iter != by_symbol_.end() && IsSubSymbol(iter->first, name)) ?
- iter->second : Value();
+ return (iter != by_symbol_.end() && IsSubSymbol(iter->first, name))
+ ? iter->second
+ : Value();
}
template <typename Value>
@@ -249,10 +252,8 @@
const std::string& name) {
for (int i = 0; i < name.size(); i++) {
// I don't trust ctype.h due to locales. :(
- if (name[i] != '.' && name[i] != '_' &&
- (name[i] < '0' || name[i] > '9') &&
- (name[i] < 'A' || name[i] > 'Z') &&
- (name[i] < 'a' || name[i] > 'z')) {
+ if (name[i] != '.' && name[i] != '_' && (name[i] < '0' || name[i] > '9') &&
+ (name[i] < 'A' || name[i] > 'Z') && (name[i] < 'a' || name[i] > 'z')) {
return false;
}
}
@@ -321,8 +322,8 @@
}
}
-bool EncodedDescriptorDatabase::Add(
- const void* encoded_file_descriptor, int size) {
+bool EncodedDescriptorDatabase::Add(const void* encoded_file_descriptor,
+ int size) {
FileDescriptorProto file;
if (file.ParseFromArray(encoded_file_descriptor, size)) {
return index_.AddFile(file, std::make_pair(encoded_file_descriptor, size));
@@ -333,8 +334,8 @@
}
}
-bool EncodedDescriptorDatabase::AddCopy(
- const void* encoded_file_descriptor, int size) {
+bool EncodedDescriptorDatabase::AddCopy(const void* encoded_file_descriptor,
+ int size) {
void* copy = operator new(size);
memcpy(copy, encoded_file_descriptor, size);
files_to_delete_.push_back(copy);
@@ -392,8 +393,7 @@
}
bool EncodedDescriptorDatabase::MaybeParse(
- std::pair<const void*, int> encoded_file,
- FileDescriptorProto* output) {
+ std::pair<const void*, int> encoded_file, FileDescriptorProto* output) {
if (encoded_file.first == NULL) return false;
return output->ParseFromArray(encoded_file.first, encoded_file.second);
}
@@ -401,7 +401,7 @@
// ===================================================================
DescriptorPoolDatabase::DescriptorPoolDatabase(const DescriptorPool& pool)
- : pool_(pool) {}
+ : pool_(pool) {}
DescriptorPoolDatabase::~DescriptorPoolDatabase() {}
bool DescriptorPoolDatabase::FindFileByName(const std::string& filename,
@@ -429,7 +429,7 @@
if (extendee == NULL) return false;
const FieldDescriptor* extension =
- pool_.FindExtensionByNumber(extendee, field_number);
+ pool_.FindExtensionByNumber(extendee, field_number);
if (extension == NULL) return false;
output->Clear();
@@ -455,14 +455,13 @@
// ===================================================================
MergedDescriptorDatabase::MergedDescriptorDatabase(
- DescriptorDatabase* source1,
- DescriptorDatabase* source2) {
+ DescriptorDatabase* source1, DescriptorDatabase* source2) {
sources_.push_back(source1);
sources_.push_back(source2);
}
MergedDescriptorDatabase::MergedDescriptorDatabase(
const std::vector<DescriptorDatabase*>& sources)
- : sources_(sources) {}
+ : sources_(sources) {}
MergedDescriptorDatabase::~MergedDescriptorDatabase() {}
bool MergedDescriptorDatabase::FindFileByName(const std::string& filename,
@@ -500,8 +499,8 @@
const std::string& containing_type, int field_number,
FileDescriptorProto* output) {
for (int i = 0; i < sources_.size(); i++) {
- if (sources_[i]->FindFileContainingExtension(
- containing_type, field_number, output)) {
+ if (sources_[i]->FindFileContainingExtension(containing_type, field_number,
+ output)) {
// The symbol was found in source i. However, if one of the previous
// sources defines a file with the same name (which presumably doesn't
// contain the symbol, since it wasn't found in that source), then we
diff --git a/src/google/protobuf/descriptor_database.h b/src/google/protobuf/descriptor_database.h
index 5ac0383..8fc8ae3 100644
--- a/src/google/protobuf/descriptor_database.h
+++ b/src/google/protobuf/descriptor_database.h
@@ -183,13 +183,10 @@
public:
// Helpers to recursively add particular descriptors and all their contents
// to the index.
- bool AddFile(const FileDescriptorProto& file,
- Value value);
+ bool AddFile(const FileDescriptorProto& file, Value value);
bool AddSymbol(const std::string& name, Value value);
- bool AddNestedExtensions(const DescriptorProto& message_type,
- Value value);
- bool AddExtension(const FieldDescriptorProto& field,
- Value value);
+ bool AddNestedExtensions(const DescriptorProto& message_type, Value value);
+ bool AddExtension(const FieldDescriptorProto& field, Value value);
Value FindFile(const std::string& filename);
Value FindSymbol(const std::string& name);
@@ -270,14 +267,12 @@
bool ValidateSymbolName(const std::string& name);
};
-
DescriptorIndex<const FileDescriptorProto*> index_;
std::vector<const FileDescriptorProto*> files_to_delete_;
// If file is non-NULL, copy it into *output and return true, otherwise
// return false.
- bool MaybeCopy(const FileDescriptorProto* file,
- FileDescriptorProto* output);
+ bool MaybeCopy(const FileDescriptorProto* file, FileDescriptorProto* output);
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SimpleDescriptorDatabase);
};
diff --git a/src/google/protobuf/descriptor_database_unittest.cc b/src/google/protobuf/descriptor_database_unittest.cc
index 423a700..58ccf4e 100644
--- a/src/google/protobuf/descriptor_database_unittest.cc
+++ b/src/google/protobuf/descriptor_database_unittest.cc
@@ -64,8 +64,7 @@
for (int i = 0; i < proto.message_type_size(); i++) {
if (proto.message_type(i).name() == type_name) return;
}
- ADD_FAILURE() << "\"" << proto.name()
- << "\" did not contain expected type \""
+ ADD_FAILURE() << "\"" << proto.name() << "\" did not contain expected type \""
<< type_name << "\".";
}
@@ -100,9 +99,7 @@
virtual ~SimpleDescriptorDatabaseTestCase() {}
- virtual DescriptorDatabase* GetDatabase() {
- return &database_;
- }
+ virtual DescriptorDatabase* GetDatabase() { return &database_; }
virtual bool AddToDatabase(const FileDescriptorProto& file) {
return database_.Add(file);
}
@@ -120,9 +117,7 @@
virtual ~EncodedDescriptorDatabaseTestCase() {}
- virtual DescriptorDatabase* GetDatabase() {
- return &database_;
- }
+ virtual DescriptorDatabase* GetDatabase() { return &database_; }
virtual bool AddToDatabase(const FileDescriptorProto& file) {
std::string data;
file.SerializeToString(&data);
@@ -143,9 +138,7 @@
DescriptorPoolDatabaseTestCase() : database_(pool_) {}
virtual ~DescriptorPoolDatabaseTestCase() {}
- virtual DescriptorDatabase* GetDatabase() {
- return &database_;
- }
+ virtual DescriptorDatabase* GetDatabase() { return &database_; }
virtual bool AddToDatabase(const FileDescriptorProto& file) {
return pool_.BuildFile(file);
}
@@ -183,11 +176,11 @@
TEST_P(DescriptorDatabaseTest, FindFileByName) {
AddToDatabase(
- "name: \"foo.proto\" "
- "message_type { name:\"Foo\" }");
+ "name: \"foo.proto\" "
+ "message_type { name:\"Foo\" }");
AddToDatabase(
- "name: \"bar.proto\" "
- "message_type { name:\"Bar\" }");
+ "name: \"bar.proto\" "
+ "message_type { name:\"Bar\" }");
{
FileDescriptorProto file;
@@ -212,27 +205,26 @@
TEST_P(DescriptorDatabaseTest, FindFileContainingSymbol) {
AddToDatabase(
- "name: \"foo.proto\" "
- "message_type { "
- " name: \"Foo\" "
- " field { name:\"qux\" }"
- " nested_type { name: \"Grault\" } "
- " enum_type { name: \"Garply\" } "
- "} "
- "enum_type { "
- " name: \"Waldo\" "
- " value { name:\"FRED\" } "
- "} "
- "extension { name: \"plugh\" } "
- "service { "
- " name: \"Xyzzy\" "
- " method { name: \"Thud\" } "
- "}"
- );
+ "name: \"foo.proto\" "
+ "message_type { "
+ " name: \"Foo\" "
+ " field { name:\"qux\" }"
+ " nested_type { name: \"Grault\" } "
+ " enum_type { name: \"Garply\" } "
+ "} "
+ "enum_type { "
+ " name: \"Waldo\" "
+ " value { name:\"FRED\" } "
+ "} "
+ "extension { name: \"plugh\" } "
+ "service { "
+ " name: \"Xyzzy\" "
+ " method { name: \"Thud\" } "
+ "}");
AddToDatabase(
- "name: \"bar.proto\" "
- "package: \"corge\" "
- "message_type { name: \"Bar\" }");
+ "name: \"bar.proto\" "
+ "package: \"corge\" "
+ "message_type { name: \"Bar\" }");
{
FileDescriptorProto file;
@@ -247,8 +239,8 @@
EXPECT_EQ("foo.proto", file.name());
// Non-existent field under a valid top level symbol can also be
// found.
- EXPECT_TRUE(database_->FindFileContainingSymbol("Foo.none_field.none",
- &file));
+ EXPECT_TRUE(
+ database_->FindFileContainingSymbol("Foo.none_field.none", &file));
}
{
@@ -322,24 +314,25 @@
TEST_P(DescriptorDatabaseTest, FindFileContainingExtension) {
AddToDatabase(
- "name: \"foo.proto\" "
- "message_type { "
- " name: \"Foo\" "
- " extension_range { start: 1 end: 1000 } "
- " extension { name:\"qux\" label:LABEL_OPTIONAL type:TYPE_INT32 number:5 "
- " extendee: \".Foo\" }"
- "}");
+ "name: \"foo.proto\" "
+ "message_type { "
+ " name: \"Foo\" "
+ " extension_range { start: 1 end: 1000 } "
+ " extension { name:\"qux\" label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "number:5 "
+ " extendee: \".Foo\" }"
+ "}");
AddToDatabase(
- "name: \"bar.proto\" "
- "package: \"corge\" "
- "dependency: \"foo.proto\" "
- "message_type { "
- " name: \"Bar\" "
- " extension_range { start: 1 end: 1000 } "
- "} "
- "extension { name:\"grault\" extendee: \".Foo\" number:32 } "
- "extension { name:\"garply\" extendee: \".corge.Bar\" number:70 } "
- "extension { name:\"waldo\" extendee: \"Bar\" number:56 } ");
+ "name: \"bar.proto\" "
+ "package: \"corge\" "
+ "dependency: \"foo.proto\" "
+ "message_type { "
+ " name: \"Bar\" "
+ " extension_range { start: 1 end: 1000 } "
+ "} "
+ "extension { name:\"grault\" extendee: \".Foo\" number:32 } "
+ "extension { name:\"garply\" extendee: \".corge.Bar\" number:70 } "
+ "extension { name:\"waldo\" extendee: \"Bar\" number:56 } ");
{
FileDescriptorProto file;
@@ -391,24 +384,25 @@
TEST_P(DescriptorDatabaseTest, FindAllExtensionNumbers) {
AddToDatabase(
- "name: \"foo.proto\" "
- "message_type { "
- " name: \"Foo\" "
- " extension_range { start: 1 end: 1000 } "
- " extension { name:\"qux\" label:LABEL_OPTIONAL type:TYPE_INT32 number:5 "
- " extendee: \".Foo\" }"
- "}");
+ "name: \"foo.proto\" "
+ "message_type { "
+ " name: \"Foo\" "
+ " extension_range { start: 1 end: 1000 } "
+ " extension { name:\"qux\" label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "number:5 "
+ " extendee: \".Foo\" }"
+ "}");
AddToDatabase(
- "name: \"bar.proto\" "
- "package: \"corge\" "
- "dependency: \"foo.proto\" "
- "message_type { "
- " name: \"Bar\" "
- " extension_range { start: 1 end: 1000 } "
- "} "
- "extension { name:\"grault\" extendee: \".Foo\" number:32 } "
- "extension { name:\"garply\" extendee: \".corge.Bar\" number:70 } "
- "extension { name:\"waldo\" extendee: \"Bar\" number:56 } ");
+ "name: \"bar.proto\" "
+ "package: \"corge\" "
+ "dependency: \"foo.proto\" "
+ "message_type { "
+ " name: \"Bar\" "
+ " extension_range { start: 1 end: 1000 } "
+ "} "
+ "extension { name:\"grault\" extendee: \".Foo\" number:32 } "
+ "extension { name:\"garply\" extendee: \".corge.Bar\" number:70 } "
+ "extension { name:\"waldo\" extendee: \"Bar\" number:56 } ");
{
std::vector<int> numbers;
@@ -442,47 +436,49 @@
TEST_P(DescriptorDatabaseTest, ConflictingFileError) {
AddToDatabase(
- "name: \"foo.proto\" "
- "message_type { "
- " name: \"Foo\" "
- "}");
+ "name: \"foo.proto\" "
+ "message_type { "
+ " name: \"Foo\" "
+ "}");
AddToDatabaseWithError(
- "name: \"foo.proto\" "
- "message_type { "
- " name: \"Bar\" "
- "}");
+ "name: \"foo.proto\" "
+ "message_type { "
+ " name: \"Bar\" "
+ "}");
}
TEST_P(DescriptorDatabaseTest, ConflictingTypeError) {
AddToDatabase(
- "name: \"foo.proto\" "
- "message_type { "
- " name: \"Foo\" "
- "}");
+ "name: \"foo.proto\" "
+ "message_type { "
+ " name: \"Foo\" "
+ "}");
AddToDatabaseWithError(
- "name: \"bar.proto\" "
- "message_type { "
- " name: \"Foo\" "
- "}");
+ "name: \"bar.proto\" "
+ "message_type { "
+ " name: \"Foo\" "
+ "}");
}
TEST_P(DescriptorDatabaseTest, ConflictingExtensionError) {
AddToDatabase(
- "name: \"foo.proto\" "
- "extension { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:5 "
- " extendee: \".Foo\" }");
+ "name: \"foo.proto\" "
+ "extension { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:5 "
+ " extendee: \".Foo\" }");
AddToDatabaseWithError(
- "name: \"bar.proto\" "
- "extension { name:\"bar\" label:LABEL_OPTIONAL type:TYPE_INT32 number:5 "
- " extendee: \".Foo\" }");
+ "name: \"bar.proto\" "
+ "extension { name:\"bar\" label:LABEL_OPTIONAL type:TYPE_INT32 number:5 "
+ " extendee: \".Foo\" }");
}
-INSTANTIATE_TEST_CASE_P(Simple, DescriptorDatabaseTest,
+INSTANTIATE_TEST_CASE_P(
+ Simple, DescriptorDatabaseTest,
testing::Values(&SimpleDescriptorDatabaseTestCase::New));
-INSTANTIATE_TEST_CASE_P(MemoryConserving, DescriptorDatabaseTest,
+INSTANTIATE_TEST_CASE_P(
+ MemoryConserving, DescriptorDatabaseTest,
testing::Values(&EncodedDescriptorDatabaseTestCase::New));
INSTANTIATE_TEST_CASE_P(Pool, DescriptorDatabaseTest,
- testing::Values(&DescriptorPoolDatabaseTestCase::New));
+ testing::Values(&DescriptorPoolDatabaseTestCase::New));
#endif // GTEST_HAS_PARAM_TEST
@@ -540,36 +536,40 @@
class MergedDescriptorDatabaseTest : public testing::Test {
protected:
MergedDescriptorDatabaseTest()
- : forward_merged_(&database1_, &database2_),
- reverse_merged_(&database2_, &database1_) {}
+ : forward_merged_(&database1_, &database2_),
+ reverse_merged_(&database2_, &database1_) {}
virtual void SetUp() {
- AddToDatabase(&database1_,
- "name: \"foo.proto\" "
- "message_type { name:\"Foo\" extension_range { start: 1 end: 100 } } "
- "extension { name:\"foo_ext\" extendee: \".Foo\" number:3 "
- " label:LABEL_OPTIONAL type:TYPE_INT32 } ");
- AddToDatabase(&database2_,
- "name: \"bar.proto\" "
- "message_type { name:\"Bar\" extension_range { start: 1 end: 100 } } "
- "extension { name:\"bar_ext\" extendee: \".Bar\" number:5 "
- " label:LABEL_OPTIONAL type:TYPE_INT32 } ");
+ AddToDatabase(
+ &database1_,
+ "name: \"foo.proto\" "
+ "message_type { name:\"Foo\" extension_range { start: 1 end: 100 } } "
+ "extension { name:\"foo_ext\" extendee: \".Foo\" number:3 "
+ " label:LABEL_OPTIONAL type:TYPE_INT32 } ");
+ AddToDatabase(
+ &database2_,
+ "name: \"bar.proto\" "
+ "message_type { name:\"Bar\" extension_range { start: 1 end: 100 } } "
+ "extension { name:\"bar_ext\" extendee: \".Bar\" number:5 "
+ " label:LABEL_OPTIONAL type:TYPE_INT32 } ");
// baz.proto exists in both pools, with different definitions.
- AddToDatabase(&database1_,
- "name: \"baz.proto\" "
- "message_type { name:\"Baz\" extension_range { start: 1 end: 100 } } "
- "message_type { name:\"FromPool1\" } "
- "extension { name:\"baz_ext\" extendee: \".Baz\" number:12 "
- " label:LABEL_OPTIONAL type:TYPE_INT32 } "
- "extension { name:\"database1_only_ext\" extendee: \".Baz\" number:13 "
- " label:LABEL_OPTIONAL type:TYPE_INT32 } ");
- AddToDatabase(&database2_,
- "name: \"baz.proto\" "
- "message_type { name:\"Baz\" extension_range { start: 1 end: 100 } } "
- "message_type { name:\"FromPool2\" } "
- "extension { name:\"baz_ext\" extendee: \".Baz\" number:12 "
- " label:LABEL_OPTIONAL type:TYPE_INT32 } ");
+ AddToDatabase(
+ &database1_,
+ "name: \"baz.proto\" "
+ "message_type { name:\"Baz\" extension_range { start: 1 end: 100 } } "
+ "message_type { name:\"FromPool1\" } "
+ "extension { name:\"baz_ext\" extendee: \".Baz\" number:12 "
+ " label:LABEL_OPTIONAL type:TYPE_INT32 } "
+ "extension { name:\"database1_only_ext\" extendee: \".Baz\" number:13 "
+ " label:LABEL_OPTIONAL type:TYPE_INT32 } ");
+ AddToDatabase(
+ &database2_,
+ "name: \"baz.proto\" "
+ "message_type { name:\"Baz\" extension_range { start: 1 end: 100 } } "
+ "message_type { name:\"FromPool2\" } "
+ "extension { name:\"baz_ext\" extendee: \".Baz\" number:12 "
+ " label:LABEL_OPTIONAL type:TYPE_INT32 } ");
}
SimpleDescriptorDatabase database1_;
@@ -663,8 +663,7 @@
{
// Can't find non-existent symbol.
FileDescriptorProto file;
- EXPECT_FALSE(
- forward_merged_.FindFileContainingSymbol("NoSuchType", &file));
+ EXPECT_FALSE(forward_merged_.FindFileContainingSymbol("NoSuchType", &file));
}
}
@@ -672,8 +671,7 @@
{
// Can find file that is only in database1_.
FileDescriptorProto file;
- EXPECT_TRUE(
- forward_merged_.FindFileContainingExtension("Foo", 3, &file));
+ EXPECT_TRUE(forward_merged_.FindFileContainingExtension("Foo", 3, &file));
EXPECT_EQ("foo.proto", file.name());
ExpectContainsType(file, "Foo");
}
@@ -681,8 +679,7 @@
{
// Can find file that is only in database2_.
FileDescriptorProto file;
- EXPECT_TRUE(
- forward_merged_.FindFileContainingExtension("Bar", 5, &file));
+ EXPECT_TRUE(forward_merged_.FindFileContainingExtension("Bar", 5, &file));
EXPECT_EQ("bar.proto", file.name());
ExpectContainsType(file, "Bar");
}
@@ -690,8 +687,7 @@
{
// In forward_merged_, database1_'s baz.proto takes precedence.
FileDescriptorProto file;
- EXPECT_TRUE(
- forward_merged_.FindFileContainingExtension("Baz", 12, &file));
+ EXPECT_TRUE(forward_merged_.FindFileContainingExtension("Baz", 12, &file));
EXPECT_EQ("baz.proto", file.name());
ExpectContainsType(file, "FromPool1");
}
@@ -699,8 +695,7 @@
{
// In reverse_merged_, database2_'s baz.proto takes precedence.
FileDescriptorProto file;
- EXPECT_TRUE(
- reverse_merged_.FindFileContainingExtension("Baz", 12, &file));
+ EXPECT_TRUE(reverse_merged_.FindFileContainingExtension("Baz", 12, &file));
EXPECT_EQ("baz.proto", file.name());
ExpectContainsType(file, "FromPool2");
}
@@ -716,8 +711,7 @@
{
// Can't find non-existent extension.
FileDescriptorProto file;
- EXPECT_FALSE(
- forward_merged_.FindFileContainingExtension("Foo", 6, &file));
+ EXPECT_FALSE(forward_merged_.FindFileContainingExtension("Foo", 6, &file));
}
}
diff --git a/src/google/protobuf/descriptor_unittest.cc b/src/google/protobuf/descriptor_unittest.cc
index e93d01b..f87947f 100644
--- a/src/google/protobuf/descriptor_unittest.cc
+++ b/src/google/protobuf/descriptor_unittest.cc
@@ -208,21 +208,43 @@
const std::string& message) {
const char* location_name = NULL;
switch (location) {
- case NAME : location_name = "NAME" ; break;
- case NUMBER : location_name = "NUMBER" ; break;
- case TYPE : location_name = "TYPE" ; break;
- case EXTENDEE : location_name = "EXTENDEE" ; break;
- case DEFAULT_VALUE: location_name = "DEFAULT_VALUE"; break;
- case OPTION_NAME : location_name = "OPTION_NAME" ; break;
- case OPTION_VALUE : location_name = "OPTION_VALUE" ; break;
- case INPUT_TYPE : location_name = "INPUT_TYPE" ; break;
- case OUTPUT_TYPE : location_name = "OUTPUT_TYPE" ; break;
- case OTHER : location_name = "OTHER" ; break;
+ case NAME:
+ location_name = "NAME";
+ break;
+ case NUMBER:
+ location_name = "NUMBER";
+ break;
+ case TYPE:
+ location_name = "TYPE";
+ break;
+ case EXTENDEE:
+ location_name = "EXTENDEE";
+ break;
+ case DEFAULT_VALUE:
+ location_name = "DEFAULT_VALUE";
+ break;
+ case OPTION_NAME:
+ location_name = "OPTION_NAME";
+ break;
+ case OPTION_VALUE:
+ location_name = "OPTION_VALUE";
+ break;
+ case INPUT_TYPE:
+ location_name = "INPUT_TYPE";
+ break;
+ case OUTPUT_TYPE:
+ location_name = "OUTPUT_TYPE";
+ break;
+ case IMPORT:
+ location_name = "IMPORT";
+ break;
+ case OTHER:
+ location_name = "OTHER";
+ break;
}
- strings::SubstituteAndAppend(
- &text_, "$0: $1: $2: $3\n",
- filename, element_name, location_name, message);
+ strings::SubstituteAndAppend(&text_, "$0: $1: $2: $3\n", filename,
+ element_name, location_name, message);
}
// implements ErrorCollector ---------------------------------------
@@ -231,21 +253,43 @@
const std::string& message) {
const char* location_name = NULL;
switch (location) {
- case NAME : location_name = "NAME" ; break;
- case NUMBER : location_name = "NUMBER" ; break;
- case TYPE : location_name = "TYPE" ; break;
- case EXTENDEE : location_name = "EXTENDEE" ; break;
- case DEFAULT_VALUE: location_name = "DEFAULT_VALUE"; break;
- case OPTION_NAME : location_name = "OPTION_NAME" ; break;
- case OPTION_VALUE : location_name = "OPTION_VALUE" ; break;
- case INPUT_TYPE : location_name = "INPUT_TYPE" ; break;
- case OUTPUT_TYPE : location_name = "OUTPUT_TYPE" ; break;
- case OTHER : location_name = "OTHER" ; break;
+ case NAME:
+ location_name = "NAME";
+ break;
+ case NUMBER:
+ location_name = "NUMBER";
+ break;
+ case TYPE:
+ location_name = "TYPE";
+ break;
+ case EXTENDEE:
+ location_name = "EXTENDEE";
+ break;
+ case DEFAULT_VALUE:
+ location_name = "DEFAULT_VALUE";
+ break;
+ case OPTION_NAME:
+ location_name = "OPTION_NAME";
+ break;
+ case OPTION_VALUE:
+ location_name = "OPTION_VALUE";
+ break;
+ case INPUT_TYPE:
+ location_name = "INPUT_TYPE";
+ break;
+ case OUTPUT_TYPE:
+ location_name = "OUTPUT_TYPE";
+ break;
+ case IMPORT:
+ location_name = "IMPORT";
+ break;
+ case OTHER:
+ location_name = "OTHER";
+ break;
}
- strings::SubstituteAndAppend(
- &warning_text_, "$0: $1: $2: $3\n",
- filename, element_name, location_name, message);
+ strings::SubstituteAndAppend(&warning_text_, "$0: $1: $2: $3\n", filename,
+ element_name, location_name, message);
}
};
@@ -336,17 +380,17 @@
const FileDescriptor* bar_file_;
const FileDescriptor* baz_file_;
- const Descriptor* foo_message_;
- const EnumDescriptor* foo_enum_;
+ const Descriptor* foo_message_;
+ const EnumDescriptor* foo_enum_;
const EnumValueDescriptor* foo_enum_value_;
- const ServiceDescriptor* foo_service_;
- const FieldDescriptor* foo_extension_;
+ const ServiceDescriptor* foo_service_;
+ const FieldDescriptor* foo_extension_;
- const Descriptor* bar_message_;
- const EnumDescriptor* bar_enum_;
+ const Descriptor* bar_message_;
+ const EnumDescriptor* bar_enum_;
const EnumValueDescriptor* bar_enum_value_;
- const ServiceDescriptor* bar_service_;
- const FieldDescriptor* bar_extension_;
+ const ServiceDescriptor* bar_service_;
+ const FieldDescriptor* bar_extension_;
};
TEST_F(FileDescriptorTest, Name) {
@@ -622,35 +666,28 @@
AddEmptyEnum(&foo_file, "TestEnum");
DescriptorProto* message = AddMessage(&foo_file, "TestMessage");
- AddField(message, "foo", 1,
- FieldDescriptorProto::LABEL_REQUIRED,
+ AddField(message, "foo", 1, FieldDescriptorProto::LABEL_REQUIRED,
FieldDescriptorProto::TYPE_STRING);
- AddField(message, "bar", 6,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(message, "bar", 6, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_ENUM)
- ->set_type_name("TestEnum");
- AddField(message, "baz", 500000000,
- FieldDescriptorProto::LABEL_REPEATED,
+ ->set_type_name("TestEnum");
+ AddField(message, "baz", 500000000, FieldDescriptorProto::LABEL_REPEATED,
FieldDescriptorProto::TYPE_MESSAGE)
- ->set_type_name("TestForeign");
- AddField(message, "qux", 15,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ ->set_type_name("TestForeign");
+ AddField(message, "qux", 15, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_GROUP)
- ->set_type_name("TestForeign");
+ ->set_type_name("TestForeign");
FileDescriptorProto bar_file;
bar_file.set_name("bar.proto");
bar_file.set_package("corge.grault");
DescriptorProto* message2 = AddMessage(&bar_file, "TestMessage2");
- AddField(message2, "foo", 1,
- FieldDescriptorProto::LABEL_REQUIRED,
+ AddField(message2, "foo", 1, FieldDescriptorProto::LABEL_REQUIRED,
FieldDescriptorProto::TYPE_STRING);
- AddField(message2, "bar", 2,
- FieldDescriptorProto::LABEL_REQUIRED,
+ AddField(message2, "bar", 2, FieldDescriptorProto::LABEL_REQUIRED,
FieldDescriptorProto::TYPE_STRING);
- AddField(message2, "quux", 6,
- FieldDescriptorProto::LABEL_REQUIRED,
+ AddField(message2, "quux", 6, FieldDescriptorProto::LABEL_REQUIRED,
FieldDescriptorProto::TYPE_STRING);
FileDescriptorProto map_file;
@@ -658,11 +695,9 @@
DescriptorProto* message3 = AddMessage(&map_file, "TestMessage3");
DescriptorProto* entry = AddNestedMessage(message3, "MapInt32Int32Entry");
- AddField(entry, "key", 1,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(entry, "key", 1, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
- AddField(entry, "value", 2,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(entry, "value", 2, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
entry->mutable_options()->set_map_entry(true);
@@ -675,23 +710,17 @@
json_file.set_name("json.proto");
json_file.set_syntax("proto3");
DescriptorProto* message4 = AddMessage(&json_file, "TestMessage4");
- AddField(message4, "field_name1", 1,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(message4, "field_name1", 1, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
- AddField(message4, "fieldName2", 2,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(message4, "fieldName2", 2, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
- AddField(message4, "FieldName3", 3,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(message4, "FieldName3", 3, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
- AddField(message4, "_field_name4", 4,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(message4, "_field_name4", 4, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
- AddField(message4, "FIELD_NAME5", 5,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(message4, "FIELD_NAME5", 5, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
- AddField(message4, "field_name6", 6,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(message4, "field_name6", 6, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32)
->set_json_name("@type");
@@ -725,15 +754,15 @@
message2_ = bar_file_->message_type(0);
ASSERT_EQ(3, message2_->field_count());
- foo2_ = message2_->field(0);
- bar2_ = message2_->field(1);
+ foo2_ = message2_->field(0);
+ bar2_ = message2_->field(1);
quux2_ = message2_->field(2);
ASSERT_EQ(1, map_file_->message_type_count());
message3_ = map_file_->message_type(0);
ASSERT_EQ(1, message3_->field_count());
- map_ = message3_->field(0);
+ map_ = message3_->field(0);
ASSERT_EQ(1, json_file_->message_type_count());
message4_ = json_file_->message_type(0);
@@ -806,8 +835,8 @@
EXPECT_TRUE(message_->FindFieldByName("no_such_field") == NULL);
EXPECT_TRUE(message_->FindFieldByName("quux") == NULL);
- EXPECT_EQ(foo2_ , message2_->FindFieldByName("foo" ));
- EXPECT_EQ(bar2_ , message2_->FindFieldByName("bar" ));
+ EXPECT_EQ(foo2_, message2_->FindFieldByName("foo"));
+ EXPECT_EQ(bar2_, message2_->FindFieldByName("bar"));
EXPECT_EQ(quux2_, message2_->FindFieldByName("quux"));
EXPECT_TRUE(message2_->FindFieldByName("baz") == NULL);
EXPECT_TRUE(message2_->FindFieldByName("qux") == NULL);
@@ -821,8 +850,8 @@
EXPECT_TRUE(message_->FindFieldByNumber(837592) == NULL);
EXPECT_TRUE(message_->FindFieldByNumber(2) == NULL);
- EXPECT_EQ(foo2_ , message2_->FindFieldByNumber(1));
- EXPECT_EQ(bar2_ , message2_->FindFieldByNumber(2));
+ EXPECT_EQ(foo2_, message2_->FindFieldByNumber(1));
+ EXPECT_EQ(bar2_, message2_->FindFieldByNumber(2));
EXPECT_EQ(quux2_, message2_->FindFieldByNumber(6));
EXPECT_TRUE(message2_->FindFieldByNumber(15) == NULL);
EXPECT_TRUE(message2_->FindFieldByNumber(500000000) == NULL);
@@ -904,17 +933,17 @@
}
TEST_F(DescriptorTest, FieldNumber) {
- EXPECT_EQ( 1, foo_->number());
- EXPECT_EQ( 6, bar_->number());
+ EXPECT_EQ(1, foo_->number());
+ EXPECT_EQ(6, bar_->number());
EXPECT_EQ(500000000, baz_->number());
- EXPECT_EQ( 15, qux_->number());
+ EXPECT_EQ(15, qux_->number());
}
TEST_F(DescriptorTest, FieldType) {
- EXPECT_EQ(FieldDescriptor::TYPE_STRING , foo_->type());
- EXPECT_EQ(FieldDescriptor::TYPE_ENUM , bar_->type());
+ EXPECT_EQ(FieldDescriptor::TYPE_STRING, foo_->type());
+ EXPECT_EQ(FieldDescriptor::TYPE_ENUM, bar_->type());
EXPECT_EQ(FieldDescriptor::TYPE_MESSAGE, baz_->type());
- EXPECT_EQ(FieldDescriptor::TYPE_GROUP , qux_->type());
+ EXPECT_EQ(FieldDescriptor::TYPE_GROUP, qux_->type());
}
TEST_F(DescriptorTest, FieldLabel) {
@@ -923,17 +952,17 @@
EXPECT_EQ(FieldDescriptor::LABEL_REPEATED, baz_->label());
EXPECT_EQ(FieldDescriptor::LABEL_OPTIONAL, qux_->label());
- EXPECT_TRUE (foo_->is_required());
+ EXPECT_TRUE(foo_->is_required());
EXPECT_FALSE(foo_->is_optional());
EXPECT_FALSE(foo_->is_repeated());
EXPECT_FALSE(bar_->is_required());
- EXPECT_TRUE (bar_->is_optional());
+ EXPECT_TRUE(bar_->is_optional());
EXPECT_FALSE(bar_->is_repeated());
EXPECT_FALSE(baz_->is_required());
EXPECT_FALSE(baz_->is_optional());
- EXPECT_TRUE (baz_->is_repeated());
+ EXPECT_TRUE(baz_->is_repeated());
}
TEST_F(DescriptorTest, IsMap) {
@@ -955,8 +984,8 @@
EXPECT_EQ(message_, baz_->containing_type());
EXPECT_EQ(message_, qux_->containing_type());
- EXPECT_EQ(message2_, foo2_ ->containing_type());
- EXPECT_EQ(message2_, bar2_ ->containing_type());
+ EXPECT_EQ(message2_, foo2_->containing_type());
+ EXPECT_EQ(message2_, bar2_->containing_type());
EXPECT_EQ(message2_, quux2_->containing_type());
}
@@ -1005,21 +1034,17 @@
oneof_message->add_oneof_decl()->set_name("foo");
oneof_message->add_oneof_decl()->set_name("bar");
- AddField(oneof_message, "a", 1,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(oneof_message, "a", 1, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
- AddField(oneof_message, "b", 2,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(oneof_message, "b", 2, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_STRING);
oneof_message->mutable_field(1)->set_oneof_index(0);
- AddField(oneof_message, "c", 3,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(oneof_message, "c", 3, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_MESSAGE);
oneof_message->mutable_field(2)->set_oneof_index(0);
oneof_message->mutable_field(2)->set_type_name("TestOneof");
- AddField(oneof_message, "d", 4,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(oneof_message, "d", 4, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_FLOAT);
oneof_message->mutable_field(3)->set_oneof_index(1);
@@ -1086,14 +1111,11 @@
AddExtensionRange(AddMessage(&file, "ExtendableMessage"), 1, 1000);
DescriptorProto* message = AddMessage(&file, "TestMessage");
- AddField(message, "foo_foo", 1,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(message, "foo_foo", 1, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
- AddField(message, "FooBar", 2,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(message, "FooBar", 2, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
- AddField(message, "fooBaz", 3,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(message, "fooBaz", 3, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
AddField(message, "fooFoo", 4, // Camel-case conflict with foo_foo.
FieldDescriptorProto::LABEL_OPTIONAL,
@@ -1151,22 +1173,22 @@
TEST_F(StylizedFieldNamesTest, LowercaseName) {
EXPECT_EQ("foo_foo", message_->field(0)->lowercase_name());
- EXPECT_EQ("foobar" , message_->field(1)->lowercase_name());
- EXPECT_EQ("foobaz" , message_->field(2)->lowercase_name());
- EXPECT_EQ("foofoo" , message_->field(3)->lowercase_name());
- EXPECT_EQ("foobar" , message_->field(4)->lowercase_name());
+ EXPECT_EQ("foobar", message_->field(1)->lowercase_name());
+ EXPECT_EQ("foobaz", message_->field(2)->lowercase_name());
+ EXPECT_EQ("foofoo", message_->field(3)->lowercase_name());
+ EXPECT_EQ("foobar", message_->field(4)->lowercase_name());
EXPECT_EQ("bar_foo", message_->extension(0)->lowercase_name());
- EXPECT_EQ("barbar" , message_->extension(1)->lowercase_name());
- EXPECT_EQ("barbaz" , message_->extension(2)->lowercase_name());
- EXPECT_EQ("barfoo" , message_->extension(3)->lowercase_name());
- EXPECT_EQ("barbar" , message_->extension(4)->lowercase_name());
+ EXPECT_EQ("barbar", message_->extension(1)->lowercase_name());
+ EXPECT_EQ("barbaz", message_->extension(2)->lowercase_name());
+ EXPECT_EQ("barfoo", message_->extension(3)->lowercase_name());
+ EXPECT_EQ("barbar", message_->extension(4)->lowercase_name());
EXPECT_EQ("baz_foo", file_->extension(0)->lowercase_name());
- EXPECT_EQ("bazbar" , file_->extension(1)->lowercase_name());
- EXPECT_EQ("bazbaz" , file_->extension(2)->lowercase_name());
- EXPECT_EQ("bazfoo" , file_->extension(3)->lowercase_name());
- EXPECT_EQ("bazbar" , file_->extension(4)->lowercase_name());
+ EXPECT_EQ("bazbar", file_->extension(1)->lowercase_name());
+ EXPECT_EQ("bazbaz", file_->extension(2)->lowercase_name());
+ EXPECT_EQ("bazfoo", file_->extension(3)->lowercase_name());
+ EXPECT_EQ("bazbar", file_->extension(4)->lowercase_name());
}
TEST_F(StylizedFieldNamesTest, CamelcaseName) {
@@ -1190,12 +1212,9 @@
}
TEST_F(StylizedFieldNamesTest, FindByLowercaseName) {
- EXPECT_EQ(message_->field(0),
- message_->FindFieldByLowercaseName("foo_foo"));
- EXPECT_EQ(message_->field(1),
- message_->FindFieldByLowercaseName("foobar"));
- EXPECT_EQ(message_->field(2),
- message_->FindFieldByLowercaseName("foobaz"));
+ EXPECT_EQ(message_->field(0), message_->FindFieldByLowercaseName("foo_foo"));
+ EXPECT_EQ(message_->field(1), message_->FindFieldByLowercaseName("foobar"));
+ EXPECT_EQ(message_->field(2), message_->FindFieldByLowercaseName("foobaz"));
EXPECT_TRUE(message_->FindFieldByLowercaseName("FooBar") == NULL);
EXPECT_TRUE(message_->FindFieldByLowercaseName("fooBaz") == NULL);
EXPECT_TRUE(message_->FindFieldByLowercaseName("bar_foo") == NULL);
@@ -1214,22 +1233,17 @@
EXPECT_EQ(file_->extension(0),
file_->FindExtensionByLowercaseName("baz_foo"));
- EXPECT_EQ(file_->extension(1),
- file_->FindExtensionByLowercaseName("bazbar"));
- EXPECT_EQ(file_->extension(2),
- file_->FindExtensionByLowercaseName("bazbaz"));
+ EXPECT_EQ(file_->extension(1), file_->FindExtensionByLowercaseName("bazbar"));
+ EXPECT_EQ(file_->extension(2), file_->FindExtensionByLowercaseName("bazbaz"));
EXPECT_TRUE(file_->FindExtensionByLowercaseName("BazBar") == NULL);
EXPECT_TRUE(file_->FindExtensionByLowercaseName("bazBaz") == NULL);
EXPECT_TRUE(file_->FindExtensionByLowercaseName("nosuchfield") == NULL);
}
TEST_F(StylizedFieldNamesTest, FindByCamelcaseName) {
- EXPECT_EQ(message_->field(0),
- message_->FindFieldByCamelcaseName("fooFoo"));
- EXPECT_EQ(message_->field(1),
- message_->FindFieldByCamelcaseName("fooBar"));
- EXPECT_EQ(message_->field(2),
- message_->FindFieldByCamelcaseName("fooBaz"));
+ EXPECT_EQ(message_->field(0), message_->FindFieldByCamelcaseName("fooFoo"));
+ EXPECT_EQ(message_->field(1), message_->FindFieldByCamelcaseName("fooBar"));
+ EXPECT_EQ(message_->field(2), message_->FindFieldByCamelcaseName("fooBaz"));
EXPECT_TRUE(message_->FindFieldByCamelcaseName("foo_foo") == NULL);
EXPECT_TRUE(message_->FindFieldByCamelcaseName("FooBar") == NULL);
EXPECT_TRUE(message_->FindFieldByCamelcaseName("barFoo") == NULL);
@@ -1246,12 +1260,9 @@
EXPECT_TRUE(message_->FindExtensionByCamelcaseName("fooFoo") == NULL);
EXPECT_TRUE(message_->FindExtensionByCamelcaseName("nosuchfield") == NULL);
- EXPECT_EQ(file_->extension(0),
- file_->FindExtensionByCamelcaseName("bazFoo"));
- EXPECT_EQ(file_->extension(1),
- file_->FindExtensionByCamelcaseName("bazBar"));
- EXPECT_EQ(file_->extension(2),
- file_->FindExtensionByCamelcaseName("bazBaz"));
+ EXPECT_EQ(file_->extension(0), file_->FindExtensionByCamelcaseName("bazFoo"));
+ EXPECT_EQ(file_->extension(1), file_->FindExtensionByCamelcaseName("bazBar"));
+ EXPECT_EQ(file_->extension(2), file_->FindExtensionByCamelcaseName("bazBaz"));
EXPECT_TRUE(file_->FindExtensionByCamelcaseName("baz_foo") == NULL);
EXPECT_TRUE(file_->FindExtensionByCamelcaseName("BazBar") == NULL);
EXPECT_TRUE(file_->FindExtensionByCamelcaseName("nosuchfield") == NULL);
@@ -1358,24 +1369,24 @@
}
TEST_F(EnumDescriptorTest, FindValueByName) {
- EXPECT_EQ(foo_ , enum_ ->FindValueByName("FOO"));
- EXPECT_EQ(bar_ , enum_ ->FindValueByName("BAR"));
+ EXPECT_EQ(foo_, enum_->FindValueByName("FOO"));
+ EXPECT_EQ(bar_, enum_->FindValueByName("BAR"));
EXPECT_EQ(foo2_, enum2_->FindValueByName("FOO"));
EXPECT_EQ(baz2_, enum2_->FindValueByName("BAZ"));
- EXPECT_TRUE(enum_ ->FindValueByName("NO_SUCH_VALUE") == NULL);
- EXPECT_TRUE(enum_ ->FindValueByName("BAZ" ) == NULL);
- EXPECT_TRUE(enum2_->FindValueByName("BAR" ) == NULL);
+ EXPECT_TRUE(enum_->FindValueByName("NO_SUCH_VALUE") == NULL);
+ EXPECT_TRUE(enum_->FindValueByName("BAZ") == NULL);
+ EXPECT_TRUE(enum2_->FindValueByName("BAR") == NULL);
}
TEST_F(EnumDescriptorTest, FindValueByNumber) {
- EXPECT_EQ(foo_ , enum_ ->FindValueByNumber(1));
- EXPECT_EQ(bar_ , enum_ ->FindValueByNumber(2));
+ EXPECT_EQ(foo_, enum_->FindValueByNumber(1));
+ EXPECT_EQ(bar_, enum_->FindValueByNumber(2));
EXPECT_EQ(foo2_, enum2_->FindValueByNumber(1));
EXPECT_EQ(baz2_, enum2_->FindValueByNumber(3));
- EXPECT_TRUE(enum_ ->FindValueByNumber(416) == NULL);
- EXPECT_TRUE(enum_ ->FindValueByNumber(3) == NULL);
+ EXPECT_TRUE(enum_->FindValueByNumber(416) == NULL);
+ EXPECT_TRUE(enum_->FindValueByNumber(3) == NULL);
EXPECT_TRUE(enum2_->FindValueByNumber(2) == NULL);
}
@@ -1402,8 +1413,8 @@
}
TEST_F(EnumDescriptorTest, ValueType) {
- EXPECT_EQ(enum_ , foo_ ->type());
- EXPECT_EQ(enum_ , bar_ ->type());
+ EXPECT_EQ(enum_, foo_->type());
+ EXPECT_EQ(enum_, bar_->type());
EXPECT_EQ(enum2_, foo2_->type());
EXPECT_EQ(enum2_, baz2_->type());
}
@@ -1466,11 +1477,11 @@
ASSERT_TRUE(bar_file_ != NULL);
ASSERT_EQ(6, foo_file_->message_type_count());
- foo_request_ = foo_file_->message_type(0);
+ foo_request_ = foo_file_->message_type(0);
foo_response_ = foo_file_->message_type(1);
- bar_request_ = foo_file_->message_type(2);
+ bar_request_ = foo_file_->message_type(2);
bar_response_ = foo_file_->message_type(3);
- baz_request_ = foo_file_->message_type(4);
+ baz_request_ = foo_file_->message_type(4);
baz_response_ = foo_file_->message_type(5);
ASSERT_EQ(1, foo_file_->service_count());
@@ -1527,14 +1538,14 @@
}
TEST_F(ServiceDescriptorTest, FindMethodByName) {
- EXPECT_EQ(foo_ , service_ ->FindMethodByName("Foo"));
- EXPECT_EQ(bar_ , service_ ->FindMethodByName("Bar"));
+ EXPECT_EQ(foo_, service_->FindMethodByName("Foo"));
+ EXPECT_EQ(bar_, service_->FindMethodByName("Bar"));
EXPECT_EQ(foo2_, service2_->FindMethodByName("Foo"));
EXPECT_EQ(baz2_, service2_->FindMethodByName("Baz"));
- EXPECT_TRUE(service_ ->FindMethodByName("NoSuchMethod") == NULL);
- EXPECT_TRUE(service_ ->FindMethodByName("Baz" ) == NULL);
- EXPECT_TRUE(service2_->FindMethodByName("Bar" ) == NULL);
+ EXPECT_TRUE(service_->FindMethodByName("NoSuchMethod") == NULL);
+ EXPECT_TRUE(service_->FindMethodByName("Baz") == NULL);
+ EXPECT_TRUE(service2_->FindMethodByName("Bar") == NULL);
}
TEST_F(ServiceDescriptorTest, MethodName) {
@@ -1688,8 +1699,8 @@
};
TEST_F(NestedDescriptorTest, MessageName) {
- EXPECT_EQ("Foo", foo_ ->name());
- EXPECT_EQ("Bar", bar_ ->name());
+ EXPECT_EQ("Foo", foo_->name());
+ EXPECT_EQ("Bar", bar_->name());
EXPECT_EQ("Foo", foo2_->name());
EXPECT_EQ("Baz", baz2_->name());
@@ -1700,8 +1711,8 @@
}
TEST_F(NestedDescriptorTest, MessageContainingType) {
- EXPECT_EQ(message_ , foo_ ->containing_type());
- EXPECT_EQ(message_ , bar_ ->containing_type());
+ EXPECT_EQ(message_, foo_->containing_type());
+ EXPECT_EQ(message_, bar_->containing_type());
EXPECT_EQ(message2_, foo2_->containing_type());
EXPECT_EQ(message2_, baz2_->containing_type());
}
@@ -1720,34 +1731,34 @@
}
TEST_F(NestedDescriptorTest, FindNestedTypeByName) {
- EXPECT_EQ(foo_ , message_ ->FindNestedTypeByName("Foo"));
- EXPECT_EQ(bar_ , message_ ->FindNestedTypeByName("Bar"));
+ EXPECT_EQ(foo_, message_->FindNestedTypeByName("Foo"));
+ EXPECT_EQ(bar_, message_->FindNestedTypeByName("Bar"));
EXPECT_EQ(foo2_, message2_->FindNestedTypeByName("Foo"));
EXPECT_EQ(baz2_, message2_->FindNestedTypeByName("Baz"));
- EXPECT_TRUE(message_ ->FindNestedTypeByName("NoSuchType") == NULL);
- EXPECT_TRUE(message_ ->FindNestedTypeByName("Baz" ) == NULL);
- EXPECT_TRUE(message2_->FindNestedTypeByName("Bar" ) == NULL);
+ EXPECT_TRUE(message_->FindNestedTypeByName("NoSuchType") == NULL);
+ EXPECT_TRUE(message_->FindNestedTypeByName("Baz") == NULL);
+ EXPECT_TRUE(message2_->FindNestedTypeByName("Bar") == NULL);
EXPECT_TRUE(message_->FindNestedTypeByName("Qux") == NULL);
}
TEST_F(NestedDescriptorTest, EnumName) {
- EXPECT_EQ("Baz" , baz_ ->name());
- EXPECT_EQ("Qux" , qux_ ->name());
- EXPECT_EQ("Qux" , qux2_->name());
+ EXPECT_EQ("Baz", baz_->name());
+ EXPECT_EQ("Qux", qux_->name());
+ EXPECT_EQ("Qux", qux2_->name());
EXPECT_EQ("Quux", quux2_->name());
EXPECT_EQ("TestMessage.Baz", baz_->full_name());
EXPECT_EQ("TestMessage.Qux", qux_->full_name());
- EXPECT_EQ("corge.grault.TestMessage2.Qux" , qux2_ ->full_name());
+ EXPECT_EQ("corge.grault.TestMessage2.Qux", qux2_->full_name());
EXPECT_EQ("corge.grault.TestMessage2.Quux", quux2_->full_name());
}
TEST_F(NestedDescriptorTest, EnumContainingType) {
- EXPECT_EQ(message_ , baz_ ->containing_type());
- EXPECT_EQ(message_ , qux_ ->containing_type());
- EXPECT_EQ(message2_, qux2_ ->containing_type());
+ EXPECT_EQ(message_, baz_->containing_type());
+ EXPECT_EQ(message_, qux_->containing_type());
+ EXPECT_EQ(message2_, qux2_->containing_type());
EXPECT_EQ(message2_, quux2_->containing_type());
}
@@ -1758,27 +1769,27 @@
}
TEST_F(NestedDescriptorTest, FindEnumTypeByName) {
- EXPECT_EQ(baz_ , message_ ->FindEnumTypeByName("Baz" ));
- EXPECT_EQ(qux_ , message_ ->FindEnumTypeByName("Qux" ));
- EXPECT_EQ(qux2_ , message2_->FindEnumTypeByName("Qux" ));
+ EXPECT_EQ(baz_, message_->FindEnumTypeByName("Baz"));
+ EXPECT_EQ(qux_, message_->FindEnumTypeByName("Qux"));
+ EXPECT_EQ(qux2_, message2_->FindEnumTypeByName("Qux"));
EXPECT_EQ(quux2_, message2_->FindEnumTypeByName("Quux"));
- EXPECT_TRUE(message_ ->FindEnumTypeByName("NoSuchType") == NULL);
- EXPECT_TRUE(message_ ->FindEnumTypeByName("Quux" ) == NULL);
- EXPECT_TRUE(message2_->FindEnumTypeByName("Baz" ) == NULL);
+ EXPECT_TRUE(message_->FindEnumTypeByName("NoSuchType") == NULL);
+ EXPECT_TRUE(message_->FindEnumTypeByName("Quux") == NULL);
+ EXPECT_TRUE(message2_->FindEnumTypeByName("Baz") == NULL);
EXPECT_TRUE(message_->FindEnumTypeByName("Foo") == NULL);
}
TEST_F(NestedDescriptorTest, FindEnumValueByName) {
- EXPECT_EQ(a_ , message_ ->FindEnumValueByName("A"));
- EXPECT_EQ(b_ , message_ ->FindEnumValueByName("B"));
+ EXPECT_EQ(a_, message_->FindEnumValueByName("A"));
+ EXPECT_EQ(b_, message_->FindEnumValueByName("B"));
EXPECT_EQ(a2_, message2_->FindEnumValueByName("A"));
EXPECT_EQ(c2_, message2_->FindEnumValueByName("C"));
- EXPECT_TRUE(message_ ->FindEnumValueByName("NO_SUCH_VALUE") == NULL);
- EXPECT_TRUE(message_ ->FindEnumValueByName("C" ) == NULL);
- EXPECT_TRUE(message2_->FindEnumValueByName("B" ) == NULL);
+ EXPECT_TRUE(message_->FindEnumValueByName("NO_SUCH_VALUE") == NULL);
+ EXPECT_TRUE(message_->FindEnumValueByName("C") == NULL);
+ EXPECT_TRUE(message2_->FindEnumValueByName("B") == NULL);
EXPECT_TRUE(message_->FindEnumValueByName("Foo") == NULL);
}
@@ -1822,17 +1833,17 @@
AddExtension(&foo_file, "Foo", "foo_enum", 19,
FieldDescriptorProto::LABEL_REPEATED,
FieldDescriptorProto::TYPE_ENUM)
- ->set_type_name("Baz");
+ ->set_type_name("Baz");
DescriptorProto* bar = AddMessage(&foo_file, "Bar");
AddNestedExtension(bar, "Foo", "foo_message", 30,
FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_MESSAGE)
- ->set_type_name("Qux");
+ ->set_type_name("Qux");
AddNestedExtension(bar, "Foo", "foo_group", 39,
FieldDescriptorProto::LABEL_REPEATED,
FieldDescriptorProto::TYPE_GROUP)
- ->set_type_name("Qux");
+ ->set_type_name("Qux");
// Build the descriptors and get the pointers.
foo_file_ = pool_.BuildFile(foo_file);
@@ -1878,20 +1889,20 @@
EXPECT_TRUE(bar_->extension(0)->is_extension());
EXPECT_TRUE(bar_->extension(1)->is_extension());
- EXPECT_EQ("foo_int32" , foo_file_->extension(0)->name());
- EXPECT_EQ("foo_enum" , foo_file_->extension(1)->name());
+ EXPECT_EQ("foo_int32", foo_file_->extension(0)->name());
+ EXPECT_EQ("foo_enum", foo_file_->extension(1)->name());
EXPECT_EQ("foo_message", bar_->extension(0)->name());
- EXPECT_EQ("foo_group" , bar_->extension(1)->name());
+ EXPECT_EQ("foo_group", bar_->extension(1)->name());
EXPECT_EQ(10, foo_file_->extension(0)->number());
EXPECT_EQ(19, foo_file_->extension(1)->number());
EXPECT_EQ(30, bar_->extension(0)->number());
EXPECT_EQ(39, bar_->extension(1)->number());
- EXPECT_EQ(FieldDescriptor::TYPE_INT32 , foo_file_->extension(0)->type());
- EXPECT_EQ(FieldDescriptor::TYPE_ENUM , foo_file_->extension(1)->type());
+ EXPECT_EQ(FieldDescriptor::TYPE_INT32, foo_file_->extension(0)->type());
+ EXPECT_EQ(FieldDescriptor::TYPE_ENUM, foo_file_->extension(1)->type());
EXPECT_EQ(FieldDescriptor::TYPE_MESSAGE, bar_->extension(0)->type());
- EXPECT_EQ(FieldDescriptor::TYPE_GROUP , bar_->extension(1)->type());
+ EXPECT_EQ(FieldDescriptor::TYPE_GROUP, bar_->extension(1)->type());
EXPECT_EQ(baz_, foo_file_->extension(1)->enum_type());
EXPECT_EQ(qux_, bar_->extension(0)->message_type());
@@ -1914,13 +1925,13 @@
};
TEST_F(ExtensionDescriptorTest, IsExtensionNumber) {
- EXPECT_FALSE(foo_->IsExtensionNumber( 9));
- EXPECT_TRUE (foo_->IsExtensionNumber(10));
- EXPECT_TRUE (foo_->IsExtensionNumber(19));
+ EXPECT_FALSE(foo_->IsExtensionNumber(9));
+ EXPECT_TRUE(foo_->IsExtensionNumber(10));
+ EXPECT_TRUE(foo_->IsExtensionNumber(19));
EXPECT_FALSE(foo_->IsExtensionNumber(20));
EXPECT_FALSE(foo_->IsExtensionNumber(29));
- EXPECT_TRUE (foo_->IsExtensionNumber(30));
- EXPECT_TRUE (foo_->IsExtensionNumber(39));
+ EXPECT_TRUE(foo_->IsExtensionNumber(30));
+ EXPECT_TRUE(foo_->IsExtensionNumber(39));
EXPECT_FALSE(foo_->IsExtensionNumber(40));
}
@@ -1930,7 +1941,7 @@
ASSERT_EQ(2, bar_->extension_count());
EXPECT_EQ(bar_->extension(0), bar_->FindExtensionByName("foo_message"));
- EXPECT_EQ(bar_->extension(1), bar_->FindExtensionByName("foo_group" ));
+ EXPECT_EQ(bar_->extension(1), bar_->FindExtensionByName("foo_group"));
EXPECT_TRUE(bar_->FindExtensionByName("no_such_extension") == NULL);
EXPECT_TRUE(foo_->FindExtensionByName("foo_int32") == NULL);
@@ -2034,16 +2045,16 @@
TEST_F(ReservedDescriptorTest, IsReservedNumber) {
EXPECT_FALSE(foo_->IsReservedNumber(1));
- EXPECT_TRUE (foo_->IsReservedNumber(2));
+ EXPECT_TRUE(foo_->IsReservedNumber(2));
EXPECT_FALSE(foo_->IsReservedNumber(3));
EXPECT_FALSE(foo_->IsReservedNumber(8));
- EXPECT_TRUE (foo_->IsReservedNumber(9));
- EXPECT_TRUE (foo_->IsReservedNumber(10));
- EXPECT_TRUE (foo_->IsReservedNumber(11));
+ EXPECT_TRUE(foo_->IsReservedNumber(9));
+ EXPECT_TRUE(foo_->IsReservedNumber(10));
+ EXPECT_TRUE(foo_->IsReservedNumber(11));
EXPECT_FALSE(foo_->IsReservedNumber(12));
EXPECT_FALSE(foo_->IsReservedNumber(13));
EXPECT_FALSE(foo_->IsReservedNumber(14));
- EXPECT_TRUE (foo_->IsReservedNumber(15));
+ EXPECT_TRUE(foo_->IsReservedNumber(15));
EXPECT_FALSE(foo_->IsReservedNumber(16));
};
@@ -2055,8 +2066,8 @@
};
TEST_F(ReservedDescriptorTest, IsReservedName) {
- EXPECT_TRUE (foo_->IsReservedName("foo"));
- EXPECT_TRUE (foo_->IsReservedName("bar"));
+ EXPECT_TRUE(foo_->IsReservedName("foo"));
+ EXPECT_TRUE(foo_->IsReservedName("bar"));
EXPECT_FALSE(foo_->IsReservedName("baz"));
};
@@ -2153,17 +2164,17 @@
EXPECT_TRUE(foo_->IsReservedNumber(-1));
EXPECT_TRUE(foo_->IsReservedNumber(0));
EXPECT_TRUE(foo_->IsReservedNumber(1));
- EXPECT_TRUE (foo_->IsReservedNumber(2));
+ EXPECT_TRUE(foo_->IsReservedNumber(2));
EXPECT_TRUE(foo_->IsReservedNumber(3));
EXPECT_FALSE(foo_->IsReservedNumber(8));
- EXPECT_TRUE (foo_->IsReservedNumber(9));
- EXPECT_TRUE (foo_->IsReservedNumber(10));
- EXPECT_TRUE (foo_->IsReservedNumber(11));
+ EXPECT_TRUE(foo_->IsReservedNumber(9));
+ EXPECT_TRUE(foo_->IsReservedNumber(10));
+ EXPECT_TRUE(foo_->IsReservedNumber(11));
EXPECT_TRUE(foo_->IsReservedNumber(12));
EXPECT_FALSE(foo_->IsReservedNumber(13));
EXPECT_FALSE(foo_->IsReservedNumber(13));
EXPECT_FALSE(foo_->IsReservedNumber(14));
- EXPECT_TRUE (foo_->IsReservedNumber(15));
+ EXPECT_TRUE(foo_->IsReservedNumber(15));
EXPECT_TRUE(foo_->IsReservedNumber(16));
EXPECT_FALSE(foo_->IsReservedNumber(17));
@@ -2186,8 +2197,8 @@
}
TEST_F(ReservedEnumDescriptorTest, IsReservedName) {
- EXPECT_TRUE (foo_->IsReservedName("foo"));
- EXPECT_TRUE (foo_->IsReservedName("bar"));
+ EXPECT_TRUE(foo_->IsReservedName("foo"));
+ EXPECT_TRUE(foo_->IsReservedName("bar"));
EXPECT_FALSE(foo_->IsReservedName("baz"));
}
@@ -2202,9 +2213,9 @@
AddEmptyEnum(&file_proto, "DummyEnum");
DescriptorProto* message = AddMessage(&file_proto, "TestMessage");
- FieldDescriptorProto* field =
- AddField(message, "foo", 1, FieldDescriptorProto::LABEL_OPTIONAL,
- static_cast<FieldDescriptorProto::Type>(static_cast<int>(type)));
+ FieldDescriptorProto* field = AddField(
+ message, "foo", 1, FieldDescriptorProto::LABEL_OPTIONAL,
+ static_cast<FieldDescriptorProto::Type>(static_cast<int>(type)));
if (type == FieldDescriptor::TYPE_MESSAGE ||
type == FieldDescriptor::TYPE_GROUP) {
@@ -2217,8 +2228,7 @@
pool_.reset(new DescriptorPool());
const FileDescriptor* file = pool_->BuildFile(file_proto);
- if (file != NULL &&
- file->message_type_count() == 1 &&
+ if (file != NULL && file->message_type_count() == 1 &&
file->message_type(0)->field_count() == 1) {
return file->message_type(0)->field(0);
} else {
@@ -2233,8 +2243,8 @@
FieldDescriptor::CppType GetCppTypeForFieldType(FieldDescriptor::Type type) {
const FieldDescriptor* field = GetFieldDescriptorOfType(type);
- return field != NULL ? field->cpp_type() :
- static_cast<FieldDescriptor::CppType>(0);
+ return field != NULL ? field->cpp_type()
+ : static_cast<FieldDescriptor::CppType>(0);
}
const char* GetCppTypeNameForFieldType(FieldDescriptor::Type type) {
@@ -2249,7 +2259,7 @@
}
const EnumDescriptor* GetEnumDescriptorForFieldType(
- FieldDescriptor::Type type) {
+ FieldDescriptor::Type type) {
const FieldDescriptor* field = GetFieldDescriptorOfType(type);
return field != NULL ? field->enum_type() : NULL;
}
@@ -2262,24 +2272,24 @@
typedef FieldDescriptor FD; // avoid ugly line wrapping
- EXPECT_STREQ("double" , GetTypeNameForFieldType(FD::TYPE_DOUBLE ));
- EXPECT_STREQ("float" , GetTypeNameForFieldType(FD::TYPE_FLOAT ));
- EXPECT_STREQ("int64" , GetTypeNameForFieldType(FD::TYPE_INT64 ));
- EXPECT_STREQ("uint64" , GetTypeNameForFieldType(FD::TYPE_UINT64 ));
- EXPECT_STREQ("int32" , GetTypeNameForFieldType(FD::TYPE_INT32 ));
- EXPECT_STREQ("fixed64" , GetTypeNameForFieldType(FD::TYPE_FIXED64 ));
- EXPECT_STREQ("fixed32" , GetTypeNameForFieldType(FD::TYPE_FIXED32 ));
- EXPECT_STREQ("bool" , GetTypeNameForFieldType(FD::TYPE_BOOL ));
+ EXPECT_STREQ("double", GetTypeNameForFieldType(FD::TYPE_DOUBLE));
+ EXPECT_STREQ("float", GetTypeNameForFieldType(FD::TYPE_FLOAT));
+ EXPECT_STREQ("int64", GetTypeNameForFieldType(FD::TYPE_INT64));
+ EXPECT_STREQ("uint64", GetTypeNameForFieldType(FD::TYPE_UINT64));
+ EXPECT_STREQ("int32", GetTypeNameForFieldType(FD::TYPE_INT32));
+ EXPECT_STREQ("fixed64", GetTypeNameForFieldType(FD::TYPE_FIXED64));
+ EXPECT_STREQ("fixed32", GetTypeNameForFieldType(FD::TYPE_FIXED32));
+ EXPECT_STREQ("bool", GetTypeNameForFieldType(FD::TYPE_BOOL));
EXPECT_STREQ("string", GetTypeNameForFieldType(FD::TYPE_STRING));
- EXPECT_STREQ("group" , GetTypeNameForFieldType(FD::TYPE_GROUP ));
- EXPECT_STREQ("message" , GetTypeNameForFieldType(FD::TYPE_MESSAGE ));
- EXPECT_STREQ("bytes" , GetTypeNameForFieldType(FD::TYPE_BYTES ));
- EXPECT_STREQ("uint32" , GetTypeNameForFieldType(FD::TYPE_UINT32 ));
- EXPECT_STREQ("enum" , GetTypeNameForFieldType(FD::TYPE_ENUM ));
+ EXPECT_STREQ("group", GetTypeNameForFieldType(FD::TYPE_GROUP));
+ EXPECT_STREQ("message", GetTypeNameForFieldType(FD::TYPE_MESSAGE));
+ EXPECT_STREQ("bytes", GetTypeNameForFieldType(FD::TYPE_BYTES));
+ EXPECT_STREQ("uint32", GetTypeNameForFieldType(FD::TYPE_UINT32));
+ EXPECT_STREQ("enum", GetTypeNameForFieldType(FD::TYPE_ENUM));
EXPECT_STREQ("sfixed32", GetTypeNameForFieldType(FD::TYPE_SFIXED32));
EXPECT_STREQ("sfixed64", GetTypeNameForFieldType(FD::TYPE_SFIXED64));
- EXPECT_STREQ("sint32" , GetTypeNameForFieldType(FD::TYPE_SINT32 ));
- EXPECT_STREQ("sint64" , GetTypeNameForFieldType(FD::TYPE_SINT64 ));
+ EXPECT_STREQ("sint32", GetTypeNameForFieldType(FD::TYPE_SINT32));
+ EXPECT_STREQ("sint64", GetTypeNameForFieldType(FD::TYPE_SINT64));
}
TEST_F(MiscTest, StaticTypeNames) {
@@ -2287,24 +2297,24 @@
typedef FieldDescriptor FD; // avoid ugly line wrapping
- EXPECT_STREQ("double" , FD::TypeName(FD::TYPE_DOUBLE ));
- EXPECT_STREQ("float" , FD::TypeName(FD::TYPE_FLOAT ));
- EXPECT_STREQ("int64" , FD::TypeName(FD::TYPE_INT64 ));
- EXPECT_STREQ("uint64" , FD::TypeName(FD::TYPE_UINT64 ));
- EXPECT_STREQ("int32" , FD::TypeName(FD::TYPE_INT32 ));
- EXPECT_STREQ("fixed64" , FD::TypeName(FD::TYPE_FIXED64 ));
- EXPECT_STREQ("fixed32" , FD::TypeName(FD::TYPE_FIXED32 ));
- EXPECT_STREQ("bool" , FD::TypeName(FD::TYPE_BOOL ));
+ EXPECT_STREQ("double", FD::TypeName(FD::TYPE_DOUBLE));
+ EXPECT_STREQ("float", FD::TypeName(FD::TYPE_FLOAT));
+ EXPECT_STREQ("int64", FD::TypeName(FD::TYPE_INT64));
+ EXPECT_STREQ("uint64", FD::TypeName(FD::TYPE_UINT64));
+ EXPECT_STREQ("int32", FD::TypeName(FD::TYPE_INT32));
+ EXPECT_STREQ("fixed64", FD::TypeName(FD::TYPE_FIXED64));
+ EXPECT_STREQ("fixed32", FD::TypeName(FD::TYPE_FIXED32));
+ EXPECT_STREQ("bool", FD::TypeName(FD::TYPE_BOOL));
EXPECT_STREQ("string", FD::TypeName(FD::TYPE_STRING));
- EXPECT_STREQ("group" , FD::TypeName(FD::TYPE_GROUP ));
- EXPECT_STREQ("message" , FD::TypeName(FD::TYPE_MESSAGE ));
- EXPECT_STREQ("bytes" , FD::TypeName(FD::TYPE_BYTES ));
- EXPECT_STREQ("uint32" , FD::TypeName(FD::TYPE_UINT32 ));
- EXPECT_STREQ("enum" , FD::TypeName(FD::TYPE_ENUM ));
+ EXPECT_STREQ("group", FD::TypeName(FD::TYPE_GROUP));
+ EXPECT_STREQ("message", FD::TypeName(FD::TYPE_MESSAGE));
+ EXPECT_STREQ("bytes", FD::TypeName(FD::TYPE_BYTES));
+ EXPECT_STREQ("uint32", FD::TypeName(FD::TYPE_UINT32));
+ EXPECT_STREQ("enum", FD::TypeName(FD::TYPE_ENUM));
EXPECT_STREQ("sfixed32", FD::TypeName(FD::TYPE_SFIXED32));
EXPECT_STREQ("sfixed64", FD::TypeName(FD::TYPE_SFIXED64));
- EXPECT_STREQ("sint32" , FD::TypeName(FD::TYPE_SINT32 ));
- EXPECT_STREQ("sint64" , FD::TypeName(FD::TYPE_SINT64 ));
+ EXPECT_STREQ("sint32", FD::TypeName(FD::TYPE_SINT32));
+ EXPECT_STREQ("sint64", FD::TypeName(FD::TYPE_SINT64));
}
TEST_F(MiscTest, CppTypes) {
@@ -2312,24 +2322,24 @@
typedef FieldDescriptor FD; // avoid ugly line wrapping
- EXPECT_EQ(FD::CPPTYPE_DOUBLE , GetCppTypeForFieldType(FD::TYPE_DOUBLE ));
- EXPECT_EQ(FD::CPPTYPE_FLOAT , GetCppTypeForFieldType(FD::TYPE_FLOAT ));
- EXPECT_EQ(FD::CPPTYPE_INT64 , GetCppTypeForFieldType(FD::TYPE_INT64 ));
- EXPECT_EQ(FD::CPPTYPE_UINT64 , GetCppTypeForFieldType(FD::TYPE_UINT64 ));
- EXPECT_EQ(FD::CPPTYPE_INT32 , GetCppTypeForFieldType(FD::TYPE_INT32 ));
- EXPECT_EQ(FD::CPPTYPE_UINT64 , GetCppTypeForFieldType(FD::TYPE_FIXED64 ));
- EXPECT_EQ(FD::CPPTYPE_UINT32 , GetCppTypeForFieldType(FD::TYPE_FIXED32 ));
- EXPECT_EQ(FD::CPPTYPE_BOOL , GetCppTypeForFieldType(FD::TYPE_BOOL ));
- EXPECT_EQ(FD::CPPTYPE_STRING , GetCppTypeForFieldType(FD::TYPE_STRING ));
- EXPECT_EQ(FD::CPPTYPE_MESSAGE, GetCppTypeForFieldType(FD::TYPE_GROUP ));
- EXPECT_EQ(FD::CPPTYPE_MESSAGE, GetCppTypeForFieldType(FD::TYPE_MESSAGE ));
- EXPECT_EQ(FD::CPPTYPE_STRING , GetCppTypeForFieldType(FD::TYPE_BYTES ));
- EXPECT_EQ(FD::CPPTYPE_UINT32 , GetCppTypeForFieldType(FD::TYPE_UINT32 ));
- EXPECT_EQ(FD::CPPTYPE_ENUM , GetCppTypeForFieldType(FD::TYPE_ENUM ));
- EXPECT_EQ(FD::CPPTYPE_INT32 , GetCppTypeForFieldType(FD::TYPE_SFIXED32));
- EXPECT_EQ(FD::CPPTYPE_INT64 , GetCppTypeForFieldType(FD::TYPE_SFIXED64));
- EXPECT_EQ(FD::CPPTYPE_INT32 , GetCppTypeForFieldType(FD::TYPE_SINT32 ));
- EXPECT_EQ(FD::CPPTYPE_INT64 , GetCppTypeForFieldType(FD::TYPE_SINT64 ));
+ EXPECT_EQ(FD::CPPTYPE_DOUBLE, GetCppTypeForFieldType(FD::TYPE_DOUBLE));
+ EXPECT_EQ(FD::CPPTYPE_FLOAT, GetCppTypeForFieldType(FD::TYPE_FLOAT));
+ EXPECT_EQ(FD::CPPTYPE_INT64, GetCppTypeForFieldType(FD::TYPE_INT64));
+ EXPECT_EQ(FD::CPPTYPE_UINT64, GetCppTypeForFieldType(FD::TYPE_UINT64));
+ EXPECT_EQ(FD::CPPTYPE_INT32, GetCppTypeForFieldType(FD::TYPE_INT32));
+ EXPECT_EQ(FD::CPPTYPE_UINT64, GetCppTypeForFieldType(FD::TYPE_FIXED64));
+ EXPECT_EQ(FD::CPPTYPE_UINT32, GetCppTypeForFieldType(FD::TYPE_FIXED32));
+ EXPECT_EQ(FD::CPPTYPE_BOOL, GetCppTypeForFieldType(FD::TYPE_BOOL));
+ EXPECT_EQ(FD::CPPTYPE_STRING, GetCppTypeForFieldType(FD::TYPE_STRING));
+ EXPECT_EQ(FD::CPPTYPE_MESSAGE, GetCppTypeForFieldType(FD::TYPE_GROUP));
+ EXPECT_EQ(FD::CPPTYPE_MESSAGE, GetCppTypeForFieldType(FD::TYPE_MESSAGE));
+ EXPECT_EQ(FD::CPPTYPE_STRING, GetCppTypeForFieldType(FD::TYPE_BYTES));
+ EXPECT_EQ(FD::CPPTYPE_UINT32, GetCppTypeForFieldType(FD::TYPE_UINT32));
+ EXPECT_EQ(FD::CPPTYPE_ENUM, GetCppTypeForFieldType(FD::TYPE_ENUM));
+ EXPECT_EQ(FD::CPPTYPE_INT32, GetCppTypeForFieldType(FD::TYPE_SFIXED32));
+ EXPECT_EQ(FD::CPPTYPE_INT64, GetCppTypeForFieldType(FD::TYPE_SFIXED64));
+ EXPECT_EQ(FD::CPPTYPE_INT32, GetCppTypeForFieldType(FD::TYPE_SINT32));
+ EXPECT_EQ(FD::CPPTYPE_INT64, GetCppTypeForFieldType(FD::TYPE_SINT64));
}
TEST_F(MiscTest, CppTypeNames) {
@@ -2337,24 +2347,24 @@
typedef FieldDescriptor FD; // avoid ugly line wrapping
- EXPECT_STREQ("double" , GetCppTypeNameForFieldType(FD::TYPE_DOUBLE ));
- EXPECT_STREQ("float" , GetCppTypeNameForFieldType(FD::TYPE_FLOAT ));
- EXPECT_STREQ("int64" , GetCppTypeNameForFieldType(FD::TYPE_INT64 ));
- EXPECT_STREQ("uint64" , GetCppTypeNameForFieldType(FD::TYPE_UINT64 ));
- EXPECT_STREQ("int32" , GetCppTypeNameForFieldType(FD::TYPE_INT32 ));
- EXPECT_STREQ("uint64" , GetCppTypeNameForFieldType(FD::TYPE_FIXED64 ));
- EXPECT_STREQ("uint32" , GetCppTypeNameForFieldType(FD::TYPE_FIXED32 ));
- EXPECT_STREQ("bool" , GetCppTypeNameForFieldType(FD::TYPE_BOOL ));
+ EXPECT_STREQ("double", GetCppTypeNameForFieldType(FD::TYPE_DOUBLE));
+ EXPECT_STREQ("float", GetCppTypeNameForFieldType(FD::TYPE_FLOAT));
+ EXPECT_STREQ("int64", GetCppTypeNameForFieldType(FD::TYPE_INT64));
+ EXPECT_STREQ("uint64", GetCppTypeNameForFieldType(FD::TYPE_UINT64));
+ EXPECT_STREQ("int32", GetCppTypeNameForFieldType(FD::TYPE_INT32));
+ EXPECT_STREQ("uint64", GetCppTypeNameForFieldType(FD::TYPE_FIXED64));
+ EXPECT_STREQ("uint32", GetCppTypeNameForFieldType(FD::TYPE_FIXED32));
+ EXPECT_STREQ("bool", GetCppTypeNameForFieldType(FD::TYPE_BOOL));
EXPECT_STREQ("string", GetCppTypeNameForFieldType(FD::TYPE_STRING));
- EXPECT_STREQ("message", GetCppTypeNameForFieldType(FD::TYPE_GROUP ));
- EXPECT_STREQ("message", GetCppTypeNameForFieldType(FD::TYPE_MESSAGE ));
+ EXPECT_STREQ("message", GetCppTypeNameForFieldType(FD::TYPE_GROUP));
+ EXPECT_STREQ("message", GetCppTypeNameForFieldType(FD::TYPE_MESSAGE));
EXPECT_STREQ("string", GetCppTypeNameForFieldType(FD::TYPE_BYTES));
- EXPECT_STREQ("uint32" , GetCppTypeNameForFieldType(FD::TYPE_UINT32 ));
- EXPECT_STREQ("enum" , GetCppTypeNameForFieldType(FD::TYPE_ENUM ));
- EXPECT_STREQ("int32" , GetCppTypeNameForFieldType(FD::TYPE_SFIXED32));
- EXPECT_STREQ("int64" , GetCppTypeNameForFieldType(FD::TYPE_SFIXED64));
- EXPECT_STREQ("int32" , GetCppTypeNameForFieldType(FD::TYPE_SINT32 ));
- EXPECT_STREQ("int64" , GetCppTypeNameForFieldType(FD::TYPE_SINT64 ));
+ EXPECT_STREQ("uint32", GetCppTypeNameForFieldType(FD::TYPE_UINT32));
+ EXPECT_STREQ("enum", GetCppTypeNameForFieldType(FD::TYPE_ENUM));
+ EXPECT_STREQ("int32", GetCppTypeNameForFieldType(FD::TYPE_SFIXED32));
+ EXPECT_STREQ("int64", GetCppTypeNameForFieldType(FD::TYPE_SFIXED64));
+ EXPECT_STREQ("int32", GetCppTypeNameForFieldType(FD::TYPE_SINT32));
+ EXPECT_STREQ("int64", GetCppTypeNameForFieldType(FD::TYPE_SINT64));
}
TEST_F(MiscTest, StaticCppTypeNames) {
@@ -2362,14 +2372,14 @@
typedef FieldDescriptor FD; // avoid ugly line wrapping
- EXPECT_STREQ("int32" , FD::CppTypeName(FD::CPPTYPE_INT32 ));
- EXPECT_STREQ("int64" , FD::CppTypeName(FD::CPPTYPE_INT64 ));
- EXPECT_STREQ("uint32" , FD::CppTypeName(FD::CPPTYPE_UINT32 ));
- EXPECT_STREQ("uint64" , FD::CppTypeName(FD::CPPTYPE_UINT64 ));
- EXPECT_STREQ("double" , FD::CppTypeName(FD::CPPTYPE_DOUBLE ));
- EXPECT_STREQ("float" , FD::CppTypeName(FD::CPPTYPE_FLOAT ));
- EXPECT_STREQ("bool" , FD::CppTypeName(FD::CPPTYPE_BOOL ));
- EXPECT_STREQ("enum" , FD::CppTypeName(FD::CPPTYPE_ENUM ));
+ EXPECT_STREQ("int32", FD::CppTypeName(FD::CPPTYPE_INT32));
+ EXPECT_STREQ("int64", FD::CppTypeName(FD::CPPTYPE_INT64));
+ EXPECT_STREQ("uint32", FD::CppTypeName(FD::CPPTYPE_UINT32));
+ EXPECT_STREQ("uint64", FD::CppTypeName(FD::CPPTYPE_UINT64));
+ EXPECT_STREQ("double", FD::CppTypeName(FD::CPPTYPE_DOUBLE));
+ EXPECT_STREQ("float", FD::CppTypeName(FD::CPPTYPE_FLOAT));
+ EXPECT_STREQ("bool", FD::CppTypeName(FD::CPPTYPE_BOOL));
+ EXPECT_STREQ("enum", FD::CppTypeName(FD::CPPTYPE_ENUM));
EXPECT_STREQ("string", FD::CppTypeName(FD::CPPTYPE_STRING));
EXPECT_STREQ("message", FD::CppTypeName(FD::CPPTYPE_MESSAGE));
}
@@ -2379,24 +2389,24 @@
typedef FieldDescriptor FD; // avoid ugly line wrapping
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_DOUBLE ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_FLOAT ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_INT64 ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_UINT64 ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_INT32 ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_FIXED64 ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_FIXED32 ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_BOOL ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_STRING ));
- EXPECT_TRUE(NULL != GetMessageDescriptorForFieldType(FD::TYPE_GROUP ));
- EXPECT_TRUE(NULL != GetMessageDescriptorForFieldType(FD::TYPE_MESSAGE ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_BYTES ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_UINT32 ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_ENUM ));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_DOUBLE));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_FLOAT));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_INT64));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_UINT64));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_INT32));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_FIXED64));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_FIXED32));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_BOOL));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_STRING));
+ EXPECT_TRUE(NULL != GetMessageDescriptorForFieldType(FD::TYPE_GROUP));
+ EXPECT_TRUE(NULL != GetMessageDescriptorForFieldType(FD::TYPE_MESSAGE));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_BYTES));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_UINT32));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_ENUM));
EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_SFIXED32));
EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_SFIXED64));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_SINT32 ));
- EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_SINT64 ));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_SINT32));
+ EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_SINT64));
}
TEST_F(MiscTest, EnumType) {
@@ -2404,27 +2414,26 @@
typedef FieldDescriptor FD; // avoid ugly line wrapping
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_DOUBLE ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_FLOAT ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_INT64 ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_UINT64 ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_INT32 ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_FIXED64 ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_FIXED32 ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_BOOL ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_STRING ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_GROUP ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_MESSAGE ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_BYTES ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_UINT32 ));
- EXPECT_TRUE(NULL != GetEnumDescriptorForFieldType(FD::TYPE_ENUM ));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_DOUBLE));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_FLOAT));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_INT64));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_UINT64));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_INT32));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_FIXED64));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_FIXED32));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_BOOL));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_STRING));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_GROUP));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_MESSAGE));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_BYTES));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_UINT32));
+ EXPECT_TRUE(NULL != GetEnumDescriptorForFieldType(FD::TYPE_ENUM));
EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_SFIXED32));
EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_SFIXED64));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_SINT32 ));
- EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_SINT64 ));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_SINT32));
+ EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_SINT64));
}
-
TEST_F(MiscTest, DefaultValues) {
// Test that setting default values works.
FileDescriptorProto file_proto;
@@ -2440,47 +2449,47 @@
const FD::Label label = FD::LABEL_OPTIONAL;
// Create fields of every CPP type with default values.
- AddField(message_proto, "int32" , 1, label, FD::TYPE_INT32 )
- ->set_default_value("-1");
- AddField(message_proto, "int64" , 2, label, FD::TYPE_INT64 )
- ->set_default_value("-1000000000000");
+ AddField(message_proto, "int32", 1, label, FD::TYPE_INT32)
+ ->set_default_value("-1");
+ AddField(message_proto, "int64", 2, label, FD::TYPE_INT64)
+ ->set_default_value("-1000000000000");
AddField(message_proto, "uint32", 3, label, FD::TYPE_UINT32)
- ->set_default_value("42");
+ ->set_default_value("42");
AddField(message_proto, "uint64", 4, label, FD::TYPE_UINT64)
- ->set_default_value("2000000000000");
- AddField(message_proto, "float" , 5, label, FD::TYPE_FLOAT )
- ->set_default_value("4.5");
+ ->set_default_value("2000000000000");
+ AddField(message_proto, "float", 5, label, FD::TYPE_FLOAT)
+ ->set_default_value("4.5");
AddField(message_proto, "double", 6, label, FD::TYPE_DOUBLE)
- ->set_default_value("10e100");
- AddField(message_proto, "bool" , 7, label, FD::TYPE_BOOL )
- ->set_default_value("true");
+ ->set_default_value("10e100");
+ AddField(message_proto, "bool", 7, label, FD::TYPE_BOOL)
+ ->set_default_value("true");
AddField(message_proto, "string", 8, label, FD::TYPE_STRING)
->set_default_value("hello");
- AddField(message_proto, "data" , 9, label, FD::TYPE_BYTES )
- ->set_default_value("\\001\\002\\003");
+ AddField(message_proto, "data", 9, label, FD::TYPE_BYTES)
+ ->set_default_value("\\001\\002\\003");
FieldDescriptorProto* enum_field =
- AddField(message_proto, "enum", 10, label, FD::TYPE_ENUM);
+ AddField(message_proto, "enum", 10, label, FD::TYPE_ENUM);
enum_field->set_type_name("DummyEnum");
enum_field->set_default_value("B");
// Strings are allowed to have empty defaults. (At one point, due to
// a bug, empty defaults for strings were rejected. Oops.)
AddField(message_proto, "empty_string", 11, label, FD::TYPE_STRING)
- ->set_default_value("");
+ ->set_default_value("");
// Add a second set of fields with implicit defalut values.
- AddField(message_proto, "implicit_int32" , 21, label, FD::TYPE_INT32 );
- AddField(message_proto, "implicit_int64" , 22, label, FD::TYPE_INT64 );
+ AddField(message_proto, "implicit_int32", 21, label, FD::TYPE_INT32);
+ AddField(message_proto, "implicit_int64", 22, label, FD::TYPE_INT64);
AddField(message_proto, "implicit_uint32", 23, label, FD::TYPE_UINT32);
AddField(message_proto, "implicit_uint64", 24, label, FD::TYPE_UINT64);
- AddField(message_proto, "implicit_float" , 25, label, FD::TYPE_FLOAT );
+ AddField(message_proto, "implicit_float", 25, label, FD::TYPE_FLOAT);
AddField(message_proto, "implicit_double", 26, label, FD::TYPE_DOUBLE);
- AddField(message_proto, "implicit_bool" , 27, label, FD::TYPE_BOOL );
+ AddField(message_proto, "implicit_bool", 27, label, FD::TYPE_BOOL);
AddField(message_proto, "implicit_string", 28, label, FD::TYPE_STRING);
- AddField(message_proto, "implicit_data" , 29, label, FD::TYPE_BYTES );
- AddField(message_proto, "implicit_enum" , 30, label, FD::TYPE_ENUM)
- ->set_type_name("DummyEnum");
+ AddField(message_proto, "implicit_data", 29, label, FD::TYPE_BYTES);
+ AddField(message_proto, "implicit_enum", 30, label, FD::TYPE_ENUM)
+ ->set_type_name("DummyEnum");
// Build it.
DescriptorPool pool;
@@ -2517,13 +2526,13 @@
EXPECT_EQ(42, message->field(2)->default_value_uint32());
EXPECT_EQ(PROTOBUF_ULONGLONG(2000000000000),
message->field(3)->default_value_uint64());
- EXPECT_EQ(4.5 , message->field(4)->default_value_float ());
- EXPECT_EQ(10e100 , message->field(5)->default_value_double());
- EXPECT_TRUE( message->field(6)->default_value_bool ());
- EXPECT_EQ("hello" , message->field(7)->default_value_string());
- EXPECT_EQ("\001\002\003" , message->field(8)->default_value_string());
- EXPECT_EQ(enum_value_b , message->field(9)->default_value_enum ());
- EXPECT_EQ("" , message->field(10)->default_value_string());
+ EXPECT_EQ(4.5, message->field(4)->default_value_float());
+ EXPECT_EQ(10e100, message->field(5)->default_value_double());
+ EXPECT_TRUE(message->field(6)->default_value_bool());
+ EXPECT_EQ("hello", message->field(7)->default_value_string());
+ EXPECT_EQ("\001\002\003", message->field(8)->default_value_string());
+ EXPECT_EQ(enum_value_b, message->field(9)->default_value_enum());
+ EXPECT_EQ("", message->field(10)->default_value_string());
ASSERT_FALSE(message->field(11)->has_default_value());
ASSERT_FALSE(message->field(12)->has_default_value());
@@ -2536,15 +2545,15 @@
ASSERT_FALSE(message->field(19)->has_default_value());
ASSERT_FALSE(message->field(20)->has_default_value());
- EXPECT_EQ(0 , message->field(11)->default_value_int32 ());
- EXPECT_EQ(0 , message->field(12)->default_value_int64 ());
- EXPECT_EQ(0 , message->field(13)->default_value_uint32());
- EXPECT_EQ(0 , message->field(14)->default_value_uint64());
- EXPECT_EQ(0.0f , message->field(15)->default_value_float ());
- EXPECT_EQ(0.0 , message->field(16)->default_value_double());
- EXPECT_FALSE( message->field(17)->default_value_bool ());
- EXPECT_EQ("" , message->field(18)->default_value_string());
- EXPECT_EQ("" , message->field(19)->default_value_string());
+ EXPECT_EQ(0, message->field(11)->default_value_int32());
+ EXPECT_EQ(0, message->field(12)->default_value_int64());
+ EXPECT_EQ(0, message->field(13)->default_value_uint32());
+ EXPECT_EQ(0, message->field(14)->default_value_uint64());
+ EXPECT_EQ(0.0f, message->field(15)->default_value_float());
+ EXPECT_EQ(0.0, message->field(16)->default_value_double());
+ EXPECT_FALSE(message->field(17)->default_value_bool());
+ EXPECT_EQ("", message->field(18)->default_value_string());
+ EXPECT_EQ("", message->field(19)->default_value_string());
EXPECT_EQ(enum_value_a, message->field(20)->default_value_enum());
}
@@ -2555,13 +2564,11 @@
file_proto.set_name("foo.proto");
DescriptorProto* message_proto = AddMessage(&file_proto, "TestMessage");
- AddField(message_proto, "foo", 1,
- FieldDescriptorProto::LABEL_OPTIONAL,
+ AddField(message_proto, "foo", 1, FieldDescriptorProto::LABEL_OPTIONAL,
FieldDescriptorProto::TYPE_INT32);
FieldDescriptorProto* bar_proto =
- AddField(message_proto, "bar", 2,
- FieldDescriptorProto::LABEL_OPTIONAL,
- FieldDescriptorProto::TYPE_INT32);
+ AddField(message_proto, "bar", 2, FieldDescriptorProto::LABEL_OPTIONAL,
+ FieldDescriptorProto::TYPE_INT32);
FieldOptions* options = bar_proto->mutable_options();
options->set_ctype(FieldOptions::CORD);
@@ -2588,17 +2595,12 @@
}
// ===================================================================
-enum DescriptorPoolMode {
- NO_DATABASE,
- FALLBACK_DATABASE
-};
+enum DescriptorPoolMode { NO_DATABASE, FALLBACK_DATABASE };
class AllowUnknownDependenciesTest
: public testing::TestWithParam<DescriptorPoolMode> {
protected:
- DescriptorPoolMode mode() {
- return GetParam();
- }
+ DescriptorPoolMode mode() { return GetParam(); }
virtual void SetUp() {
FileDescriptorProto foo_proto, bar_proto;
@@ -2615,32 +2617,32 @@
pool_->AllowUnknownDependencies();
ASSERT_TRUE(TextFormat::ParseFromString(
- "name: 'foo.proto'"
- "dependency: 'bar.proto'"
- "dependency: 'baz.proto'"
- "message_type {"
- " name: 'Foo'"
- " field { name:'bar' number:1 label:LABEL_OPTIONAL type_name:'Bar' }"
- " field { name:'baz' number:2 label:LABEL_OPTIONAL type_name:'Baz' }"
- " field { name:'qux' number:3 label:LABEL_OPTIONAL"
- " type_name: '.corge.Qux'"
- " type: TYPE_ENUM"
- " options {"
- " uninterpreted_option {"
- " name {"
- " name_part: 'grault'"
- " is_extension: true"
- " }"
- " positive_int_value: 1234"
- " }"
- " }"
- " }"
- "}",
- &foo_proto));
- ASSERT_TRUE(TextFormat::ParseFromString(
- "name: 'bar.proto'"
- "message_type { name: 'Bar' }",
- &bar_proto));
+ "name: 'foo.proto'"
+ "dependency: 'bar.proto'"
+ "dependency: 'baz.proto'"
+ "message_type {"
+ " name: 'Foo'"
+ " field { name:'bar' number:1 label:LABEL_OPTIONAL type_name:'Bar' }"
+ " field { name:'baz' number:2 label:LABEL_OPTIONAL type_name:'Baz' }"
+ " field { name:'qux' number:3 label:LABEL_OPTIONAL"
+ " type_name: '.corge.Qux'"
+ " type: TYPE_ENUM"
+ " options {"
+ " uninterpreted_option {"
+ " name {"
+ " name_part: 'grault'"
+ " is_extension: true"
+ " }"
+ " positive_int_value: 1234"
+ " }"
+ " }"
+ " }"
+ "}",
+ &foo_proto));
+ ASSERT_TRUE(
+ TextFormat::ParseFromString("name: 'bar.proto'"
+ "message_type { name: 'Bar' }",
+ &bar_proto));
// Collect pointers to stuff.
bar_file_ = BuildFile(bar_proto);
@@ -2683,7 +2685,7 @@
const FieldDescriptor* baz_field_;
const FieldDescriptor* qux_field_;
- SimpleDescriptorDatabase db_; // used if in FALLBACK_DATABASE mode.
+ SimpleDescriptorDatabase db_; // used if in FALLBACK_DATABASE mode.
std::unique_ptr<DescriptorPool> pool_;
};
@@ -2759,7 +2761,7 @@
// Qux should still have the uninterpreted option attached.
ASSERT_EQ(1, qux_field_->options().uninterpreted_option_size());
const UninterpretedOption& option =
- qux_field_->options().uninterpreted_option(0);
+ qux_field_->options().uninterpreted_option(0);
ASSERT_EQ(1, option.name_size());
EXPECT_EQ("grault", option.name(0).name_part());
}
@@ -2771,10 +2773,10 @@
FileDescriptorProto extension_proto;
ASSERT_TRUE(TextFormat::ParseFromString(
- "name: 'extension.proto'"
- "extension { extendee: 'UnknownType' name:'some_extension' number:123"
- " label:LABEL_OPTIONAL type:TYPE_INT32 }",
- &extension_proto));
+ "name: 'extension.proto'"
+ "extension { extendee: 'UnknownType' name:'some_extension' number:123"
+ " label:LABEL_OPTIONAL type:TYPE_INT32 }",
+ &extension_proto));
const FileDescriptor* file = BuildFile(extension_proto);
ASSERT_TRUE(file != NULL);
@@ -2795,39 +2797,39 @@
FileDescriptorProto option_proto;
ASSERT_TRUE(TextFormat::ParseFromString(
- "name: \"unknown_custom_options.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { "
- " extendee: \"google.protobuf.FileOptions\" "
- " name: \"some_option\" "
- " number: 123456 "
- " label: LABEL_OPTIONAL "
- " type: TYPE_INT32 "
- "} "
- "options { "
- " uninterpreted_option { "
- " name { "
- " name_part: \"some_option\" "
- " is_extension: true "
- " } "
- " positive_int_value: 1234 "
- " } "
- " uninterpreted_option { "
- " name { "
- " name_part: \"unknown_option\" "
- " is_extension: true "
- " } "
- " positive_int_value: 1234 "
- " } "
- " uninterpreted_option { "
- " name { "
- " name_part: \"optimize_for\" "
- " is_extension: false "
- " } "
- " identifier_value: \"SPEED\" "
- " } "
- "}",
- &option_proto));
+ "name: \"unknown_custom_options.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { "
+ " extendee: \"google.protobuf.FileOptions\" "
+ " name: \"some_option\" "
+ " number: 123456 "
+ " label: LABEL_OPTIONAL "
+ " type: TYPE_INT32 "
+ "} "
+ "options { "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"some_option\" "
+ " is_extension: true "
+ " } "
+ " positive_int_value: 1234 "
+ " } "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"unknown_option\" "
+ " is_extension: true "
+ " } "
+ " positive_int_value: 1234 "
+ " } "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"optimize_for\" "
+ " is_extension: false "
+ " } "
+ " identifier_value: \"SPEED\" "
+ " } "
+ "}",
+ &option_proto));
const FileDescriptor* file = BuildFile(option_proto);
ASSERT_TRUE(file != NULL);
@@ -2854,18 +2856,18 @@
FileDescriptorProto undeclared_dep_proto;
// We make this file fail to build by giving it two fields with tag 1.
ASSERT_TRUE(TextFormat::ParseFromString(
- "name: \"invalid_file_as_undeclared_dep.proto\" "
- "package: \"undeclared\" "
- "message_type: { "
- " name: \"Quux\" "
- " field { "
- " name:'qux' number:1 label:LABEL_OPTIONAL type: TYPE_INT32 "
- " }"
- " field { "
- " name:'quux' number:1 label:LABEL_OPTIONAL type: TYPE_INT64 "
- " }"
- "}",
- &undeclared_dep_proto));
+ "name: \"invalid_file_as_undeclared_dep.proto\" "
+ "package: \"undeclared\" "
+ "message_type: { "
+ " name: \"Quux\" "
+ " field { "
+ " name:'qux' number:1 label:LABEL_OPTIONAL type: TYPE_INT32 "
+ " }"
+ " field { "
+ " name:'quux' number:1 label:LABEL_OPTIONAL type: TYPE_INT64 "
+ " }"
+ "}",
+ &undeclared_dep_proto));
// We can't use the BuildFile() helper because we don't actually want to build
// it into the descriptor pool in the fallback database case: it just needs to
// be sitting in the database so that it gets built during the building of
@@ -2882,15 +2884,15 @@
FileDescriptorProto test_proto;
ASSERT_TRUE(TextFormat::ParseFromString(
- "name: \"test.proto\" "
- "message_type: { "
- " name: \"Corge\" "
- " field { "
- " name:'quux' number:1 label: LABEL_OPTIONAL "
- " type_name:'undeclared.Quux' type: TYPE_MESSAGE "
- " }"
- "}",
- &test_proto));
+ "name: \"test.proto\" "
+ "message_type: { "
+ " name: \"Corge\" "
+ " field { "
+ " name:'quux' number:1 label: LABEL_OPTIONAL "
+ " type_name:'undeclared.Quux' type: TYPE_MESSAGE "
+ " }"
+ "}",
+ &test_proto));
const FileDescriptor* file = BuildFile(test_proto);
ASSERT_TRUE(file != NULL);
@@ -2937,13 +2939,10 @@
field->options().GetExtension(protobuf_unittest::field_opt1));
EXPECT_EQ(42, // Check that we get the default for an option we don't set.
field->options().GetExtension(protobuf_unittest::field_opt2));
- EXPECT_EQ(-99,
- oneof->options().GetExtension(protobuf_unittest::oneof_opt1));
- EXPECT_EQ(-789,
- enm->options().GetExtension(protobuf_unittest::enum_opt1));
- EXPECT_EQ(123,
- enm->value(1)->options().GetExtension(
- protobuf_unittest::enum_value_opt1));
+ EXPECT_EQ(-99, oneof->options().GetExtension(protobuf_unittest::oneof_opt1));
+ EXPECT_EQ(-789, enm->options().GetExtension(protobuf_unittest::enum_opt1));
+ EXPECT_EQ(123, enm->value(1)->options().GetExtension(
+ protobuf_unittest::enum_value_opt1));
EXPECT_EQ(PROTOBUF_LONGLONG(-9876543210),
service->options().GetExtension(protobuf_unittest::service_opt1));
EXPECT_EQ(protobuf_unittest::METHODOPT1_VAL2,
@@ -2959,34 +2958,33 @@
options =
&protobuf_unittest::CustomOptionMinIntegerValues::descriptor()->options();
- EXPECT_EQ(false , options->GetExtension(protobuf_unittest::bool_opt));
+ EXPECT_EQ(false, options->GetExtension(protobuf_unittest::bool_opt));
EXPECT_EQ(kint32min, options->GetExtension(protobuf_unittest::int32_opt));
EXPECT_EQ(kint64min, options->GetExtension(protobuf_unittest::int64_opt));
- EXPECT_EQ(0 , options->GetExtension(protobuf_unittest::uint32_opt));
- EXPECT_EQ(0 , options->GetExtension(protobuf_unittest::uint64_opt));
+ EXPECT_EQ(0, options->GetExtension(protobuf_unittest::uint32_opt));
+ EXPECT_EQ(0, options->GetExtension(protobuf_unittest::uint64_opt));
EXPECT_EQ(kint32min, options->GetExtension(protobuf_unittest::sint32_opt));
EXPECT_EQ(kint64min, options->GetExtension(protobuf_unittest::sint64_opt));
- EXPECT_EQ(0 , options->GetExtension(protobuf_unittest::fixed32_opt));
- EXPECT_EQ(0 , options->GetExtension(protobuf_unittest::fixed64_opt));
+ EXPECT_EQ(0, options->GetExtension(protobuf_unittest::fixed32_opt));
+ EXPECT_EQ(0, options->GetExtension(protobuf_unittest::fixed64_opt));
EXPECT_EQ(kint32min, options->GetExtension(protobuf_unittest::sfixed32_opt));
EXPECT_EQ(kint64min, options->GetExtension(protobuf_unittest::sfixed64_opt));
options =
&protobuf_unittest::CustomOptionMaxIntegerValues::descriptor()->options();
- EXPECT_EQ(true , options->GetExtension(protobuf_unittest::bool_opt));
- EXPECT_EQ(kint32max , options->GetExtension(protobuf_unittest::int32_opt));
- EXPECT_EQ(kint64max , options->GetExtension(protobuf_unittest::int64_opt));
+ EXPECT_EQ(true, options->GetExtension(protobuf_unittest::bool_opt));
+ EXPECT_EQ(kint32max, options->GetExtension(protobuf_unittest::int32_opt));
+ EXPECT_EQ(kint64max, options->GetExtension(protobuf_unittest::int64_opt));
EXPECT_EQ(kuint32max, options->GetExtension(protobuf_unittest::uint32_opt));
EXPECT_EQ(kuint64max, options->GetExtension(protobuf_unittest::uint64_opt));
- EXPECT_EQ(kint32max , options->GetExtension(protobuf_unittest::sint32_opt));
- EXPECT_EQ(kint64max , options->GetExtension(protobuf_unittest::sint64_opt));
+ EXPECT_EQ(kint32max, options->GetExtension(protobuf_unittest::sint32_opt));
+ EXPECT_EQ(kint64max, options->GetExtension(protobuf_unittest::sint64_opt));
EXPECT_EQ(kuint32max, options->GetExtension(protobuf_unittest::fixed32_opt));
EXPECT_EQ(kuint64max, options->GetExtension(protobuf_unittest::fixed64_opt));
- EXPECT_EQ(kint32max , options->GetExtension(protobuf_unittest::sfixed32_opt));
- EXPECT_EQ(kint64max , options->GetExtension(protobuf_unittest::sfixed64_opt));
+ EXPECT_EQ(kint32max, options->GetExtension(protobuf_unittest::sfixed32_opt));
+ EXPECT_EQ(kint64max, options->GetExtension(protobuf_unittest::sfixed64_opt));
- options =
- &protobuf_unittest::CustomOptionOtherValues::descriptor()->options();
+ options = &protobuf_unittest::CustomOptionOtherValues::descriptor()->options();
EXPECT_EQ(-100, options->GetExtension(protobuf_unittest::int32_opt));
EXPECT_FLOAT_EQ(12.3456789,
options->GetExtension(protobuf_unittest::float_opt));
@@ -3016,35 +3014,52 @@
const MessageOptions* options =
&protobuf_unittest::VariousComplexOptions::descriptor()->options();
EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt1).foo(), 42);
- EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt1).
- GetExtension(protobuf_unittest::quux), 324);
- EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt1).
- GetExtension(protobuf_unittest::corge).qux(), 876);
+ EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt1)
+ .GetExtension(protobuf_unittest::quux),
+ 324);
+ EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt1)
+ .GetExtension(protobuf_unittest::corge)
+ .qux(),
+ 876);
EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).baz(), 987);
- EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).
- GetExtension(protobuf_unittest::grault), 654);
+ EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2)
+ .GetExtension(protobuf_unittest::grault),
+ 654);
EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).bar().foo(),
743);
- EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).bar().
- GetExtension(protobuf_unittest::quux), 1999);
- EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).bar().
- GetExtension(protobuf_unittest::corge).qux(), 2008);
- EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).
- GetExtension(protobuf_unittest::garply).foo(), 741);
- EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).
- GetExtension(protobuf_unittest::garply).
- GetExtension(protobuf_unittest::quux), 1998);
- EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).
- GetExtension(protobuf_unittest::garply).
- GetExtension(protobuf_unittest::corge).qux(), 2121);
- EXPECT_EQ(options->GetExtension(
- protobuf_unittest::ComplexOptionType2::ComplexOptionType4::complex_opt4).
- waldo(), 1971);
- EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).
- fred().waldo(), 321);
+ EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2)
+ .bar()
+ .GetExtension(protobuf_unittest::quux),
+ 1999);
+ EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2)
+ .bar()
+ .GetExtension(protobuf_unittest::corge)
+ .qux(),
+ 2008);
+ EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2)
+ .GetExtension(protobuf_unittest::garply)
+ .foo(),
+ 741);
+ EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2)
+ .GetExtension(protobuf_unittest::garply)
+ .GetExtension(protobuf_unittest::quux),
+ 1998);
+ EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2)
+ .GetExtension(protobuf_unittest::garply)
+ .GetExtension(protobuf_unittest::corge)
+ .qux(),
+ 2121);
+ EXPECT_EQ(options
+ ->GetExtension(protobuf_unittest::ComplexOptionType2::
+ ComplexOptionType4::complex_opt4)
+ .waldo(),
+ 1971);
+ EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).fred().waldo(),
+ 321);
EXPECT_EQ(9, options->GetExtension(protobuf_unittest::complex_opt3).qux());
- EXPECT_EQ(22, options->GetExtension(protobuf_unittest::complex_opt3).
- complexoptiontype5().plugh());
+ EXPECT_EQ(22, options->GetExtension(protobuf_unittest::complex_opt3)
+ .complexoptiontype5()
+ .plugh());
EXPECT_EQ(24, options->GetExtension(protobuf_unittest::complexopt6).xyzzy());
}
@@ -3057,43 +3072,42 @@
FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != NULL);
- protobuf_unittest::TestMessageWithCustomOptions::descriptor()
- ->file()->CopyTo(&file_proto);
+ protobuf_unittest::TestMessageWithCustomOptions::descriptor()->file()->CopyTo(
+ &file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != NULL);
ASSERT_TRUE(TextFormat::ParseFromString(
- "name: \"custom_options_import.proto\" "
- "package: \"protobuf_unittest\" "
- "dependency: \"google/protobuf/unittest_custom_options.proto\" "
- "options { "
- " uninterpreted_option { "
- " name { "
- " name_part: \"file_opt1\" "
- " is_extension: true "
- " } "
- " positive_int_value: 1234 "
- " } "
- // Test a non-extension option too. (At one point this failed due to a
- // bug.)
- " uninterpreted_option { "
- " name { "
- " name_part: \"java_package\" "
- " is_extension: false "
- " } "
- " string_value: \"foo\" "
- " } "
- // Test that enum-typed options still work too. (At one point this also
- // failed due to a bug.)
- " uninterpreted_option { "
- " name { "
- " name_part: \"optimize_for\" "
- " is_extension: false "
- " } "
- " identifier_value: \"SPEED\" "
- " } "
- "}"
- ,
- &file_proto));
+ "name: \"custom_options_import.proto\" "
+ "package: \"protobuf_unittest\" "
+ "dependency: \"google/protobuf/unittest_custom_options.proto\" "
+ "options { "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"file_opt1\" "
+ " is_extension: true "
+ " } "
+ " positive_int_value: 1234 "
+ " } "
+ // Test a non-extension option too. (At one point this failed due to a
+ // bug.)
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"java_package\" "
+ " is_extension: false "
+ " } "
+ " string_value: \"foo\" "
+ " } "
+ // Test that enum-typed options still work too. (At one point this also
+ // failed due to a bug.)
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"optimize_for\" "
+ " is_extension: false "
+ " } "
+ " identifier_value: \"SPEED\" "
+ " } "
+ "}",
+ &file_proto));
const FileDescriptor* file = pool.BuildFile(file_proto);
ASSERT_TRUE(file != NULL);
@@ -3116,8 +3130,8 @@
FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != NULL);
- protobuf_unittest::TestMessageWithCustomOptions::descriptor()
- ->file()->CopyTo(&file_proto);
+ protobuf_unittest::TestMessageWithCustomOptions::descriptor()->file()->CopyTo(
+ &file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != NULL);
// The following represents the definition:
@@ -3130,48 +3144,48 @@
// option (complex_opt1).foo3 = 1234;
// }
ASSERT_TRUE(TextFormat::ParseFromString(
- "name: \"custom_options_import.proto\" "
- "package: \"protobuf_unittest\" "
- "dependency: \"google/protobuf/unittest_custom_options.proto\" "
- "message_type { "
- " name: \"Foo\" "
- " options { "
- " uninterpreted_option { "
- " name { "
- " name_part: \"complex_opt1\" "
- " is_extension: true "
- " } "
- " name { "
- " name_part: \"foo\" "
- " is_extension: false "
- " } "
- " positive_int_value: 1234 "
- " } "
- " uninterpreted_option { "
- " name { "
- " name_part: \"complex_opt1\" "
- " is_extension: true "
- " } "
- " name { "
- " name_part: \"foo2\" "
- " is_extension: false "
- " } "
- " positive_int_value: 1234 "
- " } "
- " uninterpreted_option { "
- " name { "
- " name_part: \"complex_opt1\" "
- " is_extension: true "
- " } "
- " name { "
- " name_part: \"foo3\" "
- " is_extension: false "
- " } "
- " positive_int_value: 1234 "
- " } "
- " } "
- "}",
- &file_proto));
+ "name: \"custom_options_import.proto\" "
+ "package: \"protobuf_unittest\" "
+ "dependency: \"google/protobuf/unittest_custom_options.proto\" "
+ "message_type { "
+ " name: \"Foo\" "
+ " options { "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"complex_opt1\" "
+ " is_extension: true "
+ " } "
+ " name { "
+ " name_part: \"foo\" "
+ " is_extension: false "
+ " } "
+ " positive_int_value: 1234 "
+ " } "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"complex_opt1\" "
+ " is_extension: true "
+ " } "
+ " name { "
+ " name_part: \"foo2\" "
+ " is_extension: false "
+ " } "
+ " positive_int_value: 1234 "
+ " } "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"complex_opt1\" "
+ " is_extension: true "
+ " } "
+ " name { "
+ " name_part: \"foo3\" "
+ " is_extension: false "
+ " } "
+ " positive_int_value: 1234 "
+ " } "
+ " } "
+ "}",
+ &file_proto));
const FileDescriptor* file = pool.BuildFile(file_proto);
ASSERT_TRUE(file != NULL);
@@ -3193,8 +3207,8 @@
FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != NULL);
- protobuf_unittest::TestMessageWithCustomOptions::descriptor()
- ->file()->CopyTo(&file_proto);
+ protobuf_unittest::TestMessageWithCustomOptions::descriptor()->file()->CopyTo(
+ &file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != NULL);
// The following represents the definition:
@@ -3207,48 +3221,48 @@
// option (complex_opt1).foo4 = 56;
// }
ASSERT_TRUE(TextFormat::ParseFromString(
- "name: \"custom_options_import.proto\" "
- "package: \"protobuf_unittest\" "
- "dependency: \"google/protobuf/unittest_custom_options.proto\" "
- "message_type { "
- " name: \"Foo\" "
- " options { "
- " uninterpreted_option { "
- " name { "
- " name_part: \"complex_opt1\" "
- " is_extension: true "
- " } "
- " name { "
- " name_part: \"foo4\" "
- " is_extension: false "
- " } "
- " positive_int_value: 12 "
- " } "
- " uninterpreted_option { "
- " name { "
- " name_part: \"complex_opt1\" "
- " is_extension: true "
- " } "
- " name { "
- " name_part: \"foo4\" "
- " is_extension: false "
- " } "
- " positive_int_value: 34 "
- " } "
- " uninterpreted_option { "
- " name { "
- " name_part: \"complex_opt1\" "
- " is_extension: true "
- " } "
- " name { "
- " name_part: \"foo4\" "
- " is_extension: false "
- " } "
- " positive_int_value: 56 "
- " } "
- " } "
- "}",
- &file_proto));
+ "name: \"custom_options_import.proto\" "
+ "package: \"protobuf_unittest\" "
+ "dependency: \"google/protobuf/unittest_custom_options.proto\" "
+ "message_type { "
+ " name: \"Foo\" "
+ " options { "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"complex_opt1\" "
+ " is_extension: true "
+ " } "
+ " name { "
+ " name_part: \"foo4\" "
+ " is_extension: false "
+ " } "
+ " positive_int_value: 12 "
+ " } "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"complex_opt1\" "
+ " is_extension: true "
+ " } "
+ " name { "
+ " name_part: \"foo4\" "
+ " is_extension: false "
+ " } "
+ " positive_int_value: 34 "
+ " } "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"complex_opt1\" "
+ " is_extension: true "
+ " } "
+ " name { "
+ " name_part: \"foo4\" "
+ " is_extension: false "
+ " } "
+ " positive_int_value: 56 "
+ " } "
+ " } "
+ "}",
+ &file_proto));
const FileDescriptor* file = pool.BuildFile(file_proto);
ASSERT_TRUE(file != NULL);
@@ -3273,8 +3287,8 @@
FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != NULL);
- protobuf_unittest::TestMessageWithCustomOptions::descriptor()
- ->file()->CopyTo(&file_proto);
+ protobuf_unittest::TestMessageWithCustomOptions::descriptor()->file()->CopyTo(
+ &file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != NULL);
// The following represents the definition:
@@ -3287,62 +3301,64 @@
// option (complex_opt2).barney = {waldo: 100};
// }
ASSERT_TRUE(TextFormat::ParseFromString(
- "name: \"custom_options_import.proto\" "
- "package: \"protobuf_unittest\" "
- "dependency: \"google/protobuf/unittest_custom_options.proto\" "
- "message_type { "
- " name: \"Foo\" "
- " options { "
- " uninterpreted_option { "
- " name { "
- " name_part: \"complex_opt2\" "
- " is_extension: true "
- " } "
- " name { "
- " name_part: \"barney\" "
- " is_extension: false "
- " } "
- " aggregate_value: \"waldo: 1\" "
- " } "
- " uninterpreted_option { "
- " name { "
- " name_part: \"complex_opt2\" "
- " is_extension: true "
- " } "
- " name { "
- " name_part: \"barney\" "
- " is_extension: false "
- " } "
- " aggregate_value: \"waldo: 10\" "
- " } "
- " uninterpreted_option { "
- " name { "
- " name_part: \"complex_opt2\" "
- " is_extension: true "
- " } "
- " name { "
- " name_part: \"barney\" "
- " is_extension: false "
- " } "
- " aggregate_value: \"waldo: 100\" "
- " } "
- " } "
- "}",
- &file_proto));
+ "name: \"custom_options_import.proto\" "
+ "package: \"protobuf_unittest\" "
+ "dependency: \"google/protobuf/unittest_custom_options.proto\" "
+ "message_type { "
+ " name: \"Foo\" "
+ " options { "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"complex_opt2\" "
+ " is_extension: true "
+ " } "
+ " name { "
+ " name_part: \"barney\" "
+ " is_extension: false "
+ " } "
+ " aggregate_value: \"waldo: 1\" "
+ " } "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"complex_opt2\" "
+ " is_extension: true "
+ " } "
+ " name { "
+ " name_part: \"barney\" "
+ " is_extension: false "
+ " } "
+ " aggregate_value: \"waldo: 10\" "
+ " } "
+ " uninterpreted_option { "
+ " name { "
+ " name_part: \"complex_opt2\" "
+ " is_extension: true "
+ " } "
+ " name { "
+ " name_part: \"barney\" "
+ " is_extension: false "
+ " } "
+ " aggregate_value: \"waldo: 100\" "
+ " } "
+ " } "
+ "}",
+ &file_proto));
const FileDescriptor* file = pool.BuildFile(file_proto);
ASSERT_TRUE(file != NULL);
ASSERT_EQ(1, file->message_type_count());
const MessageOptions& options = file->message_type(0)->options();
- EXPECT_EQ(3, options.GetExtension(
- protobuf_unittest::complex_opt2).barney_size());
- EXPECT_EQ(1,options.GetExtension(
- protobuf_unittest::complex_opt2).barney(0).waldo());
- EXPECT_EQ(10, options.GetExtension(
- protobuf_unittest::complex_opt2).barney(1).waldo());
- EXPECT_EQ(100, options.GetExtension(
- protobuf_unittest::complex_opt2).barney(2).waldo());
+ EXPECT_EQ(3,
+ options.GetExtension(protobuf_unittest::complex_opt2).barney_size());
+ EXPECT_EQ(
+ 1, options.GetExtension(protobuf_unittest::complex_opt2).barney(0).waldo());
+ EXPECT_EQ(
+ 10,
+ options.GetExtension(protobuf_unittest::complex_opt2).barney(1).waldo());
+ EXPECT_EQ(
+ 100,
+ options.GetExtension(protobuf_unittest::complex_opt2).barney(2).waldo());
}
// Check that aggregate options were parsed and saved correctly in
@@ -3353,8 +3369,8 @@
const FieldDescriptor* field = msg->FindFieldByName("fieldname");
const EnumDescriptor* enumd = file->FindEnumTypeByName("AggregateEnum");
const EnumValueDescriptor* enumv = enumd->FindValueByName("VALUE");
- const ServiceDescriptor* service = file->FindServiceByName(
- "AggregateService");
+ const ServiceDescriptor* service =
+ file->FindServiceByName("AggregateService");
const MethodDescriptor* method = service->FindMethodByName("Method");
// Tests for the different types of data embedded in fileopt
@@ -3366,9 +3382,10 @@
EXPECT_EQ("FileExtensionAnnotation",
file_options.file().GetExtension(protobuf_unittest::fileopt).s());
EXPECT_EQ("EmbeddedMessageSetElement",
- file_options.mset().GetExtension(
- protobuf_unittest::AggregateMessageSetElement
- ::message_set_extension).s());
+ file_options.mset()
+ .GetExtension(protobuf_unittest::AggregateMessageSetElement ::
+ message_set_extension)
+ .s());
// Simple tests for all the other types of annotations
EXPECT_EQ("MessageAnnotation",
@@ -3392,16 +3409,16 @@
FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != NULL);
- protobuf_unittest::TestMessageWithCustomOptions::descriptor()
- ->file()->CopyTo(&file_proto);
+ protobuf_unittest::TestMessageWithCustomOptions::descriptor()->file()->CopyTo(
+ &file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != NULL);
pool.AddUnusedImportTrackFile("custom_options_import.proto");
ASSERT_TRUE(TextFormat::ParseFromString(
- "name: \"custom_options_import.proto\" "
- "package: \"protobuf_unittest\" "
- "dependency: \"google/protobuf/unittest_custom_options.proto\" ",
- &file_proto));
+ "name: \"custom_options_import.proto\" "
+ "package: \"protobuf_unittest\" "
+ "dependency: \"google/protobuf/unittest_custom_options.proto\" ",
+ &file_proto));
MockErrorCollector error_collector;
EXPECT_TRUE(pool.BuildFileCollectingErrors(file_proto, &error_collector));
@@ -3427,32 +3444,33 @@
// Add the "required_enum_opt" extension.
FieldDescriptorProto* extension = file_proto.add_extension();
- protobuf_unittest::OldOptionType::descriptor()->file()
- ->FindExtensionByName("required_enum_opt")->CopyTo(extension);
+ protobuf_unittest::OldOptionType::descriptor()
+ ->file()
+ ->FindExtensionByName("required_enum_opt")
+ ->CopyTo(extension);
// Add a test message that uses the "required_enum_opt" option.
DescriptorProto* test_message_type = file_proto.add_message_type();
- protobuf_unittest::TestMessageWithRequiredEnumOption::descriptor()
- ->CopyTo(test_message_type);
+ protobuf_unittest::TestMessageWithRequiredEnumOption::descriptor()->CopyTo(
+ test_message_type);
// Instruct the extension to use NewOptionType instead of
// OldOptionType, and add the descriptor of NewOptionType.
extension->set_type_name(".protobuf_unittest.NewOptionType");
DescriptorProto* new_option_type = file_proto.add_message_type();
- protobuf_unittest::NewOptionType::descriptor()
- ->CopyTo(new_option_type);
+ protobuf_unittest::NewOptionType::descriptor()->CopyTo(new_option_type);
// Replace the value of the "required_enum_opt" option used in the
// test message with an enum value that only exists in NewOptionType.
- ASSERT_TRUE(TextFormat::ParseFromString(
- "uninterpreted_option { "
- " name { "
- " name_part: 'required_enum_opt' "
- " is_extension: true "
- " } "
- " aggregate_value: 'value: NEW_VALUE'"
- "}",
- test_message_type->mutable_options()));
+ ASSERT_TRUE(
+ TextFormat::ParseFromString("uninterpreted_option { "
+ " name { "
+ " name_part: 'required_enum_opt' "
+ " is_extension: true "
+ " } "
+ " aggregate_value: 'value: NEW_VALUE'"
+ "}",
+ test_message_type->mutable_options()));
// Adding the file descriptor to the pool should fail.
EXPECT_TRUE(pool.BuildFile(file_proto) == NULL);
@@ -3558,8 +3576,8 @@
ASSERT_TRUE(TextFormat::ParseFromString(file_text, &file_proto));
MockErrorCollector error_collector;
- EXPECT_TRUE(
- pool_.BuildFileCollectingErrors(file_proto, &error_collector) == NULL);
+ EXPECT_TRUE(pool_.BuildFileCollectingErrors(file_proto, &error_collector) ==
+ NULL);
EXPECT_EQ(expected_errors, error_collector.text_);
}
@@ -3594,57 +3612,57 @@
TEST_F(ValidationErrorTest, AlreadyDefined) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { name: \"Foo\" }"
- "message_type { name: \"Foo\" }",
+ "name: \"foo.proto\" "
+ "message_type { name: \"Foo\" }"
+ "message_type { name: \"Foo\" }",
- "foo.proto: Foo: NAME: \"Foo\" is already defined.\n");
+ "foo.proto: Foo: NAME: \"Foo\" is already defined.\n");
}
TEST_F(ValidationErrorTest, AlreadyDefinedInPackage) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "package: \"foo.bar\" "
- "message_type { name: \"Foo\" }"
- "message_type { name: \"Foo\" }",
+ "name: \"foo.proto\" "
+ "package: \"foo.bar\" "
+ "message_type { name: \"Foo\" }"
+ "message_type { name: \"Foo\" }",
- "foo.proto: foo.bar.Foo: NAME: \"Foo\" is already defined in "
+ "foo.proto: foo.bar.Foo: NAME: \"Foo\" is already defined in "
"\"foo.bar\".\n");
}
TEST_F(ValidationErrorTest, AlreadyDefinedInOtherFile) {
BuildFile(
- "name: \"foo.proto\" "
- "message_type { name: \"Foo\" }");
+ "name: \"foo.proto\" "
+ "message_type { name: \"Foo\" }");
BuildFileWithErrors(
- "name: \"bar.proto\" "
- "message_type { name: \"Foo\" }",
+ "name: \"bar.proto\" "
+ "message_type { name: \"Foo\" }",
- "bar.proto: Foo: NAME: \"Foo\" is already defined in file "
+ "bar.proto: Foo: NAME: \"Foo\" is already defined in file "
"\"foo.proto\".\n");
}
TEST_F(ValidationErrorTest, PackageAlreadyDefined) {
BuildFile(
- "name: \"foo.proto\" "
- "message_type { name: \"foo\" }");
+ "name: \"foo.proto\" "
+ "message_type { name: \"foo\" }");
BuildFileWithErrors(
- "name: \"bar.proto\" "
- "package: \"foo.bar\"",
+ "name: \"bar.proto\" "
+ "package: \"foo.bar\"",
- "bar.proto: foo: NAME: \"foo\" is already defined (as something other "
+ "bar.proto: foo: NAME: \"foo\" is already defined (as something other "
"than a package) in file \"foo.proto\".\n");
}
TEST_F(ValidationErrorTest, EnumValueAlreadyDefinedInParent) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type { name: \"Foo\" value { name: \"FOO\" number: 1 } } "
- "enum_type { name: \"Bar\" value { name: \"FOO\" number: 1 } } ",
+ "name: \"foo.proto\" "
+ "enum_type { name: \"Foo\" value { name: \"FOO\" number: 1 } } "
+ "enum_type { name: \"Bar\" value { name: \"FOO\" number: 1 } } ",
- "foo.proto: FOO: NAME: \"FOO\" is already defined.\n"
- "foo.proto: FOO: NAME: Note that enum values use C++ scoping rules, "
+ "foo.proto: FOO: NAME: \"FOO\" is already defined.\n"
+ "foo.proto: FOO: NAME: Note that enum values use C++ scoping rules, "
"meaning that enum values are siblings of their type, not children of "
"it. Therefore, \"FOO\" must be unique within the global scope, not "
"just within \"Bar\".\n");
@@ -3652,13 +3670,13 @@
TEST_F(ValidationErrorTest, EnumValueAlreadyDefinedInParentNonGlobal) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "package: \"pkg\" "
- "enum_type { name: \"Foo\" value { name: \"FOO\" number: 1 } } "
- "enum_type { name: \"Bar\" value { name: \"FOO\" number: 1 } } ",
+ "name: \"foo.proto\" "
+ "package: \"pkg\" "
+ "enum_type { name: \"Foo\" value { name: \"FOO\" number: 1 } } "
+ "enum_type { name: \"Bar\" value { name: \"FOO\" number: 1 } } ",
- "foo.proto: pkg.FOO: NAME: \"FOO\" is already defined in \"pkg\".\n"
- "foo.proto: pkg.FOO: NAME: Note that enum values use C++ scoping rules, "
+ "foo.proto: pkg.FOO: NAME: \"FOO\" is already defined in \"pkg\".\n"
+ "foo.proto: pkg.FOO: NAME: Note that enum values use C++ scoping rules, "
"meaning that enum values are siblings of their type, not children of "
"it. Therefore, \"FOO\" must be unique within \"pkg\", not just within "
"\"Bar\".\n");
@@ -3666,60 +3684,60 @@
TEST_F(ValidationErrorTest, MissingName) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { }",
+ "name: \"foo.proto\" "
+ "message_type { }",
- "foo.proto: : NAME: Missing name.\n");
+ "foo.proto: : NAME: Missing name.\n");
}
TEST_F(ValidationErrorTest, InvalidName) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { name: \"$\" }",
+ "name: \"foo.proto\" "
+ "message_type { name: \"$\" }",
- "foo.proto: $: NAME: \"$\" is not a valid identifier.\n");
+ "foo.proto: $: NAME: \"$\" is not a valid identifier.\n");
}
TEST_F(ValidationErrorTest, InvalidPackageName) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "package: \"foo.$\"",
+ "name: \"foo.proto\" "
+ "package: \"foo.$\"",
- "foo.proto: foo.$: NAME: \"$\" is not a valid identifier.\n");
+ "foo.proto: foo.$: NAME: \"$\" is not a valid identifier.\n");
}
TEST_F(ValidationErrorTest, MissingFileName) {
- BuildFileWithErrors(
- "",
+ BuildFileWithErrors("",
- ": : OTHER: Missing field: FileDescriptorProto.name.\n");
+ ": : OTHER: Missing field: FileDescriptorProto.name.\n");
}
TEST_F(ValidationErrorTest, DupeDependency) {
BuildFile("name: \"foo.proto\"");
BuildFileWithErrors(
- "name: \"bar.proto\" "
- "dependency: \"foo.proto\" "
- "dependency: \"foo.proto\" ",
+ "name: \"bar.proto\" "
+ "dependency: \"foo.proto\" "
+ "dependency: \"foo.proto\" ",
- "bar.proto: bar.proto: OTHER: Import \"foo.proto\" was listed twice.\n");
+ "bar.proto: foo.proto: IMPORT: Import \"foo.proto\" was listed twice.\n");
}
TEST_F(ValidationErrorTest, UnknownDependency) {
BuildFileWithErrors(
- "name: \"bar.proto\" "
- "dependency: \"foo.proto\" ",
+ "name: \"bar.proto\" "
+ "dependency: \"foo.proto\" ",
- "bar.proto: bar.proto: OTHER: Import \"foo.proto\" has not been loaded.\n");
+ "bar.proto: foo.proto: IMPORT: Import \"foo.proto\" has not been "
+ "loaded.\n");
}
TEST_F(ValidationErrorTest, InvalidPublicDependencyIndex) {
BuildFile("name: \"foo.proto\"");
BuildFileWithErrors(
- "name: \"bar.proto\" "
- "dependency: \"foo.proto\" "
- "public_dependency: 1",
- "bar.proto: bar.proto: OTHER: Invalid public dependency index.\n");
+ "name: \"bar.proto\" "
+ "dependency: \"foo.proto\" "
+ "public_dependency: 1",
+ "bar.proto: bar.proto: OTHER: Invalid public dependency index.\n");
}
TEST_F(ValidationErrorTest, ForeignUnimportedPackageNoCrash) {
@@ -3729,475 +3747,494 @@
// include that parent package in the name (i.e. we do a relative lookup)...
// Yes, really.
BuildFile(
- "name: 'foo.proto' "
- "package: 'outer.foo' ");
+ "name: 'foo.proto' "
+ "package: 'outer.foo' ");
BuildFileWithErrors(
- "name: 'bar.proto' "
- "dependency: 'baz.proto' "
- "package: 'outer.bar' "
- "message_type { "
- " name: 'Bar' "
- " field { name:'bar' number:1 label:LABEL_OPTIONAL type_name:'foo.Foo' }"
- "}",
+ "name: 'bar.proto' "
+ "dependency: 'baz.proto' "
+ "package: 'outer.bar' "
+ "message_type { "
+ " name: 'Bar' "
+ " field { name:'bar' number:1 label:LABEL_OPTIONAL type_name:'foo.Foo' }"
+ "}",
- "bar.proto: bar.proto: OTHER: Import \"baz.proto\" has not been loaded.\n"
- "bar.proto: outer.bar.Bar.bar: TYPE: \"outer.foo\" seems to be defined in "
+ "bar.proto: baz.proto: IMPORT: Import \"baz.proto\" has not been "
+ "loaded.\n"
+ "bar.proto: outer.bar.Bar.bar: TYPE: \"outer.foo\" seems to be defined "
+ "in "
"\"foo.proto\", which is not imported by \"bar.proto\". To use it here, "
"please add the necessary import.\n");
}
TEST_F(ValidationErrorTest, DupeFile) {
BuildFile(
- "name: \"foo.proto\" "
- "message_type { name: \"Foo\" }");
+ "name: \"foo.proto\" "
+ "message_type { name: \"Foo\" }");
// Note: We should *not* get redundant errors about "Foo" already being
// defined.
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { name: \"Foo\" } "
- // Add another type so that the files aren't identical (in which case there
- // would be no error).
- "enum_type { name: \"Bar\" }",
+ "name: \"foo.proto\" "
+ "message_type { name: \"Foo\" } "
+ // Add another type so that the files aren't identical (in which case
+ // there would be no error).
+ "enum_type { name: \"Bar\" }",
- "foo.proto: foo.proto: OTHER: A file with this name is already in the "
+ "foo.proto: foo.proto: OTHER: A file with this name is already in the "
"pool.\n");
}
TEST_F(ValidationErrorTest, FieldInExtensionRange) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name: \"foo\" number: 9 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " field { name: \"bar\" number: 10 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " field { name: \"baz\" number: 19 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " field { name: \"qux\" number: 20 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " extension_range { start: 10 end: 20 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name: \"foo\" number: 9 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "}"
+ " field { name: \"bar\" number: 10 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "}"
+ " field { name: \"baz\" number: 19 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "}"
+ " field { name: \"qux\" number: 20 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "}"
+ " extension_range { start: 10 end: 20 }"
+ "}",
- "foo.proto: Foo.bar: NUMBER: Extension range 10 to 19 includes field "
+ "foo.proto: Foo.bar: NUMBER: Extension range 10 to 19 includes field "
"\"bar\" (10).\n"
- "foo.proto: Foo.baz: NUMBER: Extension range 10 to 19 includes field "
+ "foo.proto: Foo.baz: NUMBER: Extension range 10 to 19 includes field "
"\"baz\" (19).\n");
}
TEST_F(ValidationErrorTest, OverlappingExtensionRanges) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " extension_range { start: 10 end: 20 }"
- " extension_range { start: 20 end: 30 }"
- " extension_range { start: 19 end: 21 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " extension_range { start: 10 end: 20 }"
+ " extension_range { start: 20 end: 30 }"
+ " extension_range { start: 19 end: 21 }"
+ "}",
- "foo.proto: Foo: NUMBER: Extension range 19 to 20 overlaps with "
+ "foo.proto: Foo: NUMBER: Extension range 19 to 20 overlaps with "
"already-defined range 10 to 19.\n"
- "foo.proto: Foo: NUMBER: Extension range 19 to 20 overlaps with "
+ "foo.proto: Foo: NUMBER: Extension range 19 to 20 overlaps with "
"already-defined range 20 to 29.\n");
}
TEST_F(ValidationErrorTest, ReservedFieldError) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name: \"foo\" number: 15 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " reserved_range { start: 10 end: 20 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name: \"foo\" number: 15 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "}"
+ " reserved_range { start: 10 end: 20 }"
+ "}",
- "foo.proto: Foo.foo: NUMBER: Field \"foo\" uses reserved number 15.\n");
+ "foo.proto: Foo.foo: NUMBER: Field \"foo\" uses reserved number 15.\n");
}
TEST_F(ValidationErrorTest, ReservedExtensionRangeError) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " extension_range { start: 10 end: 20 }"
- " reserved_range { start: 5 end: 15 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " extension_range { start: 10 end: 20 }"
+ " reserved_range { start: 5 end: 15 }"
+ "}",
- "foo.proto: Foo: NUMBER: Extension range 10 to 19"
- " overlaps with reserved range 5 to 14.\n");
+ "foo.proto: Foo: NUMBER: Extension range 10 to 19"
+ " overlaps with reserved range 5 to 14.\n");
}
TEST_F(ValidationErrorTest, ReservedExtensionRangeAdjacent) {
BuildFile(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " extension_range { start: 10 end: 20 }"
- " reserved_range { start: 5 end: 10 }"
- "}");
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " extension_range { start: 10 end: 20 }"
+ " reserved_range { start: 5 end: 10 }"
+ "}");
}
TEST_F(ValidationErrorTest, ReservedRangeOverlap) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " reserved_range { start: 10 end: 20 }"
- " reserved_range { start: 5 end: 15 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " reserved_range { start: 10 end: 20 }"
+ " reserved_range { start: 5 end: 15 }"
+ "}",
- "foo.proto: Foo: NUMBER: Reserved range 5 to 14"
- " overlaps with already-defined range 10 to 19.\n");
+ "foo.proto: Foo: NUMBER: Reserved range 5 to 14"
+ " overlaps with already-defined range 10 to 19.\n");
}
TEST_F(ValidationErrorTest, ReservedNameError) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name: \"foo\" number: 15 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " field { name: \"bar\" number: 16 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " field { name: \"baz\" number: 17 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " reserved_name: \"foo\""
- " reserved_name: \"bar\""
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name: \"foo\" number: 15 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "}"
+ " field { name: \"bar\" number: 16 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "}"
+ " field { name: \"baz\" number: 17 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "}"
+ " reserved_name: \"foo\""
+ " reserved_name: \"bar\""
+ "}",
- "foo.proto: Foo.foo: NAME: Field name \"foo\" is reserved.\n"
- "foo.proto: Foo.bar: NAME: Field name \"bar\" is reserved.\n");
+ "foo.proto: Foo.foo: NAME: Field name \"foo\" is reserved.\n"
+ "foo.proto: Foo.bar: NAME: Field name \"bar\" is reserved.\n");
}
TEST_F(ValidationErrorTest, ReservedNameRedundant) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " reserved_name: \"foo\""
- " reserved_name: \"foo\""
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " reserved_name: \"foo\""
+ " reserved_name: \"foo\""
+ "}",
- "foo.proto: foo: NAME: Field name \"foo\" is reserved multiple times.\n");
+ "foo.proto: foo: NAME: Field name \"foo\" is reserved multiple times.\n");
}
TEST_F(ValidationErrorTest, ReservedFieldsDebugString) {
const FileDescriptor* file = BuildFile(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " reserved_name: \"foo\""
- " reserved_name: \"bar\""
- " reserved_range { start: 5 end: 6 }"
- " reserved_range { start: 10 end: 20 }"
- "}");
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " reserved_name: \"foo\""
+ " reserved_name: \"bar\""
+ " reserved_range { start: 5 end: 6 }"
+ " reserved_range { start: 10 end: 20 }"
+ "}");
ASSERT_EQ(
- "syntax = \"proto2\";\n\n"
- "message Foo {\n"
- " reserved 5, 10 to 19;\n"
- " reserved \"foo\", \"bar\";\n"
- "}\n\n",
- file->DebugString());
+ "syntax = \"proto2\";\n\n"
+ "message Foo {\n"
+ " reserved 5, 10 to 19;\n"
+ " reserved \"foo\", \"bar\";\n"
+ "}\n\n",
+ file->DebugString());
}
TEST_F(ValidationErrorTest, EnumReservedFieldError) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Foo\""
- " value { name:\"BAR\" number:15 }"
- " reserved_range { start: 10 end: 20 }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Foo\""
+ " value { name:\"BAR\" number:15 }"
+ " reserved_range { start: 10 end: 20 }"
+ "}",
- "foo.proto: BAR: NUMBER: Enum value \"BAR\" uses reserved number 15.\n");
+ "foo.proto: BAR: NUMBER: Enum value \"BAR\" uses reserved number 15.\n");
}
TEST_F(ValidationErrorTest, EnumNegativeReservedFieldError) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Foo\""
- " value { name:\"BAR\" number:-15 }"
- " reserved_range { start: -20 end: -10 }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Foo\""
+ " value { name:\"BAR\" number:-15 }"
+ " reserved_range { start: -20 end: -10 }"
+ "}",
- "foo.proto: BAR: NUMBER: Enum value \"BAR\" uses reserved number -15.\n");
+ "foo.proto: BAR: NUMBER: Enum value \"BAR\" uses reserved number -15.\n");
}
TEST_F(ValidationErrorTest, EnumReservedRangeOverlap) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Foo\""
- " value { name:\"BAR\" number:0 }"
- " reserved_range { start: 10 end: 20 }"
- " reserved_range { start: 5 end: 15 }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Foo\""
+ " value { name:\"BAR\" number:0 }"
+ " reserved_range { start: 10 end: 20 }"
+ " reserved_range { start: 5 end: 15 }"
+ "}",
- "foo.proto: Foo: NUMBER: Reserved range 5 to 15"
- " overlaps with already-defined range 10 to 20.\n");
+ "foo.proto: Foo: NUMBER: Reserved range 5 to 15"
+ " overlaps with already-defined range 10 to 20.\n");
}
TEST_F(ValidationErrorTest, EnumReservedRangeOverlapByOne) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Foo\""
- " value { name:\"BAR\" number:0 }"
- " reserved_range { start: 10 end: 20 }"
- " reserved_range { start: 5 end: 10 }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Foo\""
+ " value { name:\"BAR\" number:0 }"
+ " reserved_range { start: 10 end: 20 }"
+ " reserved_range { start: 5 end: 10 }"
+ "}",
- "foo.proto: Foo: NUMBER: Reserved range 5 to 10"
- " overlaps with already-defined range 10 to 20.\n");
+ "foo.proto: Foo: NUMBER: Reserved range 5 to 10"
+ " overlaps with already-defined range 10 to 20.\n");
}
TEST_F(ValidationErrorTest, EnumNegativeReservedRangeOverlap) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Foo\""
- " value { name:\"BAR\" number:0 }"
- " reserved_range { start: -20 end: -10 }"
- " reserved_range { start: -15 end: -5 }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Foo\""
+ " value { name:\"BAR\" number:0 }"
+ " reserved_range { start: -20 end: -10 }"
+ " reserved_range { start: -15 end: -5 }"
+ "}",
- "foo.proto: Foo: NUMBER: Reserved range -15 to -5"
- " overlaps with already-defined range -20 to -10.\n");
+ "foo.proto: Foo: NUMBER: Reserved range -15 to -5"
+ " overlaps with already-defined range -20 to -10.\n");
}
TEST_F(ValidationErrorTest, EnumMixedReservedRangeOverlap) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Foo\""
- " value { name:\"BAR\" number:20 }"
- " reserved_range { start: -20 end: 10 }"
- " reserved_range { start: -15 end: 5 }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Foo\""
+ " value { name:\"BAR\" number:20 }"
+ " reserved_range { start: -20 end: 10 }"
+ " reserved_range { start: -15 end: 5 }"
+ "}",
- "foo.proto: Foo: NUMBER: Reserved range -15 to 5"
- " overlaps with already-defined range -20 to 10.\n");
+ "foo.proto: Foo: NUMBER: Reserved range -15 to 5"
+ " overlaps with already-defined range -20 to 10.\n");
}
TEST_F(ValidationErrorTest, EnumMixedReservedRangeOverlap2) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Foo\""
- " value { name:\"BAR\" number:20 }"
- " reserved_range { start: -20 end: 10 }"
- " reserved_range { start: 10 end: 10 }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Foo\""
+ " value { name:\"BAR\" number:20 }"
+ " reserved_range { start: -20 end: 10 }"
+ " reserved_range { start: 10 end: 10 }"
+ "}",
- "foo.proto: Foo: NUMBER: Reserved range 10 to 10"
- " overlaps with already-defined range -20 to 10.\n");
+ "foo.proto: Foo: NUMBER: Reserved range 10 to 10"
+ " overlaps with already-defined range -20 to 10.\n");
}
TEST_F(ValidationErrorTest, EnumReservedRangeStartGreaterThanEnd) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Foo\""
- " value { name:\"BAR\" number:20 }"
- " reserved_range { start: 11 end: 10 }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Foo\""
+ " value { name:\"BAR\" number:20 }"
+ " reserved_range { start: 11 end: 10 }"
+ "}",
- "foo.proto: Foo: NUMBER: Reserved range end number must be greater"
- " than start number.\n");
+ "foo.proto: Foo: NUMBER: Reserved range end number must be greater"
+ " than start number.\n");
}
TEST_F(ValidationErrorTest, EnumReservedNameError) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Foo\""
- " value { name:\"FOO\" number:15 }"
- " value { name:\"BAR\" number:15 }"
- " reserved_name: \"FOO\""
- " reserved_name: \"BAR\""
- "}",
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Foo\""
+ " value { name:\"FOO\" number:15 }"
+ " value { name:\"BAR\" number:15 }"
+ " reserved_name: \"FOO\""
+ " reserved_name: \"BAR\""
+ "}",
- "foo.proto: FOO: NAME: Enum value \"FOO\" is reserved.\n"
- "foo.proto: BAR: NAME: Enum value \"BAR\" is reserved.\n");
+ "foo.proto: FOO: NAME: Enum value \"FOO\" is reserved.\n"
+ "foo.proto: BAR: NAME: Enum value \"BAR\" is reserved.\n");
}
TEST_F(ValidationErrorTest, EnumReservedNameRedundant) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Foo\""
- " value { name:\"FOO\" number:15 }"
- " reserved_name: \"foo\""
- " reserved_name: \"foo\""
- "}",
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Foo\""
+ " value { name:\"FOO\" number:15 }"
+ " reserved_name: \"foo\""
+ " reserved_name: \"foo\""
+ "}",
- "foo.proto: foo: NAME: Enum value \"foo\" is reserved multiple times.\n");
+ "foo.proto: foo: NAME: Enum value \"foo\" is reserved multiple times.\n");
}
TEST_F(ValidationErrorTest, EnumReservedFieldsDebugString) {
const FileDescriptor* file = BuildFile(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Foo\""
- " value { name:\"FOO\" number:3 }"
- " reserved_name: \"foo\""
- " reserved_name: \"bar\""
- " reserved_range { start: -6 end: -6 }"
- " reserved_range { start: -5 end: -4 }"
- " reserved_range { start: -1 end: 1 }"
- " reserved_range { start: 5 end: 5 }"
- " reserved_range { start: 10 end: 19 }"
- "}");
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Foo\""
+ " value { name:\"FOO\" number:3 }"
+ " reserved_name: \"foo\""
+ " reserved_name: \"bar\""
+ " reserved_range { start: -6 end: -6 }"
+ " reserved_range { start: -5 end: -4 }"
+ " reserved_range { start: -1 end: 1 }"
+ " reserved_range { start: 5 end: 5 }"
+ " reserved_range { start: 10 end: 19 }"
+ "}");
ASSERT_EQ(
- "syntax = \"proto2\";\n\n"
- "enum Foo {\n"
- " FOO = 3;\n"
- " reserved -6, -5 to -4, -1 to 1, 5, 10 to 19;\n"
- " reserved \"foo\", \"bar\";\n"
- "}\n\n",
- file->DebugString());
+ "syntax = \"proto2\";\n\n"
+ "enum Foo {\n"
+ " FOO = 3;\n"
+ " reserved -6, -5 to -4, -1 to 1, 5, 10 to 19;\n"
+ " reserved \"foo\", \"bar\";\n"
+ "}\n\n",
+ file->DebugString());
}
TEST_F(ValidationErrorTest, InvalidDefaults) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
- // Invalid number.
- " field { name: \"foo\" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32"
- " default_value: \"abc\" }"
+ // Invalid number.
+ " field { name: \"foo\" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32"
+ " default_value: \"abc\" }"
- // Empty default value.
- " field { name: \"bar\" number: 2 label: LABEL_OPTIONAL type: TYPE_INT32"
- " default_value: \"\" }"
+ // Empty default value.
+ " field { name: \"bar\" number: 2 label: LABEL_OPTIONAL type: TYPE_INT32"
+ " default_value: \"\" }"
- // Invalid boolean.
- " field { name: \"baz\" number: 3 label: LABEL_OPTIONAL type: TYPE_BOOL"
- " default_value: \"abc\" }"
+ // Invalid boolean.
+ " field { name: \"baz\" number: 3 label: LABEL_OPTIONAL type: TYPE_BOOL"
+ " default_value: \"abc\" }"
- // Messages can't have defaults.
- " field { name: \"qux\" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE"
- " default_value: \"abc\" type_name: \"Foo\" }"
+ // Messages can't have defaults.
+ " field { name: \"qux\" number: 4 label: LABEL_OPTIONAL type: "
+ "TYPE_MESSAGE"
+ " default_value: \"abc\" type_name: \"Foo\" }"
- // Same thing, but we don't know that this field has message type until
- // we look up the type name.
- " field { name: \"quux\" number: 5 label: LABEL_OPTIONAL"
- " default_value: \"abc\" type_name: \"Foo\" }"
+ // Same thing, but we don't know that this field has message type until
+ // we look up the type name.
+ " field { name: \"quux\" number: 5 label: LABEL_OPTIONAL"
+ " default_value: \"abc\" type_name: \"Foo\" }"
- // Repeateds can't have defaults.
- " field { name: \"corge\" number: 6 label: LABEL_REPEATED type: TYPE_INT32"
- " default_value: \"1\" }"
- "}",
+ // Repeateds can't have defaults.
+ " field { name: \"corge\" number: 6 label: LABEL_REPEATED type: "
+ "TYPE_INT32"
+ " default_value: \"1\" }"
+ "}",
- "foo.proto: Foo.foo: DEFAULT_VALUE: Couldn't parse default value \"abc\".\n"
- "foo.proto: Foo.bar: DEFAULT_VALUE: Couldn't parse default value \"\".\n"
- "foo.proto: Foo.baz: DEFAULT_VALUE: Boolean default must be true or "
+ "foo.proto: Foo.foo: DEFAULT_VALUE: Couldn't parse default value "
+ "\"abc\".\n"
+ "foo.proto: Foo.bar: DEFAULT_VALUE: Couldn't parse default value \"\".\n"
+ "foo.proto: Foo.baz: DEFAULT_VALUE: Boolean default must be true or "
"false.\n"
- "foo.proto: Foo.qux: DEFAULT_VALUE: Messages can't have default values.\n"
- "foo.proto: Foo.corge: DEFAULT_VALUE: Repeated fields can't have default "
+ "foo.proto: Foo.qux: DEFAULT_VALUE: Messages can't have default values.\n"
+ "foo.proto: Foo.corge: DEFAULT_VALUE: Repeated fields can't have default "
"values.\n"
- // This ends up being reported later because the error is detected at
- // cross-linking time.
- "foo.proto: Foo.quux: DEFAULT_VALUE: Messages can't have default "
+ // This ends up being reported later because the error is detected at
+ // cross-linking time.
+ "foo.proto: Foo.quux: DEFAULT_VALUE: Messages can't have default "
"values.\n");
}
TEST_F(ValidationErrorTest, NegativeFieldNumber) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name: \"foo\" number: -1 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name: \"foo\" number: -1 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ "}"
+ "}",
- "foo.proto: Foo.foo: NUMBER: Field numbers must be positive integers.\n");
+ "foo.proto: Foo.foo: NUMBER: Field numbers must be positive integers.\n");
}
TEST_F(ValidationErrorTest, HugeFieldNumber) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name: \"foo\" number: 0x70000000 "
- " label:LABEL_OPTIONAL type:TYPE_INT32 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name: \"foo\" number: 0x70000000 "
+ " label:LABEL_OPTIONAL type:TYPE_INT32 }"
+ "}",
- "foo.proto: Foo.foo: NUMBER: Field numbers cannot be greater than "
+ "foo.proto: Foo.foo: NUMBER: Field numbers cannot be greater than "
"536870911.\n");
}
TEST_F(ValidationErrorTest, ReservedFieldNumber) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field {name:\"foo\" number: 18999 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " field {name:\"bar\" number: 19000 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " field {name:\"baz\" number: 19999 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " field {name:\"qux\" number: 20000 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field {name:\"foo\" number: 18999 label:LABEL_OPTIONAL "
+ "type:TYPE_INT32 }"
+ " field {name:\"bar\" number: 19000 label:LABEL_OPTIONAL "
+ "type:TYPE_INT32 }"
+ " field {name:\"baz\" number: 19999 label:LABEL_OPTIONAL "
+ "type:TYPE_INT32 }"
+ " field {name:\"qux\" number: 20000 label:LABEL_OPTIONAL "
+ "type:TYPE_INT32 }"
+ "}",
- "foo.proto: Foo.bar: NUMBER: Field numbers 19000 through 19999 are "
+ "foo.proto: Foo.bar: NUMBER: Field numbers 19000 through 19999 are "
"reserved for the protocol buffer library implementation.\n"
- "foo.proto: Foo.baz: NUMBER: Field numbers 19000 through 19999 are "
+ "foo.proto: Foo.baz: NUMBER: Field numbers 19000 through 19999 are "
"reserved for the protocol buffer library implementation.\n");
}
TEST_F(ValidationErrorTest, ExtensionMissingExtendee) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " extension { name: \"foo\" number: 1 label: LABEL_OPTIONAL"
- " type_name: \"Foo\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " extension { name: \"foo\" number: 1 label: LABEL_OPTIONAL"
+ " type_name: \"Foo\" }"
+ "}",
- "foo.proto: Foo.foo: EXTENDEE: FieldDescriptorProto.extendee not set for "
+ "foo.proto: Foo.foo: EXTENDEE: FieldDescriptorProto.extendee not set for "
"extension field.\n");
}
TEST_F(ValidationErrorTest, NonExtensionWithExtendee) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Bar\""
- " extension_range { start: 1 end: 2 }"
- "}"
- "message_type {"
- " name: \"Foo\""
- " field { name: \"foo\" number: 1 label: LABEL_OPTIONAL"
- " type_name: \"Foo\" extendee: \"Bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Bar\""
+ " extension_range { start: 1 end: 2 }"
+ "}"
+ "message_type {"
+ " name: \"Foo\""
+ " field { name: \"foo\" number: 1 label: LABEL_OPTIONAL"
+ " type_name: \"Foo\" extendee: \"Bar\" }"
+ "}",
- "foo.proto: Foo.foo: EXTENDEE: FieldDescriptorProto.extendee set for "
+ "foo.proto: Foo.foo: EXTENDEE: FieldDescriptorProto.extendee set for "
"non-extension field.\n");
}
TEST_F(ValidationErrorTest, FieldOneofIndexTooLarge) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32 "
- " oneof_index: 1 }"
- " field { name:\"dummy\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 "
- " oneof_index: 0 }"
- " oneof_decl { name:\"bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ " oneof_index: 1 }"
+ " field { name:\"dummy\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ " oneof_index: 0 }"
+ " oneof_decl { name:\"bar\" }"
+ "}",
- "foo.proto: Foo.foo: OTHER: FieldDescriptorProto.oneof_index 1 is out of "
+ "foo.proto: Foo.foo: TYPE: FieldDescriptorProto.oneof_index 1 is out of "
"range for type \"Foo\".\n");
}
TEST_F(ValidationErrorTest, FieldOneofIndexNegative) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32 "
- " oneof_index: -1 }"
- " field { name:\"dummy\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 "
- " oneof_index: 0 }"
- " oneof_decl { name:\"bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ " oneof_index: -1 }"
+ " field { name:\"dummy\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 "
+ " oneof_index: 0 }"
+ " oneof_decl { name:\"bar\" }"
+ "}",
- "foo.proto: Foo.foo: OTHER: FieldDescriptorProto.oneof_index -1 is out of "
+ "foo.proto: Foo.foo: TYPE: FieldDescriptorProto.oneof_index -1 is out "
+ "of "
"range for type \"Foo\".\n");
}
@@ -4215,7 +4252,7 @@
" oneof_decl { name:\"foos\" }"
"}",
- "foo.proto: Foo.bar: OTHER: Fields in the same oneof must be defined "
+ "foo.proto: Foo.bar: TYPE: Fields in the same oneof must be defined "
"consecutively. \"bar\" cannot be defined before the completion of the "
"\"foos\" oneof definition.\n");
@@ -4235,10 +4272,10 @@
" oneof_decl { name:\"foos\" }"
" oneof_decl { name:\"bars\" }"
"}",
- "foo2.proto: Foo2.bar1: OTHER: Fields in the same oneof must be defined "
+ "foo2.proto: Foo2.bar1: TYPE: Fields in the same oneof must be defined "
"consecutively. \"bar1\" cannot be defined before the completion of the "
"\"foos\" oneof definition.\n"
- "foo2.proto: Foo2.foo2: OTHER: Fields in the same oneof must be defined "
+ "foo2.proto: Foo2.foo2: TYPE: Fields in the same oneof must be defined "
"consecutively. \"foo2\" cannot be defined before the completion of the "
"\"bars\" oneof definition.\n");
@@ -4257,202 +4294,205 @@
" oneof_decl { name:\"foos\" }"
" oneof_decl { name:\"bars\" }"
"}",
- "foo3.proto: Foo3.baz: OTHER: Fields in the same oneof must be defined "
+ "foo3.proto: Foo3.baz: TYPE: Fields in the same oneof must be defined "
"consecutively. \"baz\" cannot be defined before the completion of the "
"\"foos\" oneof definition.\n");
}
TEST_F(ValidationErrorTest, FieldNumberConflict) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name: \"foo\" number: 1 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " field { name: \"bar\" number: 1 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name: \"foo\" number: 1 label:LABEL_OPTIONAL type:TYPE_INT32 }"
+ " field { name: \"bar\" number: 1 label:LABEL_OPTIONAL type:TYPE_INT32 }"
+ "}",
- "foo.proto: Foo.bar: NUMBER: Field number 1 has already been used in "
+ "foo.proto: Foo.bar: NUMBER: Field number 1 has already been used in "
"\"Foo\" by field \"foo\".\n");
}
TEST_F(ValidationErrorTest, BadMessageSetExtensionType) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"MessageSet\""
- " options { message_set_wire_format: true }"
- " extension_range { start: 4 end: 5 }"
- "}"
- "message_type {"
- " name: \"Foo\""
- " extension { name:\"foo\" number:4 label:LABEL_OPTIONAL type:TYPE_INT32"
- " extendee: \"MessageSet\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"MessageSet\""
+ " options { message_set_wire_format: true }"
+ " extension_range { start: 4 end: 5 }"
+ "}"
+ "message_type {"
+ " name: \"Foo\""
+ " extension { name:\"foo\" number:4 label:LABEL_OPTIONAL type:TYPE_INT32"
+ " extendee: \"MessageSet\" }"
+ "}",
- "foo.proto: Foo.foo: TYPE: Extensions of MessageSets must be optional "
+ "foo.proto: Foo.foo: TYPE: Extensions of MessageSets must be optional "
"messages.\n");
}
TEST_F(ValidationErrorTest, BadMessageSetExtensionLabel) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"MessageSet\""
- " options { message_set_wire_format: true }"
- " extension_range { start: 4 end: 5 }"
- "}"
- "message_type {"
- " name: \"Foo\""
- " extension { name:\"foo\" number:4 label:LABEL_REPEATED type:TYPE_MESSAGE"
- " type_name: \"Foo\" extendee: \"MessageSet\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"MessageSet\""
+ " options { message_set_wire_format: true }"
+ " extension_range { start: 4 end: 5 }"
+ "}"
+ "message_type {"
+ " name: \"Foo\""
+ " extension { name:\"foo\" number:4 label:LABEL_REPEATED "
+ "type:TYPE_MESSAGE"
+ " type_name: \"Foo\" extendee: \"MessageSet\" }"
+ "}",
- "foo.proto: Foo.foo: TYPE: Extensions of MessageSets must be optional "
+ "foo.proto: Foo.foo: TYPE: Extensions of MessageSets must be optional "
"messages.\n");
}
TEST_F(ValidationErrorTest, FieldInMessageSet) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " options { message_set_wire_format: true }"
- " field { name: \"foo\" number: 1 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " options { message_set_wire_format: true }"
+ " field { name: \"foo\" number: 1 label:LABEL_OPTIONAL type:TYPE_INT32 }"
+ "}",
- "foo.proto: Foo.foo: NAME: MessageSets cannot have fields, only "
+ "foo.proto: Foo.foo: NAME: MessageSets cannot have fields, only "
"extensions.\n");
}
TEST_F(ValidationErrorTest, NegativeExtensionRangeNumber) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " extension_range { start: -10 end: -1 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " extension_range { start: -10 end: -1 }"
+ "}",
- "foo.proto: Foo: NUMBER: Extension numbers must be positive integers.\n");
+ "foo.proto: Foo: NUMBER: Extension numbers must be positive integers.\n");
}
TEST_F(ValidationErrorTest, HugeExtensionRangeNumber) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " extension_range { start: 1 end: 0x70000000 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " extension_range { start: 1 end: 0x70000000 }"
+ "}",
- "foo.proto: Foo: NUMBER: Extension numbers cannot be greater than "
+ "foo.proto: Foo: NUMBER: Extension numbers cannot be greater than "
"536870911.\n");
}
TEST_F(ValidationErrorTest, ExtensionRangeEndBeforeStart) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " extension_range { start: 10 end: 10 }"
- " extension_range { start: 10 end: 5 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " extension_range { start: 10 end: 10 }"
+ " extension_range { start: 10 end: 5 }"
+ "}",
- "foo.proto: Foo: NUMBER: Extension range end number must be greater than "
+ "foo.proto: Foo: NUMBER: Extension range end number must be greater than "
"start number.\n"
- "foo.proto: Foo: NUMBER: Extension range end number must be greater than "
+ "foo.proto: Foo: NUMBER: Extension range end number must be greater than "
"start number.\n");
}
TEST_F(ValidationErrorTest, EmptyEnum) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type { name: \"Foo\" }"
- // Also use the empty enum in a message to make sure there are no crashes
- // during validation (possible if the code attempts to derive a default
- // value for the field).
- "message_type {"
- " name: \"Bar\""
- " field { name: \"foo\" number: 1 label:LABEL_OPTIONAL type_name:\"Foo\" }"
- " field { name: \"bar\" number: 2 label:LABEL_OPTIONAL type_name:\"Foo\" "
- " default_value: \"NO_SUCH_VALUE\" }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type { name: \"Foo\" }"
+ // Also use the empty enum in a message to make sure there are no crashes
+ // during validation (possible if the code attempts to derive a default
+ // value for the field).
+ "message_type {"
+ " name: \"Bar\""
+ " field { name: \"foo\" number: 1 label:LABEL_OPTIONAL "
+ "type_name:\"Foo\" }"
+ " field { name: \"bar\" number: 2 label:LABEL_OPTIONAL "
+ "type_name:\"Foo\" "
+ " default_value: \"NO_SUCH_VALUE\" }"
+ "}",
- "foo.proto: Foo: NAME: Enums must contain at least one value.\n"
- "foo.proto: Bar.bar: DEFAULT_VALUE: Enum type \"Foo\" has no value named "
+ "foo.proto: Foo: NAME: Enums must contain at least one value.\n"
+ "foo.proto: Bar.bar: DEFAULT_VALUE: Enum type \"Foo\" has no value named "
"\"NO_SUCH_VALUE\".\n");
}
TEST_F(ValidationErrorTest, UndefinedExtendee) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " extension { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32"
- " extendee: \"Bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " extension { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32"
+ " extendee: \"Bar\" }"
+ "}",
- "foo.proto: Foo.foo: EXTENDEE: \"Bar\" is not defined.\n");
+ "foo.proto: Foo.foo: EXTENDEE: \"Bar\" is not defined.\n");
}
TEST_F(ValidationErrorTest, NonMessageExtendee) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } }"
- "message_type {"
- " name: \"Foo\""
- " extension { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32"
- " extendee: \"Bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } }"
+ "message_type {"
+ " name: \"Foo\""
+ " extension { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32"
+ " extendee: \"Bar\" }"
+ "}",
- "foo.proto: Foo.foo: EXTENDEE: \"Bar\" is not a message type.\n");
+ "foo.proto: Foo.foo: EXTENDEE: \"Bar\" is not a message type.\n");
}
TEST_F(ValidationErrorTest, NotAnExtensionNumber) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Bar\""
- "}"
- "message_type {"
- " name: \"Foo\""
- " extension { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32"
- " extendee: \"Bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Bar\""
+ "}"
+ "message_type {"
+ " name: \"Foo\""
+ " extension { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32"
+ " extendee: \"Bar\" }"
+ "}",
- "foo.proto: Foo.foo: NUMBER: \"Bar\" does not declare 1 as an extension "
+ "foo.proto: Foo.foo: NUMBER: \"Bar\" does not declare 1 as an extension "
"number.\n");
}
TEST_F(ValidationErrorTest, RequiredExtension) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Bar\""
- " extension_range { start: 1000 end: 10000 }"
- "}"
- "message_type {"
- " name: \"Foo\""
- " extension {"
- " name:\"foo\""
- " number:1000"
- " label:LABEL_REQUIRED"
- " type:TYPE_INT32"
- " extendee: \"Bar\""
- " }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Bar\""
+ " extension_range { start: 1000 end: 10000 }"
+ "}"
+ "message_type {"
+ " name: \"Foo\""
+ " extension {"
+ " name:\"foo\""
+ " number:1000"
+ " label:LABEL_REQUIRED"
+ " type:TYPE_INT32"
+ " extendee: \"Bar\""
+ " }"
+ "}",
- "foo.proto: Foo.foo: TYPE: Message extensions cannot have required "
- "fields.\n");
+ "foo.proto: Foo.foo: TYPE: Message extensions cannot have required "
+ "fields.\n");
}
TEST_F(ValidationErrorTest, UndefinedFieldType) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
+ "}",
- "foo.proto: Foo.foo: TYPE: \"Bar\" is not defined.\n");
+ "foo.proto: Foo.foo: TYPE: \"Bar\" is not defined.\n");
}
TEST_F(ValidationErrorTest, UndefinedFieldTypeWithDefault) {
@@ -4461,42 +4501,42 @@
// error message. We want this input to yield a validation error instead,
// since the unknown type is the primary problem.
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"int\" "
- " default_value:\"1\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"int\" "
+ " default_value:\"1\" }"
+ "}",
- "foo.proto: Foo.foo: TYPE: \"int\" is not defined.\n");
+ "foo.proto: Foo.foo: TYPE: \"int\" is not defined.\n");
}
TEST_F(ValidationErrorTest, UndefinedNestedFieldType) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " nested_type { name:\"Baz\" }"
- " field { name:\"foo\" number:1"
- " label:LABEL_OPTIONAL"
- " type_name:\"Foo.Baz.Bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " nested_type { name:\"Baz\" }"
+ " field { name:\"foo\" number:1"
+ " label:LABEL_OPTIONAL"
+ " type_name:\"Foo.Baz.Bar\" }"
+ "}",
- "foo.proto: Foo.foo: TYPE: \"Foo.Baz.Bar\" is not defined.\n");
+ "foo.proto: Foo.foo: TYPE: \"Foo.Baz.Bar\" is not defined.\n");
}
TEST_F(ValidationErrorTest, FieldTypeDefinedInUndeclaredDependency) {
BuildFile(
- "name: \"bar.proto\" "
- "message_type { name: \"Bar\" } ");
+ "name: \"bar.proto\" "
+ "message_type { name: \"Bar\" } ");
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
- "}",
- "foo.proto: Foo.foo: TYPE: \"Bar\" seems to be defined in \"bar.proto\", "
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
+ "}",
+ "foo.proto: Foo.foo: TYPE: \"Bar\" seems to be defined in \"bar.proto\", "
"which is not imported by \"foo.proto\". To use it here, please add the "
"necessary import.\n");
}
@@ -4517,21 +4557,21 @@
// }
//
BuildFile(
- "name: \"bar.proto\" "
- "message_type { name: \"Bar\" }");
+ "name: \"bar.proto\" "
+ "message_type { name: \"Bar\" }");
BuildFile(
- "name: \"forward.proto\""
- "dependency: \"bar.proto\"");
+ "name: \"forward.proto\""
+ "dependency: \"bar.proto\"");
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"forward.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
- "}",
- "foo.proto: Foo.foo: TYPE: \"Bar\" seems to be defined in \"bar.proto\", "
+ "name: \"foo.proto\" "
+ "dependency: \"forward.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
+ "}",
+ "foo.proto: Foo.foo: TYPE: \"Bar\" seems to be defined in \"bar.proto\", "
"which is not imported by \"foo.proto\". To use it here, please add the "
"necessary import.\n");
}
@@ -4554,21 +4594,21 @@
// }
//
BuildFile(
- "name: \"bar.proto\" "
- "message_type { name: \"Bar\" }");
+ "name: \"bar.proto\" "
+ "message_type { name: \"Bar\" }");
BuildFile(
- "name: \"forward.proto\""
- "dependency: \"bar.proto\" "
- "public_dependency: 0");
+ "name: \"forward.proto\""
+ "dependency: \"bar.proto\" "
+ "public_dependency: 0");
BuildFile(
- "name: \"foo.proto\" "
- "dependency: \"forward.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
- "}");
+ "name: \"foo.proto\" "
+ "dependency: \"forward.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
+ "}");
}
TEST_F(ValidationErrorTest, FieldTypeDefinedInTransitivePublicDependency) {
@@ -4590,26 +4630,26 @@
// }
//
BuildFile(
- "name: \"bar.proto\" "
- "message_type { name: \"Bar\" }");
+ "name: \"bar.proto\" "
+ "message_type { name: \"Bar\" }");
BuildFile(
- "name: \"forward.proto\""
- "dependency: \"bar.proto\" "
- "public_dependency: 0");
+ "name: \"forward.proto\""
+ "dependency: \"bar.proto\" "
+ "public_dependency: 0");
BuildFile(
- "name: \"forward2.proto\""
- "dependency: \"forward.proto\" "
- "public_dependency: 0");
+ "name: \"forward2.proto\""
+ "dependency: \"forward.proto\" "
+ "public_dependency: 0");
BuildFile(
- "name: \"foo.proto\" "
- "dependency: \"forward2.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
- "}");
+ "name: \"foo.proto\" "
+ "dependency: \"forward2.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
+ "}");
}
TEST_F(ValidationErrorTest,
@@ -4634,26 +4674,26 @@
// }
//
BuildFile(
- "name: \"bar.proto\" "
- "message_type { name: \"Bar\" }");
+ "name: \"bar.proto\" "
+ "message_type { name: \"Bar\" }");
BuildFile(
- "name: \"forward.proto\""
- "dependency: \"bar.proto\"");
+ "name: \"forward.proto\""
+ "dependency: \"bar.proto\"");
BuildFile(
- "name: \"forward2.proto\""
- "dependency: \"forward.proto\" "
- "public_dependency: 0");
+ "name: \"forward2.proto\""
+ "dependency: \"forward.proto\" "
+ "public_dependency: 0");
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"forward2.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
- "}",
- "foo.proto: Foo.foo: TYPE: \"Bar\" seems to be defined in \"bar.proto\", "
+ "name: \"foo.proto\" "
+ "dependency: \"forward2.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
+ "}",
+ "foo.proto: Foo.foo: TYPE: \"Bar\" seems to be defined in \"bar.proto\", "
"which is not imported by \"foo.proto\". To use it here, please add the "
"necessary import.\n");
}
@@ -4675,22 +4715,22 @@
// fail, and ten try "Bar.Baz" and succeed, even though "Bar" should actually
// refer to the inner Bar, not the outer one.
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Bar\""
- " nested_type { name: \"Baz\" }"
- "}"
- "message_type {"
- " name: \"Foo\""
- " nested_type { name: \"Bar\" }"
- " field { name:\"baz\" number:1 label:LABEL_OPTIONAL"
- " type_name:\"Bar.Baz\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Bar\""
+ " nested_type { name: \"Baz\" }"
+ "}"
+ "message_type {"
+ " name: \"Foo\""
+ " nested_type { name: \"Bar\" }"
+ " field { name:\"baz\" number:1 label:LABEL_OPTIONAL"
+ " type_name:\"Bar.Baz\" }"
+ "}",
- "foo.proto: Foo.baz: TYPE: \"Bar.Baz\" is resolved to \"Foo.Bar.Baz\","
- " which is not defined. The innermost scope is searched first in name "
- "resolution. Consider using a leading '.'(i.e., \".Bar.Baz\") to start "
- "from the outermost scope.\n");
+ "foo.proto: Foo.baz: TYPE: \"Bar.Baz\" is resolved to \"Foo.Bar.Baz\","
+ " which is not defined. The innermost scope is searched first in name "
+ "resolution. Consider using a leading '.'(i.e., \".Bar.Baz\") to start "
+ "from the outermost scope.\n");
}
TEST_F(ValidationErrorTest, SearchMostLocalFirst2) {
@@ -4698,17 +4738,17 @@
// proceeds to find the outer one because the inner one's not an
// aggregate.
BuildFile(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Bar\""
- " nested_type { name: \"Baz\" }"
- "}"
- "message_type {"
- " name: \"Foo\""
- " field { name: \"Bar\" number:1 type:TYPE_BYTES } "
- " field { name:\"baz\" number:2 label:LABEL_OPTIONAL"
- " type_name:\"Bar.Baz\" }"
- "}");
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Bar\""
+ " nested_type { name: \"Baz\" }"
+ "}"
+ "message_type {"
+ " name: \"Foo\""
+ " field { name: \"Bar\" number:1 type:TYPE_BYTES } "
+ " field { name:\"baz\" number:2 label:LABEL_OPTIONAL"
+ " type_name:\"Bar.Baz\" }"
+ "}");
}
TEST_F(ValidationErrorTest, PackageOriginallyDeclaredInTransitiveDependent) {
@@ -4734,349 +4774,348 @@
// prevent it from finding "foo.bar".
BuildFile(
- "name: \"foo.proto\" "
- "package: \"foo.bar\" ");
+ "name: \"foo.proto\" "
+ "package: \"foo.bar\" ");
BuildFile(
- "name: \"bar.proto\" "
- "package: \"foo.bar\" "
- "dependency: \"foo.proto\" "
- "message_type { name: \"Bar\" }");
+ "name: \"bar.proto\" "
+ "package: \"foo.bar\" "
+ "dependency: \"foo.proto\" "
+ "message_type { name: \"Bar\" }");
BuildFile(
- "name: \"baz.proto\" "
- "package: \"foo\" "
- "dependency: \"bar.proto\" "
- "message_type { "
- " name: \"Baz\" "
- " field { name:\"qux\" number:1 label:LABEL_OPTIONAL "
- " type_name:\"bar.Bar\" }"
- "}");
+ "name: \"baz.proto\" "
+ "package: \"foo\" "
+ "dependency: \"bar.proto\" "
+ "message_type { "
+ " name: \"Baz\" "
+ " field { name:\"qux\" number:1 label:LABEL_OPTIONAL "
+ " type_name:\"bar.Bar\" }"
+ "}");
}
TEST_F(ValidationErrorTest, FieldTypeNotAType) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL "
- " type_name:\".Foo.bar\" }"
- " field { name:\"bar\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL "
+ " type_name:\".Foo.bar\" }"
+ " field { name:\"bar\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 }"
+ "}",
- "foo.proto: Foo.foo: TYPE: \".Foo.bar\" is not a type.\n");
+ "foo.proto: Foo.foo: TYPE: \".Foo.bar\" is not a type.\n");
}
TEST_F(ValidationErrorTest, RelativeFieldTypeNotAType) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " nested_type {"
- " name: \"Bar\""
- " field { name:\"Baz\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 }"
- " }"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL "
- " type_name:\"Bar.Baz\" }"
- "}",
- "foo.proto: Foo.foo: TYPE: \"Bar.Baz\" is not a type.\n");
+ "name: \"foo.proto\" "
+ "message_type {"
+ " nested_type {"
+ " name: \"Bar\""
+ " field { name:\"Baz\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 }"
+ " }"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL "
+ " type_name:\"Bar.Baz\" }"
+ "}",
+ "foo.proto: Foo.foo: TYPE: \"Bar.Baz\" is not a type.\n");
}
TEST_F(ValidationErrorTest, FieldTypeMayBeItsName) {
BuildFile(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Bar\""
- "}"
- "message_type {"
- " name: \"Foo\""
- " field { name:\"Bar\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
- "}");
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Bar\""
+ "}"
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"Bar\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }"
+ "}");
}
TEST_F(ValidationErrorTest, EnumFieldTypeIsMessage) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { name: \"Bar\" } "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_ENUM"
- " type_name:\"Bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type { name: \"Bar\" } "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_ENUM"
+ " type_name:\"Bar\" }"
+ "}",
- "foo.proto: Foo.foo: TYPE: \"Bar\" is not an enum type.\n");
+ "foo.proto: Foo.foo: TYPE: \"Bar\" is not an enum type.\n");
}
TEST_F(ValidationErrorTest, MessageFieldTypeIsEnum) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE"
- " type_name:\"Bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE"
+ " type_name:\"Bar\" }"
+ "}",
- "foo.proto: Foo.foo: TYPE: \"Bar\" is not a message type.\n");
+ "foo.proto: Foo.foo: TYPE: \"Bar\" is not a message type.\n");
}
TEST_F(ValidationErrorTest, BadEnumDefaultValue) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\""
- " default_value:\"NO_SUCH_VALUE\" }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\""
+ " default_value:\"NO_SUCH_VALUE\" }"
+ "}",
- "foo.proto: Foo.foo: DEFAULT_VALUE: Enum type \"Bar\" has no value named "
+ "foo.proto: Foo.foo: DEFAULT_VALUE: Enum type \"Bar\" has no value named "
"\"NO_SUCH_VALUE\".\n");
}
TEST_F(ValidationErrorTest, EnumDefaultValueIsInteger) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\""
- " default_value:\"0\" }"
- "}",
+ "name: \"foo.proto\" "
+ "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\""
+ " default_value:\"0\" }"
+ "}",
- "foo.proto: Foo.foo: DEFAULT_VALUE: Default value for an enum field must "
- "be an identifier.\n");
+ "foo.proto: Foo.foo: DEFAULT_VALUE: Default value for an enum field must "
+ "be an identifier.\n");
}
TEST_F(ValidationErrorTest, PrimitiveWithTypeName) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32"
- " type_name:\"Foo\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32"
+ " type_name:\"Foo\" }"
+ "}",
- "foo.proto: Foo.foo: TYPE: Field with primitive type has type_name.\n");
+ "foo.proto: Foo.foo: TYPE: Field with primitive type has type_name.\n");
}
TEST_F(ValidationErrorTest, NonPrimitiveWithoutTypeName) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE }"
+ "}",
- "foo.proto: Foo.foo: TYPE: Field with message or enum type missing "
+ "foo.proto: Foo.foo: TYPE: Field with message or enum type missing "
"type_name.\n");
}
TEST_F(ValidationErrorTest, OneofWithNoFields) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " oneof_decl { name:\"bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " oneof_decl { name:\"bar\" }"
+ "}",
- "foo.proto: Foo.bar: NAME: Oneof must have at least one field.\n");
+ "foo.proto: Foo.bar: NAME: Oneof must have at least one field.\n");
}
TEST_F(ValidationErrorTest, OneofLabelMismatch) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"Foo\""
- " field { name:\"foo\" number:1 label:LABEL_REPEATED type:TYPE_INT32 "
- " oneof_index:0 }"
- " oneof_decl { name:\"bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"Foo\""
+ " field { name:\"foo\" number:1 label:LABEL_REPEATED type:TYPE_INT32 "
+ " oneof_index:0 }"
+ " oneof_decl { name:\"bar\" }"
+ "}",
- "foo.proto: Foo.foo: NAME: Fields of oneofs must themselves have label "
+ "foo.proto: Foo.foo: NAME: Fields of oneofs must themselves have label "
"LABEL_OPTIONAL.\n");
}
TEST_F(ValidationErrorTest, InputTypeNotDefined) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { name: \"Foo\" } "
- "service {"
- " name: \"TestService\""
- " method { name: \"A\" input_type: \"Bar\" output_type: \"Foo\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type { name: \"Foo\" } "
+ "service {"
+ " name: \"TestService\""
+ " method { name: \"A\" input_type: \"Bar\" output_type: \"Foo\" }"
+ "}",
- "foo.proto: TestService.A: INPUT_TYPE: \"Bar\" is not defined.\n"
- );
+ "foo.proto: TestService.A: INPUT_TYPE: \"Bar\" is not defined.\n"
+ );
}
TEST_F(ValidationErrorTest, InputTypeNotAMessage) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { name: \"Foo\" } "
- "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } "
- "service {"
- " name: \"TestService\""
- " method { name: \"A\" input_type: \"Bar\" output_type: \"Foo\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type { name: \"Foo\" } "
+ "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } "
+ "service {"
+ " name: \"TestService\""
+ " method { name: \"A\" input_type: \"Bar\" output_type: \"Foo\" }"
+ "}",
- "foo.proto: TestService.A: INPUT_TYPE: \"Bar\" is not a message type.\n"
- );
+ "foo.proto: TestService.A: INPUT_TYPE: \"Bar\" is not a message type.\n"
+ );
}
TEST_F(ValidationErrorTest, OutputTypeNotDefined) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { name: \"Foo\" } "
- "service {"
- " name: \"TestService\""
- " method { name: \"A\" input_type: \"Foo\" output_type: \"Bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type { name: \"Foo\" } "
+ "service {"
+ " name: \"TestService\""
+ " method { name: \"A\" input_type: \"Foo\" output_type: \"Bar\" }"
+ "}",
- "foo.proto: TestService.A: OUTPUT_TYPE: \"Bar\" is not defined.\n"
- );
+ "foo.proto: TestService.A: OUTPUT_TYPE: \"Bar\" is not defined.\n"
+ );
}
TEST_F(ValidationErrorTest, OutputTypeNotAMessage) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { name: \"Foo\" } "
- "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } "
- "service {"
- " name: \"TestService\""
- " method { name: \"A\" input_type: \"Foo\" output_type: \"Bar\" }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type { name: \"Foo\" } "
+ "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } "
+ "service {"
+ " name: \"TestService\""
+ " method { name: \"A\" input_type: \"Foo\" output_type: \"Bar\" }"
+ "}",
- "foo.proto: TestService.A: OUTPUT_TYPE: \"Bar\" is not a message type.\n"
- );
+ "foo.proto: TestService.A: OUTPUT_TYPE: \"Bar\" is not a message type.\n"
+ );
}
TEST_F(ValidationErrorTest, IllegalPackedField) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {\n"
- " name: \"Foo\""
- " field { name:\"packed_string\" number:1 label:LABEL_REPEATED "
- " type:TYPE_STRING "
- " options { uninterpreted_option {"
- " name { name_part: \"packed\" is_extension: false }"
- " identifier_value: \"true\" }}}\n"
- " field { name:\"packed_message\" number:3 label:LABEL_REPEATED "
- " type_name: \"Foo\""
- " options { uninterpreted_option {"
- " name { name_part: \"packed\" is_extension: false }"
- " identifier_value: \"true\" }}}\n"
- " field { name:\"optional_int32\" number: 4 label: LABEL_OPTIONAL "
- " type:TYPE_INT32 "
- " options { uninterpreted_option {"
- " name { name_part: \"packed\" is_extension: false }"
- " identifier_value: \"true\" }}}\n"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {\n"
+ " name: \"Foo\""
+ " field { name:\"packed_string\" number:1 label:LABEL_REPEATED "
+ " type:TYPE_STRING "
+ " options { uninterpreted_option {"
+ " name { name_part: \"packed\" is_extension: false }"
+ " identifier_value: \"true\" }}}\n"
+ " field { name:\"packed_message\" number:3 label:LABEL_REPEATED "
+ " type_name: \"Foo\""
+ " options { uninterpreted_option {"
+ " name { name_part: \"packed\" is_extension: false }"
+ " identifier_value: \"true\" }}}\n"
+ " field { name:\"optional_int32\" number: 4 label: LABEL_OPTIONAL "
+ " type:TYPE_INT32 "
+ " options { uninterpreted_option {"
+ " name { name_part: \"packed\" is_extension: false }"
+ " identifier_value: \"true\" }}}\n"
+ "}",
- "foo.proto: Foo.packed_string: TYPE: [packed = true] can only be "
- "specified for repeated primitive fields.\n"
- "foo.proto: Foo.packed_message: TYPE: [packed = true] can only be "
- "specified for repeated primitive fields.\n"
- "foo.proto: Foo.optional_int32: TYPE: [packed = true] can only be "
- "specified for repeated primitive fields.\n"
- );
+ "foo.proto: Foo.packed_string: TYPE: [packed = true] can only be "
+ "specified for repeated primitive fields.\n"
+ "foo.proto: Foo.packed_message: TYPE: [packed = true] can only be "
+ "specified for repeated primitive fields.\n"
+ "foo.proto: Foo.optional_int32: TYPE: [packed = true] can only be "
+ "specified for repeated primitive fields.\n");
}
TEST_F(ValidationErrorTest, OptionWrongType) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { "
- " name: \"TestMessage\" "
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_STRING "
- " options { uninterpreted_option { name { name_part: \"ctype\" "
- " is_extension: false }"
- " positive_int_value: 1 }"
- " }"
- " }"
- "}\n",
+ "name: \"foo.proto\" "
+ "message_type { "
+ " name: \"TestMessage\" "
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_STRING "
+ " options { uninterpreted_option { name { name_part: \"ctype\" "
+ " is_extension: false }"
+ " positive_int_value: 1 }"
+ " }"
+ " }"
+ "}\n",
- "foo.proto: TestMessage.foo: OPTION_VALUE: Value must be identifier for "
- "enum-valued option \"google.protobuf.FieldOptions.ctype\".\n");
+ "foo.proto: TestMessage.foo: OPTION_VALUE: Value must be identifier for "
+ "enum-valued option \"google.protobuf.FieldOptions.ctype\".\n");
}
TEST_F(ValidationErrorTest, OptionExtendsAtomicType) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { "
- " name: \"TestMessage\" "
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_STRING "
- " options { uninterpreted_option { name { name_part: \"ctype\" "
- " is_extension: false }"
- " name { name_part: \"foo\" "
- " is_extension: true }"
- " positive_int_value: 1 }"
- " }"
- " }"
- "}\n",
+ "name: \"foo.proto\" "
+ "message_type { "
+ " name: \"TestMessage\" "
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_STRING "
+ " options { uninterpreted_option { name { name_part: \"ctype\" "
+ " is_extension: false }"
+ " name { name_part: \"foo\" "
+ " is_extension: true }"
+ " positive_int_value: 1 }"
+ " }"
+ " }"
+ "}\n",
- "foo.proto: TestMessage.foo: OPTION_NAME: Option \"ctype\" is an "
- "atomic type, not a message.\n");
+ "foo.proto: TestMessage.foo: OPTION_NAME: Option \"ctype\" is an "
+ "atomic type, not a message.\n");
}
TEST_F(ValidationErrorTest, DupOption) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { "
- " name: \"TestMessage\" "
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_UINT32 "
- " options { uninterpreted_option { name { name_part: \"ctype\" "
- " is_extension: false }"
- " identifier_value: \"CORD\" }"
- " uninterpreted_option { name { name_part: \"ctype\" "
- " is_extension: false }"
- " identifier_value: \"CORD\" }"
- " }"
- " }"
- "}\n",
+ "name: \"foo.proto\" "
+ "message_type { "
+ " name: \"TestMessage\" "
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_UINT32 "
+ " options { uninterpreted_option { name { name_part: \"ctype\" "
+ " is_extension: false }"
+ " identifier_value: \"CORD\" }"
+ " uninterpreted_option { name { name_part: \"ctype\" "
+ " is_extension: false }"
+ " identifier_value: \"CORD\" }"
+ " }"
+ " }"
+ "}\n",
- "foo.proto: TestMessage.foo: OPTION_NAME: Option \"ctype\" was "
- "already set.\n");
+ "foo.proto: TestMessage.foo: OPTION_NAME: Option \"ctype\" was "
+ "already set.\n");
}
TEST_F(ValidationErrorTest, InvalidOptionName) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type { "
- " name: \"TestMessage\" "
- " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL "
- " options { uninterpreted_option { "
- " name { name_part: \"uninterpreted_option\" "
- " is_extension: false }"
- " positive_int_value: 1 "
- " }"
- " }"
- " }"
- "}\n",
+ "name: \"foo.proto\" "
+ "message_type { "
+ " name: \"TestMessage\" "
+ " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL "
+ " options { uninterpreted_option { "
+ " name { name_part: \"uninterpreted_option\" "
+ " is_extension: false }"
+ " positive_int_value: 1 "
+ " }"
+ " }"
+ " }"
+ "}\n",
- "foo.proto: TestMessage.foo: OPTION_NAME: Option must not use "
- "reserved name \"uninterpreted_option\".\n");
+ "foo.proto: TestMessage.foo: OPTION_NAME: Option must not use "
+ "reserved name \"uninterpreted_option\".\n");
}
TEST_F(ValidationErrorTest, RepeatedMessageOption) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "message_type: { name: \"Bar\" field: { "
- " name: \"foo\" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32 } "
- "} "
- "extension { name: \"bar\" number: 7672757 label: LABEL_REPEATED "
- " type: TYPE_MESSAGE type_name: \"Bar\" "
- " extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"bar\" "
- " is_extension: true } "
- " name { name_part: \"foo\" "
- " is_extension: false } "
- " positive_int_value: 1 } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "message_type: { name: \"Bar\" field: { "
+ " name: \"foo\" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32 } "
+ "} "
+ "extension { name: \"bar\" number: 7672757 label: LABEL_REPEATED "
+ " type: TYPE_MESSAGE type_name: \"Bar\" "
+ " extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"bar\" "
+ " is_extension: true } "
+ " name { name_part: \"foo\" "
+ " is_extension: false } "
+ " positive_int_value: 1 } }",
- "foo.proto: foo.proto: OPTION_NAME: Option field \"(bar)\" is a "
- "repeated message. Repeated message options must be initialized "
- "using an aggregate value.\n");
+ "foo.proto: foo.proto: OPTION_NAME: Option field \"(bar)\" is a "
+ "repeated message. Repeated message options must be initialized "
+ "using an aggregate value.\n");
}
TEST_F(ValidationErrorTest, ResolveUndefinedOption) {
@@ -5098,299 +5137,301 @@
BuildDescriptorMessagesInTestPool();
BuildFile(
- "name: \"foo.proto\" "
- "package: \"baz\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "message_type: { name: \"Bar\" field: { "
- " name: \"foo\" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32 } "
- "} "
- "extension { name: \"bar\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_MESSAGE type_name: \"Bar\" "
- " extendee: \"google.protobuf.FileOptions\" }");
+ "name: \"foo.proto\" "
+ "package: \"baz\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "message_type: { name: \"Bar\" field: { "
+ " name: \"foo\" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32 } "
+ "} "
+ "extension { name: \"bar\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_MESSAGE type_name: \"Bar\" "
+ " extendee: \"google.protobuf.FileOptions\" }");
BuildFileWithErrors(
- "name: \"qux.proto\" "
- "package: \"qux.baz\" "
- "options { uninterpreted_option { name { name_part: \"baz.bar\" "
- " is_extension: true } "
- " name { name_part: \"foo\" "
- " is_extension: false } "
- " positive_int_value: 1 } }",
+ "name: \"qux.proto\" "
+ "package: \"qux.baz\" "
+ "options { uninterpreted_option { name { name_part: \"baz.bar\" "
+ " is_extension: true } "
+ " name { name_part: \"foo\" "
+ " is_extension: false } "
+ " positive_int_value: 1 } }",
- "qux.proto: qux.proto: OPTION_NAME: Option \"(baz.bar)\" is resolved to "
- "\"(qux.baz.bar)\","
- " which is not defined. The innermost scope is searched first in name "
- "resolution. Consider using a leading '.'(i.e., \"(.baz.bar)\") to start "
- "from the outermost scope.\n");
+ "qux.proto: qux.proto: OPTION_NAME: Option \"(baz.bar)\" is resolved to "
+ "\"(qux.baz.bar)\","
+ " which is not defined. The innermost scope is searched first in name "
+ "resolution. Consider using a leading '.'(i.e., \"(.baz.bar)\") to start "
+ "from the outermost scope.\n");
}
TEST_F(ValidationErrorTest, UnknownOption) {
BuildFileWithErrors(
- "name: \"qux.proto\" "
- "package: \"qux.baz\" "
- "options { uninterpreted_option { name { name_part: \"baaz.bar\" "
- " is_extension: true } "
- " name { name_part: \"foo\" "
- " is_extension: false } "
- " positive_int_value: 1 } }",
+ "name: \"qux.proto\" "
+ "package: \"qux.baz\" "
+ "options { uninterpreted_option { name { name_part: \"baaz.bar\" "
+ " is_extension: true } "
+ " name { name_part: \"foo\" "
+ " is_extension: false } "
+ " positive_int_value: 1 } }",
- "qux.proto: qux.proto: OPTION_NAME: Option \"(baaz.bar)\" unknown. Ensure "
- "that your proto definition file imports the proto which defines the "
- "option.\n");
+ "qux.proto: qux.proto: OPTION_NAME: Option \"(baaz.bar)\" unknown. "
+ "Ensure "
+ "that your proto definition file imports the proto which defines the "
+ "option.\n");
}
TEST_F(ValidationErrorTest, CustomOptionConflictingFieldNumber) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo1\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_INT32 extendee: \"google.protobuf.FieldOptions\" }"
- "extension { name: \"foo2\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_INT32 extendee: \"google.protobuf.FieldOptions\" }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo1\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_INT32 extendee: \"google.protobuf.FieldOptions\" }"
+ "extension { name: \"foo2\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_INT32 extendee: \"google.protobuf.FieldOptions\" }",
- "foo.proto: foo2: NUMBER: Extension number 7672757 has already been used "
- "in \"google.protobuf.FieldOptions\" by extension \"foo1\".\n");
+ "foo.proto: foo2: NUMBER: Extension number 7672757 has already been used "
+ "in \"google.protobuf.FieldOptions\" by extension \"foo1\".\n");
}
TEST_F(ValidationErrorTest, Int32OptionValueOutOfPositiveRange) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_INT32 extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " positive_int_value: 0x80000000 } "
- "}",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_INT32 extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " positive_int_value: 0x80000000 } "
+ "}",
- "foo.proto: foo.proto: OPTION_VALUE: Value out of range "
- "for int32 option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value out of range "
+ "for int32 option \"foo\".\n");
}
TEST_F(ValidationErrorTest, Int32OptionValueOutOfNegativeRange) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_INT32 extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " negative_int_value: -0x80000001 } "
- "}",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_INT32 extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " negative_int_value: -0x80000001 } "
+ "}",
- "foo.proto: foo.proto: OPTION_VALUE: Value out of range "
- "for int32 option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value out of range "
+ "for int32 option \"foo\".\n");
}
TEST_F(ValidationErrorTest, Int32OptionValueIsNotPositiveInt) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_INT32 extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " string_value: \"5\" } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_INT32 extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " string_value: \"5\" } }",
- "foo.proto: foo.proto: OPTION_VALUE: Value must be integer "
- "for int32 option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value must be integer "
+ "for int32 option \"foo\".\n");
}
TEST_F(ValidationErrorTest, Int64OptionValueOutOfRange) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_INT64 extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " positive_int_value: 0x8000000000000000 } "
- "}",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_INT64 extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " positive_int_value: 0x8000000000000000 "
+ "} "
+ "}",
- "foo.proto: foo.proto: OPTION_VALUE: Value out of range "
- "for int64 option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value out of range "
+ "for int64 option \"foo\".\n");
}
TEST_F(ValidationErrorTest, Int64OptionValueIsNotPositiveInt) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_INT64 extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " identifier_value: \"5\" } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_INT64 extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " identifier_value: \"5\" } }",
- "foo.proto: foo.proto: OPTION_VALUE: Value must be integer "
- "for int64 option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value must be integer "
+ "for int64 option \"foo\".\n");
}
TEST_F(ValidationErrorTest, UInt32OptionValueOutOfRange) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_UINT32 extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " positive_int_value: 0x100000000 } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_UINT32 extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " positive_int_value: 0x100000000 } }",
- "foo.proto: foo.proto: OPTION_VALUE: Value out of range "
- "for uint32 option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value out of range "
+ "for uint32 option \"foo\".\n");
}
TEST_F(ValidationErrorTest, UInt32OptionValueIsNotPositiveInt) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_UINT32 extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " double_value: -5.6 } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_UINT32 extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " double_value: -5.6 } }",
- "foo.proto: foo.proto: OPTION_VALUE: Value must be non-negative integer "
- "for uint32 option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value must be non-negative integer "
+ "for uint32 option \"foo\".\n");
}
TEST_F(ValidationErrorTest, UInt64OptionValueIsNotPositiveInt) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_UINT64 extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " negative_int_value: -5 } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_UINT64 extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " negative_int_value: -5 } }",
- "foo.proto: foo.proto: OPTION_VALUE: Value must be non-negative integer "
- "for uint64 option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value must be non-negative integer "
+ "for uint64 option \"foo\".\n");
}
TEST_F(ValidationErrorTest, FloatOptionValueIsNotNumber) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_FLOAT extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " string_value: \"bar\" } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_FLOAT extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " string_value: \"bar\" } }",
- "foo.proto: foo.proto: OPTION_VALUE: Value must be number "
- "for float option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value must be number "
+ "for float option \"foo\".\n");
}
TEST_F(ValidationErrorTest, DoubleOptionValueIsNotNumber) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_DOUBLE extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " string_value: \"bar\" } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_DOUBLE extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " string_value: \"bar\" } }",
- "foo.proto: foo.proto: OPTION_VALUE: Value must be number "
- "for double option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value must be number "
+ "for double option \"foo\".\n");
}
TEST_F(ValidationErrorTest, BoolOptionValueIsNotTrueOrFalse) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_BOOL extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " identifier_value: \"bar\" } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_BOOL extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " identifier_value: \"bar\" } }",
- "foo.proto: foo.proto: OPTION_VALUE: Value must be \"true\" or \"false\" "
- "for boolean option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value must be \"true\" or \"false\" "
+ "for boolean option \"foo\".\n");
}
TEST_F(ValidationErrorTest, EnumOptionValueIsNotIdentifier) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "enum_type { name: \"FooEnum\" value { name: \"BAR\" number: 1 } "
- " value { name: \"BAZ\" number: 2 } }"
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_ENUM type_name: \"FooEnum\" "
- " extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " string_value: \"QUUX\" } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "enum_type { name: \"FooEnum\" value { name: \"BAR\" number: 1 } "
+ " value { name: \"BAZ\" number: 2 } }"
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_ENUM type_name: \"FooEnum\" "
+ " extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " string_value: \"QUUX\" } }",
- "foo.proto: foo.proto: OPTION_VALUE: Value must be identifier for "
- "enum-valued option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Value must be identifier for "
+ "enum-valued option \"foo\".\n");
}
TEST_F(ValidationErrorTest, EnumOptionValueIsNotEnumValueName) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "enum_type { name: \"FooEnum\" value { name: \"BAR\" number: 1 } "
- " value { name: \"BAZ\" number: 2 } }"
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_ENUM type_name: \"FooEnum\" "
- " extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " identifier_value: \"QUUX\" } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "enum_type { name: \"FooEnum\" value { name: \"BAR\" number: 1 } "
+ " value { name: \"BAZ\" number: 2 } }"
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_ENUM type_name: \"FooEnum\" "
+ " extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " identifier_value: \"QUUX\" } }",
- "foo.proto: foo.proto: OPTION_VALUE: Enum type \"FooEnum\" has no value "
- "named \"QUUX\" for option \"foo\".\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Enum type \"FooEnum\" has no value "
+ "named \"QUUX\" for option \"foo\".\n");
}
TEST_F(ValidationErrorTest, EnumOptionValueIsSiblingEnumValueName) {
BuildDescriptorMessagesInTestPool();
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"google/protobuf/descriptor.proto\" "
- "enum_type { name: \"FooEnum1\" value { name: \"BAR\" number: 1 } "
- " value { name: \"BAZ\" number: 2 } }"
- "enum_type { name: \"FooEnum2\" value { name: \"QUX\" number: 1 } "
- " value { name: \"QUUX\" number: 2 } }"
- "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
- " type: TYPE_ENUM type_name: \"FooEnum1\" "
- " extendee: \"google.protobuf.FileOptions\" }"
- "options { uninterpreted_option { name { name_part: \"foo\" "
- " is_extension: true } "
- " identifier_value: \"QUUX\" } }",
+ "name: \"foo.proto\" "
+ "dependency: \"google/protobuf/descriptor.proto\" "
+ "enum_type { name: \"FooEnum1\" value { name: \"BAR\" number: 1 } "
+ " value { name: \"BAZ\" number: 2 } }"
+ "enum_type { name: \"FooEnum2\" value { name: \"QUX\" number: 1 } "
+ " value { name: \"QUUX\" number: 2 } }"
+ "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL "
+ " type: TYPE_ENUM type_name: \"FooEnum1\" "
+ " extendee: \"google.protobuf.FileOptions\" }"
+ "options { uninterpreted_option { name { name_part: \"foo\" "
+ " is_extension: true } "
+ " identifier_value: \"QUUX\" } }",
- "foo.proto: foo.proto: OPTION_VALUE: Enum type \"FooEnum1\" has no value "
- "named \"QUUX\" for option \"foo\". This appears to be a value from a "
- "sibling type.\n");
+ "foo.proto: foo.proto: OPTION_VALUE: Enum type \"FooEnum1\" has no value "
+ "named \"QUUX\" for option \"foo\". This appears to be a value from a "
+ "sibling type.\n");
}
TEST_F(ValidationErrorTest, StringOptionValueIsNotString) {
@@ -5412,22 +5453,22 @@
TEST_F(ValidationErrorTest, JsonNameOptionOnExtensions) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "package: \"foo\" "
- "message_type {"
- " name: \"Foo\""
- " extension_range { start: 10 end: 20 }"
- "}"
- "extension {"
- " name: \"value\""
- " number: 10"
- " label: LABEL_OPTIONAL"
- " type: TYPE_INT32"
- " extendee: \"foo.Foo\""
- " json_name: \"myName\""
- "}",
- "foo.proto: foo.value: OPTION_NAME: option json_name is not allowed on "
- "extension fields.\n");
+ "name: \"foo.proto\" "
+ "package: \"foo\" "
+ "message_type {"
+ " name: \"Foo\""
+ " extension_range { start: 10 end: 20 }"
+ "}"
+ "extension {"
+ " name: \"value\""
+ " number: 10"
+ " label: LABEL_OPTIONAL"
+ " type: TYPE_INT32"
+ " extendee: \"foo.Foo\""
+ " json_name: \"myName\""
+ "}",
+ "foo.proto: foo.value: OPTION_NAME: option json_name is not allowed on "
+ "extension fields.\n");
}
TEST_F(ValidationErrorTest, DuplicateExtensionFieldNumber) {
@@ -5497,60 +5538,60 @@
TEST_F(ValidationErrorTest, NotLiteImportsLite) {
BuildFile(
- "name: \"bar.proto\" "
- "options { optimize_for: LITE_RUNTIME } ");
+ "name: \"bar.proto\" "
+ "options { optimize_for: LITE_RUNTIME } ");
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"bar.proto\" ",
+ "name: \"foo.proto\" "
+ "dependency: \"bar.proto\" ",
- "foo.proto: foo.proto: OTHER: Files that do not use optimize_for = "
+ "foo.proto: bar.proto: IMPORT: Files that do not use optimize_for = "
"LITE_RUNTIME cannot import files which do use this option. This file "
"is not lite, but it imports \"bar.proto\" which is.\n");
}
TEST_F(ValidationErrorTest, LiteExtendsNotLite) {
BuildFile(
- "name: \"bar.proto\" "
- "message_type: {"
- " name: \"Bar\""
- " extension_range { start: 1 end: 1000 }"
- "}");
+ "name: \"bar.proto\" "
+ "message_type: {"
+ " name: \"Bar\""
+ " extension_range { start: 1 end: 1000 }"
+ "}");
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "dependency: \"bar.proto\" "
- "options { optimize_for: LITE_RUNTIME } "
- "extension { name: \"ext\" number: 123 label: LABEL_OPTIONAL "
- " type: TYPE_INT32 extendee: \"Bar\" }",
+ "name: \"foo.proto\" "
+ "dependency: \"bar.proto\" "
+ "options { optimize_for: LITE_RUNTIME } "
+ "extension { name: \"ext\" number: 123 label: LABEL_OPTIONAL "
+ " type: TYPE_INT32 extendee: \"Bar\" }",
- "foo.proto: ext: EXTENDEE: Extensions to non-lite types can only be "
+ "foo.proto: ext: EXTENDEE: Extensions to non-lite types can only be "
"declared in non-lite files. Note that you cannot extend a non-lite "
"type to contain a lite type, but the reverse is allowed.\n");
}
TEST_F(ValidationErrorTest, NoLiteServices) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "options {"
- " optimize_for: LITE_RUNTIME"
- " cc_generic_services: true"
- " java_generic_services: true"
- "} "
- "service { name: \"Foo\" }",
+ "name: \"foo.proto\" "
+ "options {"
+ " optimize_for: LITE_RUNTIME"
+ " cc_generic_services: true"
+ " java_generic_services: true"
+ "} "
+ "service { name: \"Foo\" }",
- "foo.proto: Foo: NAME: Files with optimize_for = LITE_RUNTIME cannot "
- "define services unless you set both options cc_generic_services and "
- "java_generic_sevices to false.\n");
+ "foo.proto: Foo: NAME: Files with optimize_for = LITE_RUNTIME cannot "
+ "define services unless you set both options cc_generic_services and "
+ "java_generic_sevices to false.\n");
BuildFile(
- "name: \"bar.proto\" "
- "options {"
- " optimize_for: LITE_RUNTIME"
- " cc_generic_services: false"
- " java_generic_services: false"
- "} "
- "service { name: \"Bar\" }");
+ "name: \"bar.proto\" "
+ "options {"
+ " optimize_for: LITE_RUNTIME"
+ " cc_generic_services: false"
+ " java_generic_services: false"
+ "} "
+ "service { name: \"Bar\" }");
}
TEST_F(ValidationErrorTest, RollbackAfterError) {
@@ -5559,47 +5600,47 @@
// before the undefined type error is noticed. The DescriptorPool will then
// have to roll everything back.
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 }"
- "} "
- "enum_type {"
- " name: \"TestEnum\""
- " value { name:\"BAR\" number:1 }"
- "} "
- "service {"
- " name: \"TestService\""
- " method {"
- " name: \"Baz\""
- " input_type: \"NoSuchType\"" // error
- " output_type: \"TestMessage\""
- " }"
- "}",
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 }"
+ "} "
+ "enum_type {"
+ " name: \"TestEnum\""
+ " value { name:\"BAR\" number:1 }"
+ "} "
+ "service {"
+ " name: \"TestService\""
+ " method {"
+ " name: \"Baz\""
+ " input_type: \"NoSuchType\"" // error
+ " output_type: \"TestMessage\""
+ " }"
+ "}",
- "foo.proto: TestService.Baz: INPUT_TYPE: \"NoSuchType\" is not defined.\n"
- );
+ "foo.proto: TestService.Baz: INPUT_TYPE: \"NoSuchType\" is not defined.\n"
+ );
// Make sure that if we build the same file again with the error fixed,
// it works. If the above rollback was incomplete, then some symbols will
// be left defined, and this second attempt will fail since it tries to
// re-define the same symbols.
BuildFile(
- "name: \"foo.proto\" "
- "message_type {"
- " name: \"TestMessage\""
- " field { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 }"
- "} "
- "enum_type {"
- " name: \"TestEnum\""
- " value { name:\"BAR\" number:1 }"
- "} "
- "service {"
- " name: \"TestService\""
- " method { name:\"Baz\""
- " input_type:\"TestMessage\""
- " output_type:\"TestMessage\" }"
- "}");
+ "name: \"foo.proto\" "
+ "message_type {"
+ " name: \"TestMessage\""
+ " field { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 }"
+ "} "
+ "enum_type {"
+ " name: \"TestEnum\""
+ " value { name:\"BAR\" number:1 }"
+ "} "
+ "service {"
+ " name: \"TestService\""
+ " method { name:\"Baz\""
+ " input_type:\"TestMessage\""
+ " output_type:\"TestMessage\" }"
+ "}");
}
TEST_F(ValidationErrorTest, ErrorsReportedToLogError) {
@@ -5607,11 +5648,11 @@
// provided.
FileDescriptorProto file_proto;
- ASSERT_TRUE(TextFormat::ParseFromString(
- "name: \"foo.proto\" "
- "message_type { name: \"Foo\" } "
- "message_type { name: \"Foo\" } ",
- &file_proto));
+ ASSERT_TRUE(
+ TextFormat::ParseFromString("name: \"foo.proto\" "
+ "message_type { name: \"Foo\" } "
+ "message_type { name: \"Foo\" } ",
+ &file_proto));
std::vector<std::string> errors;
@@ -5629,50 +5670,50 @@
TEST_F(ValidationErrorTest, DisallowEnumAlias) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Bar\""
- " value { name:\"ENUM_A\" number:0 }"
- " value { name:\"ENUM_B\" number:0 }"
- "}",
- "foo.proto: Bar: NUMBER: "
- "\"ENUM_B\" uses the same enum value as \"ENUM_A\". "
- "If this is intended, set 'option allow_alias = true;' to the enum "
- "definition.\n");
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Bar\""
+ " value { name:\"ENUM_A\" number:0 }"
+ " value { name:\"ENUM_B\" number:0 }"
+ "}",
+ "foo.proto: Bar: NUMBER: "
+ "\"ENUM_B\" uses the same enum value as \"ENUM_A\". "
+ "If this is intended, set 'option allow_alias = true;' to the enum "
+ "definition.\n");
}
TEST_F(ValidationErrorTest, AllowEnumAlias) {
BuildFile(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Bar\""
- " value { name:\"ENUM_A\" number:0 }"
- " value { name:\"ENUM_B\" number:0 }"
- " options { allow_alias: true }"
- "}");
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Bar\""
+ " value { name:\"ENUM_A\" number:0 }"
+ " value { name:\"ENUM_B\" number:0 }"
+ " options { allow_alias: true }"
+ "}");
}
TEST_F(ValidationErrorTest, UnusedImportWarning) {
pool_.AddUnusedImportTrackFile("bar.proto");
BuildFile(
- "name: \"bar.proto\" "
- "message_type { name: \"Bar\" }");
+ "name: \"bar.proto\" "
+ "message_type { name: \"Bar\" }");
pool_.AddUnusedImportTrackFile("base.proto");
BuildFile(
- "name: \"base.proto\" "
- "message_type { name: \"Base\" }");
+ "name: \"base.proto\" "
+ "message_type { name: \"Base\" }");
pool_.AddUnusedImportTrackFile("baz.proto");
BuildFile(
- "name: \"baz.proto\" "
- "message_type { name: \"Baz\" }");
+ "name: \"baz.proto\" "
+ "message_type { name: \"Baz\" }");
pool_.AddUnusedImportTrackFile("public.proto");
BuildFile(
- "name: \"public.proto\" "
- "dependency: \"bar.proto\""
- "public_dependency: 0");
+ "name: \"public.proto\" "
+ "dependency: \"bar.proto\""
+ "public_dependency: 0");
// // forward.proto
// import "base.proto" // No warning: Base message is used.
@@ -5685,17 +5726,18 @@
//
pool_.AddUnusedImportTrackFile("forward.proto");
BuildFileWithWarnings(
- "name: \"forward.proto\""
- "dependency: \"base.proto\""
- "dependency: \"bar.proto\""
- "dependency: \"baz.proto\""
- "dependency: \"public.proto\""
- "public_dependency: 2 "
- "message_type {"
- " name: \"Forward\""
- " field { name:\"base\" number:1 label:LABEL_OPTIONAL type_name:\"Base\" }"
- "}",
- "forward.proto: bar.proto: OTHER: Import bar.proto but not used.\n");
+ "name: \"forward.proto\""
+ "dependency: \"base.proto\""
+ "dependency: \"bar.proto\""
+ "dependency: \"baz.proto\""
+ "dependency: \"public.proto\""
+ "public_dependency: 2 "
+ "message_type {"
+ " name: \"Forward\""
+ " field { name:\"base\" number:1 label:LABEL_OPTIONAL "
+ "type_name:\"Base\" }"
+ "}",
+ "forward.proto: bar.proto: IMPORT: Import bar.proto but not used.\n");
}
namespace {
@@ -5726,7 +5768,7 @@
file_proto));
}
static const char* kMapEntryErrorMessage =
- "foo.proto: Foo.foo_map: OTHER: map_entry should not be set explicitly. "
+ "foo.proto: Foo.foo_map: TYPE: map_entry should not be set explicitly. "
"Use map<KeyType, ValueType> instead.\n";
static const char* kMapEntryKeyTypeErrorMessage =
"foo.proto: Foo.foo_map: TYPE: Key in map fields cannot be float/double, "
@@ -5830,9 +5872,9 @@
TEST_F(ValidationErrorTest, MapEntryKeyName) {
FileDescriptorProto file_proto;
FillValidMapEntry(&file_proto);
- FieldDescriptorProto* key = file_proto.mutable_message_type(0)
- ->mutable_nested_type(0)
- ->mutable_field(0);
+ FieldDescriptorProto* key =
+ file_proto.mutable_message_type(0)->mutable_nested_type(0)->mutable_field(
+ 0);
key->set_name("Key");
BuildFileWithErrors(file_proto.DebugString(), kMapEntryErrorMessage);
}
@@ -5840,9 +5882,9 @@
TEST_F(ValidationErrorTest, MapEntryKeyLabel) {
FileDescriptorProto file_proto;
FillValidMapEntry(&file_proto);
- FieldDescriptorProto* key = file_proto.mutable_message_type(0)
- ->mutable_nested_type(0)
- ->mutable_field(0);
+ FieldDescriptorProto* key =
+ file_proto.mutable_message_type(0)->mutable_nested_type(0)->mutable_field(
+ 0);
key->set_label(FieldDescriptorProto::LABEL_REQUIRED);
BuildFileWithErrors(file_proto.DebugString(), kMapEntryErrorMessage);
}
@@ -5850,9 +5892,9 @@
TEST_F(ValidationErrorTest, MapEntryKeyNumber) {
FileDescriptorProto file_proto;
FillValidMapEntry(&file_proto);
- FieldDescriptorProto* key = file_proto.mutable_message_type(0)
- ->mutable_nested_type(0)
- ->mutable_field(0);
+ FieldDescriptorProto* key =
+ file_proto.mutable_message_type(0)->mutable_nested_type(0)->mutable_field(
+ 0);
key->set_number(3);
BuildFileWithErrors(file_proto.DebugString(), kMapEntryErrorMessage);
}
@@ -5860,9 +5902,9 @@
TEST_F(ValidationErrorTest, MapEntryValueName) {
FileDescriptorProto file_proto;
FillValidMapEntry(&file_proto);
- FieldDescriptorProto* value = file_proto.mutable_message_type(0)
- ->mutable_nested_type(0)
- ->mutable_field(1);
+ FieldDescriptorProto* value =
+ file_proto.mutable_message_type(0)->mutable_nested_type(0)->mutable_field(
+ 1);
value->set_name("Value");
BuildFileWithErrors(file_proto.DebugString(), kMapEntryErrorMessage);
}
@@ -5870,9 +5912,9 @@
TEST_F(ValidationErrorTest, MapEntryValueLabel) {
FileDescriptorProto file_proto;
FillValidMapEntry(&file_proto);
- FieldDescriptorProto* value = file_proto.mutable_message_type(0)
- ->mutable_nested_type(0)
- ->mutable_field(1);
+ FieldDescriptorProto* value =
+ file_proto.mutable_message_type(0)->mutable_nested_type(0)->mutable_field(
+ 1);
value->set_label(FieldDescriptorProto::LABEL_REQUIRED);
BuildFileWithErrors(file_proto.DebugString(), kMapEntryErrorMessage);
}
@@ -5880,9 +5922,9 @@
TEST_F(ValidationErrorTest, MapEntryValueNumber) {
FileDescriptorProto file_proto;
FillValidMapEntry(&file_proto);
- FieldDescriptorProto* value = file_proto.mutable_message_type(0)
- ->mutable_nested_type(0)
- ->mutable_field(1);
+ FieldDescriptorProto* value =
+ file_proto.mutable_message_type(0)->mutable_nested_type(0)->mutable_field(
+ 1);
value->set_number(3);
BuildFileWithErrors(file_proto.DebugString(), kMapEntryErrorMessage);
}
@@ -5890,9 +5932,9 @@
TEST_F(ValidationErrorTest, MapEntryKeyTypeFloat) {
FileDescriptorProto file_proto;
FillValidMapEntry(&file_proto);
- FieldDescriptorProto* key = file_proto.mutable_message_type(0)
- ->mutable_nested_type(0)
- ->mutable_field(0);
+ FieldDescriptorProto* key =
+ file_proto.mutable_message_type(0)->mutable_nested_type(0)->mutable_field(
+ 0);
key->set_type(FieldDescriptorProto::TYPE_FLOAT);
BuildFileWithErrors(file_proto.DebugString(), kMapEntryKeyTypeErrorMessage);
}
@@ -5900,9 +5942,9 @@
TEST_F(ValidationErrorTest, MapEntryKeyTypeDouble) {
FileDescriptorProto file_proto;
FillValidMapEntry(&file_proto);
- FieldDescriptorProto* key = file_proto.mutable_message_type(0)
- ->mutable_nested_type(0)
- ->mutable_field(0);
+ FieldDescriptorProto* key =
+ file_proto.mutable_message_type(0)->mutable_nested_type(0)->mutable_field(
+ 0);
key->set_type(FieldDescriptorProto::TYPE_DOUBLE);
BuildFileWithErrors(file_proto.DebugString(), kMapEntryKeyTypeErrorMessage);
}
@@ -5910,9 +5952,9 @@
TEST_F(ValidationErrorTest, MapEntryKeyTypeBytes) {
FileDescriptorProto file_proto;
FillValidMapEntry(&file_proto);
- FieldDescriptorProto* key = file_proto.mutable_message_type(0)
- ->mutable_nested_type(0)
- ->mutable_field(0);
+ FieldDescriptorProto* key =
+ file_proto.mutable_message_type(0)->mutable_nested_type(0)->mutable_field(
+ 0);
key->set_type(FieldDescriptorProto::TYPE_BYTES);
BuildFileWithErrors(file_proto.DebugString(), kMapEntryKeyTypeErrorMessage);
}
@@ -5920,9 +5962,9 @@
TEST_F(ValidationErrorTest, MapEntryKeyTypeEnum) {
FileDescriptorProto file_proto;
FillValidMapEntry(&file_proto);
- FieldDescriptorProto* key = file_proto.mutable_message_type(0)
- ->mutable_nested_type(0)
- ->mutable_field(0);
+ FieldDescriptorProto* key =
+ file_proto.mutable_message_type(0)->mutable_nested_type(0)->mutable_field(
+ 0);
key->clear_type();
key->set_type_name("BarEnum");
EnumDescriptorProto* enum_proto = file_proto.add_enum_type();
@@ -5942,13 +5984,12 @@
"be enum types.\n");
}
-
TEST_F(ValidationErrorTest, MapEntryKeyTypeMessage) {
FileDescriptorProto file_proto;
FillValidMapEntry(&file_proto);
- FieldDescriptorProto* key = file_proto.mutable_message_type(0)
- ->mutable_nested_type(0)
- ->mutable_field(0);
+ FieldDescriptorProto* key =
+ file_proto.mutable_message_type(0)->mutable_nested_type(0)->mutable_field(
+ 0);
key->clear_type();
key->set_type_name(".Bar");
BuildFileWithErrors(file_proto.DebugString(), kMapEntryKeyTypeErrorMessage);
@@ -6130,31 +6171,31 @@
TEST_F(ValidationErrorTest, MapEntryUsesNoneZeroEnumDefaultValue) {
BuildFileWithErrors(
- "name: \"foo.proto\" "
- "enum_type {"
- " name: \"Bar\""
- " value { name:\"ENUM_A\" number:1 }"
- " value { name:\"ENUM_B\" number:2 }"
- "}"
- "message_type {"
- " name: 'Foo' "
- " field { "
- " name: 'foo_map' number: 1 label:LABEL_REPEATED "
- " type_name: 'FooMapEntry' "
- " } "
- " nested_type { "
- " name: 'FooMapEntry' "
- " options { map_entry: true } "
- " field { "
- " name: 'key' number: 1 type:TYPE_INT32 label:LABEL_OPTIONAL "
- " } "
- " field { "
- " name: 'value' number: 2 type_name:\"Bar\" label:LABEL_OPTIONAL "
- " } "
- " } "
- "}",
- "foo.proto: Foo.foo_map: "
- "TYPE: Enum value in map must define 0 as the first value.\n");
+ "name: \"foo.proto\" "
+ "enum_type {"
+ " name: \"Bar\""
+ " value { name:\"ENUM_A\" number:1 }"
+ " value { name:\"ENUM_B\" number:2 }"
+ "}"
+ "message_type {"
+ " name: 'Foo' "
+ " field { "
+ " name: 'foo_map' number: 1 label:LABEL_REPEATED "
+ " type_name: 'FooMapEntry' "
+ " } "
+ " nested_type { "
+ " name: 'FooMapEntry' "
+ " options { map_entry: true } "
+ " field { "
+ " name: 'key' number: 1 type:TYPE_INT32 label:LABEL_OPTIONAL "
+ " } "
+ " field { "
+ " name: 'value' number: 2 type_name:\"Bar\" label:LABEL_OPTIONAL "
+ " } "
+ " } "
+ "}",
+ "foo.proto: Foo.foo_map: "
+ "TYPE: Enum value in map must define 0 as the first value.\n");
}
TEST_F(ValidationErrorTest, Proto3RequiredFields) {
@@ -6165,7 +6206,7 @@
" name: 'Foo' "
" field { name:'foo' number:1 label:LABEL_REQUIRED type:TYPE_INT32 } "
"}",
- "foo.proto: Foo.foo: OTHER: Required fields are not allowed in "
+ "foo.proto: Foo.foo: TYPE: Required fields are not allowed in "
"proto3.\n");
// applied to nested types as well.
@@ -6179,7 +6220,7 @@
" field { name:'bar' number:1 label:LABEL_REQUIRED type:TYPE_INT32 } "
" } "
"}",
- "foo.proto: Foo.Bar.bar: OTHER: Required fields are not allowed in "
+ "foo.proto: Foo.Bar.bar: TYPE: Required fields are not allowed in "
"proto3.\n");
// optional and repeated fields are OK.
@@ -6202,8 +6243,8 @@
" field { name:'foo' number:1 label:LABEL_OPTIONAL type:TYPE_INT32 "
" default_value: '1' }"
"}",
- "foo.proto: Foo.foo: OTHER: Explicit default values are not allowed in "
- "proto3.\n");
+ "foo.proto: Foo.foo: DEFAULT_VALUE: Explicit default values are not "
+ "allowed in proto3.\n");
BuildFileWithErrors(
"name: 'foo.proto' "
@@ -6216,8 +6257,8 @@
" default_value: '1' }"
" } "
"}",
- "foo.proto: Foo.Bar.bar: OTHER: Explicit default values are not allowed "
- "in proto3.\n");
+ "foo.proto: Foo.Bar.bar: DEFAULT_VALUE: Explicit default values are not "
+ "allowed in proto3.\n");
}
TEST_F(ValidationErrorTest, ValidateProto3ExtensionRange) {
@@ -6229,7 +6270,7 @@
" field { name:'foo' number:1 label:LABEL_OPTIONAL type:TYPE_INT32 } "
" extension_range { start:10 end:100 } "
"}",
- "foo.proto: Foo: OTHER: Extension ranges are not allowed in "
+ "foo.proto: Foo: NUMBER: Extension ranges are not allowed in "
"proto3.\n");
BuildFileWithErrors(
@@ -6243,7 +6284,7 @@
" extension_range { start:10 end:100 } "
" } "
"}",
- "foo.proto: Foo.Bar: OTHER: Extension ranges are not allowed in "
+ "foo.proto: Foo.Bar: NUMBER: Extension ranges are not allowed in "
"proto3.\n");
}
@@ -6255,7 +6296,7 @@
" name: 'Foo' "
" options { message_set_wire_format: true } "
"}",
- "foo.proto: Foo: OTHER: MessageSet is not supported "
+ "foo.proto: Foo: NAME: MessageSet is not supported "
"in proto3.\n");
}
@@ -6267,7 +6308,7 @@
" name: 'FooEnum' "
" value { name: 'FOO_FOO' number:1 } "
"}",
- "foo.proto: FooEnum: OTHER: The first enum value must be "
+ "foo.proto: FooEnum: NUMBER: The first enum value must be "
"zero in proto3.\n");
BuildFileWithErrors(
@@ -6280,7 +6321,7 @@
" value { name: 'FOO_FOO' number:1 } "
" } "
"}",
- "foo.proto: Foo.FooEnum: OTHER: The first enum value must be "
+ "foo.proto: Foo.FooEnum: NUMBER: The first enum value must be "
"zero in proto3.\n");
// valid case.
@@ -6372,7 +6413,7 @@
" name: 'bar' number: 1 label: LABEL_OPTIONAL type: TYPE_INT32 "
" extendee: 'Container' "
"}",
- "bar.proto: bar: OTHER: Extensions in proto3 are only allowed for "
+ "bar.proto: bar: EXTENDEE: Extensions in proto3 are only allowed for "
"defining options.\n");
}
@@ -6387,7 +6428,7 @@
" field { name:'name' number:1 label:LABEL_OPTIONAL type:TYPE_INT32 }"
" field { name:'Name' number:2 label:LABEL_OPTIONAL type:TYPE_INT32 }"
"}",
- "foo.proto: Foo: OTHER: The JSON camel-case name of field \"Name\" "
+ "foo.proto: Foo: NAME: The JSON camel-case name of field \"Name\" "
"conflicts with field \"name\". This is not allowed in proto3.\n");
// Underscores are ignored.
BuildFileWithErrors(
@@ -6398,7 +6439,7 @@
" field { name:'ab' number:1 label:LABEL_OPTIONAL type:TYPE_INT32 }"
" field { name:'_a__b_' number:2 label:LABEL_OPTIONAL type:TYPE_INT32 }"
"}",
- "foo.proto: Foo: OTHER: The JSON camel-case name of field \"_a__b_\" "
+ "foo.proto: Foo: NAME: The JSON camel-case name of field \"_a__b_\" "
"conflicts with field \"ab\". This is not allowed in proto3.\n");
}
@@ -6420,24 +6461,26 @@
SimpleDescriptorDatabase database_;
virtual void SetUp() {
+ AddToDatabase(
+ &database_,
+ "name: 'foo.proto' "
+ "message_type { name:'Foo' extension_range { start: 1 end: 100 } } "
+ "enum_type { name:'TestEnum' value { name:'DUMMY' number:0 } } "
+ "service { name:'TestService' } ");
AddToDatabase(&database_,
- "name: 'foo.proto' "
- "message_type { name:'Foo' extension_range { start: 1 end: 100 } } "
- "enum_type { name:'TestEnum' value { name:'DUMMY' number:0 } } "
- "service { name:'TestService' } ");
- AddToDatabase(&database_,
- "name: 'bar.proto' "
- "dependency: 'foo.proto' "
- "message_type { name:'Bar' } "
- "extension { name:'foo_ext' extendee: '.Foo' number:5 "
- " label:LABEL_OPTIONAL type:TYPE_INT32 } ");
+ "name: 'bar.proto' "
+ "dependency: 'foo.proto' "
+ "message_type { name:'Bar' } "
+ "extension { name:'foo_ext' extendee: '.Foo' number:5 "
+ " label:LABEL_OPTIONAL type:TYPE_INT32 } ");
// Baz has an undeclared dependency on Foo.
- AddToDatabase(&database_,
- "name: 'baz.proto' "
- "message_type { "
- " name:'Baz' "
- " field { name:'foo' number:1 label:LABEL_OPTIONAL type_name:'Foo' } "
- "}");
+ AddToDatabase(
+ &database_,
+ "name: 'baz.proto' "
+ "message_type { "
+ " name:'Baz' "
+ " field { name:'foo' number:1 label:LABEL_OPTIONAL type_name:'Foo' } "
+ "}");
}
// We can't inject a file containing errors into a DescriptorPool, so we
@@ -6481,7 +6524,7 @@
class CallCountingDatabase : public DescriptorDatabase {
public:
CallCountingDatabase(DescriptorDatabase* wrapped_db)
- : wrapped_db_(wrapped_db) {
+ : wrapped_db_(wrapped_db) {
Clear();
}
~CallCountingDatabase() {}
@@ -6490,9 +6533,7 @@
int call_count_;
- void Clear() {
- call_count_ = 0;
- }
+ void Clear() { call_count_ = 0; }
// implements DescriptorDatabase ---------------------------------
bool FindFileByName(const std::string& filename,
@@ -6509,8 +6550,8 @@
int field_number,
FileDescriptorProto* output) {
++call_count_;
- return wrapped_db_->FindFileContainingExtension(
- containing_type, field_number, output);
+ return wrapped_db_->FindFileContainingExtension(containing_type,
+ field_number, output);
}
};
@@ -6520,7 +6561,7 @@
class FalsePositiveDatabase : public DescriptorDatabase {
public:
FalsePositiveDatabase(DescriptorDatabase* wrapped_db)
- : wrapped_db_(wrapped_db) {}
+ : wrapped_db_(wrapped_db) {}
~FalsePositiveDatabase() {}
DescriptorDatabase* wrapped_db_;
@@ -6667,13 +6708,13 @@
EXPECT_TRUE(pool.FindFileByName("error.proto") == NULL);
EXPECT_EQ(
- "error.proto: error.proto: OTHER: File recursively imports itself: "
+ "error.proto: error2.proto: IMPORT: File recursively imports itself: "
"error.proto -> error2.proto -> error.proto\n"
- "error2.proto: error2.proto: OTHER: Import \"error.proto\" was not "
+ "error2.proto: error.proto: IMPORT: Import \"error.proto\" was not "
"found or had errors.\n"
- "error.proto: error.proto: OTHER: Import \"error2.proto\" was not "
+ "error.proto: error2.proto: IMPORT: Import \"error2.proto\" was not "
"found or had errors.\n",
- error_collector.text_);
+ error_collector.text_);
}
TEST_F(DatabaseBackedPoolTest, UndeclaredDependencyOnUnbuiltType) {
@@ -6683,10 +6724,10 @@
DescriptorPool pool(&database_, &error_collector);
EXPECT_TRUE(pool.FindMessageTypeByName("Baz") == NULL);
EXPECT_EQ(
- "baz.proto: Baz.foo: TYPE: \"Foo\" seems to be defined in \"foo.proto\", "
- "which is not imported by \"baz.proto\". To use it here, please add "
- "the necessary import.\n",
- error_collector.text_);
+ "baz.proto: Baz.foo: TYPE: \"Foo\" seems to be defined in \"foo.proto\", "
+ "which is not imported by \"baz.proto\". To use it here, please add "
+ "the necessary import.\n",
+ error_collector.text_);
}
TEST_F(DatabaseBackedPoolTest, RollbackAfterError) {
@@ -6708,12 +6749,12 @@
// thoroughly test all paths through DescriptorBuilder to insure that there
// are no deadlocking problems when pool_->mutex_ is non-NULL.
const FileDescriptor* original_file =
- protobuf_unittest::TestAllTypes::descriptor()->file();
+ protobuf_unittest::TestAllTypes::descriptor()->file();
DescriptorPoolDatabase database(*DescriptorPool::generated_pool());
DescriptorPool pool(&database);
const FileDescriptor* file_from_database =
- pool.FindFileByName(original_file->name());
+ pool.FindFileByName(original_file->name());
ASSERT_TRUE(file_from_database != NULL);
@@ -6727,8 +6768,7 @@
file_from_database_proto.DebugString());
// Also verify that CopyTo() did not omit any information.
- EXPECT_EQ(original_file->DebugString(),
- file_from_database->DebugString());
+ EXPECT_EQ(original_file->DebugString(), file_from_database->DebugString());
}
TEST_F(DatabaseBackedPoolTest, DoesntRetryDbUnnecessarily) {
@@ -6844,7 +6884,7 @@
int begin_size = begin_with.size();
int end_size = end_with.size();
if (name.substr(0, begin_size) != begin_with ||
- name.substr(name.size()- end_size, end_size) != end_with) {
+ name.substr(name.size() - end_size, end_size) != end_with) {
return;
}
safe_strto32(
@@ -6937,8 +6977,9 @@
: filename_(filename), contents_(contents) {}
virtual io::ZeroCopyInputStream* Open(const std::string& filename) {
- return filename == filename_ ?
- new io::ArrayInputStream(contents_.data(), contents_.size()) : NULL;
+ return filename == filename_
+ ? new io::ArrayInputStream(contents_.data(), contents_.size())
+ : NULL;
}
private:
@@ -7040,10 +7081,8 @@
}
static std::string PrintSourceLocation(const SourceLocation& loc) {
- return strings::Substitute("$0:$1-$2:$3",
- 1 + loc.start_line,
- 1 + loc.start_column,
- 1 + loc.end_line,
+ return strings::Substitute("$0:$1-$2:$3", 1 + loc.start_line,
+ 1 + loc.start_column, 1 + loc.end_line,
1 + loc.end_column);
}
@@ -7073,27 +7112,27 @@
const FileDescriptor* file_desc =
GOOGLE_CHECK_NOTNULL(pool_.FindFileByName("/test/test.proto"));
- const Descriptor *a_desc = file_desc->FindMessageTypeByName("A");
+ const Descriptor* a_desc = file_desc->FindMessageTypeByName("A");
EXPECT_TRUE(a_desc->GetSourceLocation(&loc));
EXPECT_EQ("4:1-16:2", PrintSourceLocation(loc));
- const Descriptor *a_b_desc = a_desc->FindNestedTypeByName("B");
+ const Descriptor* a_b_desc = a_desc->FindNestedTypeByName("B");
EXPECT_TRUE(a_b_desc->GetSourceLocation(&loc));
EXPECT_EQ("7:3-9:4", PrintSourceLocation(loc));
- const EnumDescriptor *e_desc = file_desc->FindEnumTypeByName("Indecision");
+ const EnumDescriptor* e_desc = file_desc->FindEnumTypeByName("Indecision");
EXPECT_TRUE(e_desc->GetSourceLocation(&loc));
EXPECT_EQ("17:1-24:2", PrintSourceLocation(loc));
- const EnumValueDescriptor *yes_desc = e_desc->FindValueByName("YES");
+ const EnumValueDescriptor* yes_desc = e_desc->FindValueByName("YES");
EXPECT_TRUE(yes_desc->GetSourceLocation(&loc));
EXPECT_EQ("21:3-21:42", PrintSourceLocation(loc));
- const ServiceDescriptor *s_desc = file_desc->FindServiceByName("S");
+ const ServiceDescriptor* s_desc = file_desc->FindServiceByName("S");
EXPECT_TRUE(s_desc->GetSourceLocation(&loc));
EXPECT_EQ("25:1-35:2", PrintSourceLocation(loc));
- const MethodDescriptor *m_desc = s_desc->FindMethodByName("Method");
+ const MethodDescriptor* m_desc = s_desc->FindMethodByName("Method");
EXPECT_TRUE(m_desc->GetSourceLocation(&loc));
EXPECT_EQ("29:3-29:31", PrintSourceLocation(loc));
@@ -7105,16 +7144,16 @@
const FileDescriptor* file_desc =
GOOGLE_CHECK_NOTNULL(pool_.FindFileByName("/test/test.proto"));
- const FieldDescriptor *int32_extension_desc =
+ const FieldDescriptor* int32_extension_desc =
file_desc->FindExtensionByName("int32_extension");
EXPECT_TRUE(int32_extension_desc->GetSourceLocation(&loc));
EXPECT_EQ("40:3-40:55", PrintSourceLocation(loc));
- const Descriptor *c_desc = file_desc->FindMessageTypeByName("C");
+ const Descriptor* c_desc = file_desc->FindMessageTypeByName("C");
EXPECT_TRUE(c_desc->GetSourceLocation(&loc));
EXPECT_EQ("42:1-46:2", PrintSourceLocation(loc));
- const FieldDescriptor *message_extension_desc =
+ const FieldDescriptor* message_extension_desc =
c_desc->FindExtensionByName("message_extension");
EXPECT_TRUE(message_extension_desc->GetSourceLocation(&loc));
EXPECT_EQ("44:5-44:41", PrintSourceLocation(loc));
@@ -7502,7 +7541,7 @@
DescriptorPool bad1_pool(&pool_);
const FileDescriptor* bad1_file_desc =
GOOGLE_CHECK_NOTNULL(bad1_pool.BuildFile(proto));
- const Descriptor *bad1_a_desc = bad1_file_desc->FindMessageTypeByName("A");
+ const Descriptor* bad1_a_desc = bad1_file_desc->FindMessageTypeByName("A");
EXPECT_FALSE(bad1_a_desc->GetSourceLocation(&loc));
}
@@ -7516,7 +7555,7 @@
FileDescriptorProto proto;
file_desc->CopyTo(&proto); // Note, this discards the SourceCodeInfo.
EXPECT_FALSE(proto.has_source_code_info());
- SourceCodeInfo_Location *loc_msg =
+ SourceCodeInfo_Location* loc_msg =
proto.mutable_source_code_info()->add_location();
loc_msg->add_path(1);
loc_msg->add_path(2);
@@ -7528,15 +7567,15 @@
DescriptorPool bad2_pool(&pool_);
const FileDescriptor* bad2_file_desc =
GOOGLE_CHECK_NOTNULL(bad2_pool.BuildFile(proto));
- const Descriptor *bad2_a_desc = bad2_file_desc->FindMessageTypeByName("A");
+ const Descriptor* bad2_a_desc = bad2_file_desc->FindMessageTypeByName("A");
EXPECT_FALSE(bad2_a_desc->GetSourceLocation(&loc));
}
// ===================================================================
const char* const kCopySourceCodeInfoToTestInput =
- "syntax = \"proto2\";\n"
- "message Foo {}\n";
+ "syntax = \"proto2\";\n"
+ "message Foo {}\n";
// Required since source code information is not preserved by
// FileDescriptorTest.
diff --git a/src/google/protobuf/duration.pb.cc b/src/google/protobuf/duration.pb.cc
index 7c51bad..2f66112 100644
--- a/src/google/protobuf/duration.pb.cc
+++ b/src/google/protobuf/duration.pb.cc
@@ -36,10 +36,6 @@
PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Duration_google_2fprotobuf_2fduration_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsDuration_google_2fprotobuf_2fduration_2eproto}, {}};
-void InitDefaults_google_2fprotobuf_2fduration_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Duration_google_2fprotobuf_2fduration_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2fduration_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2fduration_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fduration_2eproto = nullptr;
@@ -76,8 +72,7 @@
"obuf.WellKnownTypesb\006proto3"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fduration_2eproto = {
- false, InitDefaults_google_2fprotobuf_2fduration_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2fduration_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2fduration_2eproto,
"google/protobuf/duration.proto", &assign_descriptors_table_google_2fprotobuf_2fduration_2eproto, 227,
};
@@ -85,6 +80,7 @@
static constexpr ::PROTOBUF_NAMESPACE_ID::internal::InitFunc deps[1] =
{
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Duration_google_2fprotobuf_2fduration_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2fduration_2eproto, deps, 0);
}
@@ -171,39 +167,45 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Duration::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// int64 seconds = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_seconds(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// int32 nanos = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_nanos(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ nanos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Duration::MergePartialFromCodedStream(
diff --git a/src/google/protobuf/duration.proto b/src/google/protobuf/duration.proto
index 975fce4..9d8a52d 100644
--- a/src/google/protobuf/duration.proto
+++ b/src/google/protobuf/duration.proto
@@ -101,7 +101,6 @@
//
//
message Duration {
-
// Signed seconds of the span of time. Must be from -315,576,000,000
// to +315,576,000,000 inclusive. Note: these bounds are computed from:
// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
diff --git a/src/google/protobuf/dynamic_message.cc b/src/google/protobuf/dynamic_message.cc
index 44c1fd7..5890f78 100644
--- a/src/google/protobuf/dynamic_message.cc
+++ b/src/google/protobuf/dynamic_message.cc
@@ -82,7 +82,6 @@
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/wire_format.h>
-
namespace google {
namespace protobuf {
@@ -100,23 +99,29 @@
namespace {
-bool IsMapFieldInApi(const FieldDescriptor* field) {
- return field->is_map();
-}
+bool IsMapFieldInApi(const FieldDescriptor* field) { return field->is_map(); }
// Compute the byte size of the in-memory representation of the field.
int FieldSpaceUsed(const FieldDescriptor* field) {
typedef FieldDescriptor FD; // avoid line wrapping
if (field->label() == FD::LABEL_REPEATED) {
switch (field->cpp_type()) {
- case FD::CPPTYPE_INT32 : return sizeof(RepeatedField<int32 >);
- case FD::CPPTYPE_INT64 : return sizeof(RepeatedField<int64 >);
- case FD::CPPTYPE_UINT32 : return sizeof(RepeatedField<uint32 >);
- case FD::CPPTYPE_UINT64 : return sizeof(RepeatedField<uint64 >);
- case FD::CPPTYPE_DOUBLE : return sizeof(RepeatedField<double >);
- case FD::CPPTYPE_FLOAT : return sizeof(RepeatedField<float >);
- case FD::CPPTYPE_BOOL : return sizeof(RepeatedField<bool >);
- case FD::CPPTYPE_ENUM : return sizeof(RepeatedField<int >);
+ case FD::CPPTYPE_INT32:
+ return sizeof(RepeatedField<int32>);
+ case FD::CPPTYPE_INT64:
+ return sizeof(RepeatedField<int64>);
+ case FD::CPPTYPE_UINT32:
+ return sizeof(RepeatedField<uint32>);
+ case FD::CPPTYPE_UINT64:
+ return sizeof(RepeatedField<uint64>);
+ case FD::CPPTYPE_DOUBLE:
+ return sizeof(RepeatedField<double>);
+ case FD::CPPTYPE_FLOAT:
+ return sizeof(RepeatedField<float>);
+ case FD::CPPTYPE_BOOL:
+ return sizeof(RepeatedField<bool>);
+ case FD::CPPTYPE_ENUM:
+ return sizeof(RepeatedField<int>);
case FD::CPPTYPE_MESSAGE:
if (IsMapFieldInApi(field)) {
return sizeof(DynamicMapField);
@@ -134,14 +139,22 @@
}
} else {
switch (field->cpp_type()) {
- case FD::CPPTYPE_INT32 : return sizeof(int32 );
- case FD::CPPTYPE_INT64 : return sizeof(int64 );
- case FD::CPPTYPE_UINT32 : return sizeof(uint32 );
- case FD::CPPTYPE_UINT64 : return sizeof(uint64 );
- case FD::CPPTYPE_DOUBLE : return sizeof(double );
- case FD::CPPTYPE_FLOAT : return sizeof(float );
- case FD::CPPTYPE_BOOL : return sizeof(bool );
- case FD::CPPTYPE_ENUM : return sizeof(int );
+ case FD::CPPTYPE_INT32:
+ return sizeof(int32);
+ case FD::CPPTYPE_INT64:
+ return sizeof(int64);
+ case FD::CPPTYPE_UINT32:
+ return sizeof(uint32);
+ case FD::CPPTYPE_UINT64:
+ return sizeof(uint64);
+ case FD::CPPTYPE_DOUBLE:
+ return sizeof(double);
+ case FD::CPPTYPE_FLOAT:
+ return sizeof(float);
+ case FD::CPPTYPE_BOOL:
+ return sizeof(bool);
+ case FD::CPPTYPE_ENUM:
+ return sizeof(int);
case FD::CPPTYPE_MESSAGE:
return sizeof(Message*);
@@ -165,14 +178,22 @@
int OneofFieldSpaceUsed(const FieldDescriptor* field) {
typedef FieldDescriptor FD; // avoid line wrapping
switch (field->cpp_type()) {
- case FD::CPPTYPE_INT32 : return sizeof(int32 );
- case FD::CPPTYPE_INT64 : return sizeof(int64 );
- case FD::CPPTYPE_UINT32 : return sizeof(uint32 );
- case FD::CPPTYPE_UINT64 : return sizeof(uint64 );
- case FD::CPPTYPE_DOUBLE : return sizeof(double );
- case FD::CPPTYPE_FLOAT : return sizeof(float );
- case FD::CPPTYPE_BOOL : return sizeof(bool );
- case FD::CPPTYPE_ENUM : return sizeof(int );
+ case FD::CPPTYPE_INT32:
+ return sizeof(int32);
+ case FD::CPPTYPE_INT64:
+ return sizeof(int64);
+ case FD::CPPTYPE_UINT32:
+ return sizeof(uint32);
+ case FD::CPPTYPE_UINT64:
+ return sizeof(uint64);
+ case FD::CPPTYPE_DOUBLE:
+ return sizeof(double);
+ case FD::CPPTYPE_FLOAT:
+ return sizeof(float);
+ case FD::CPPTYPE_BOOL:
+ return sizeof(bool);
+ case FD::CPPTYPE_ENUM:
+ return sizeof(int);
case FD::CPPTYPE_MESSAGE:
return sizeof(Message*);
@@ -190,9 +211,7 @@
return 0;
}
-inline int DivideRoundingUp(int i, int j) {
- return (i + (j - 1)) / j;
-}
+inline int DivideRoundingUp(int i, int j) { return (i + (j - 1)) / j; }
static const int kSafeAlignment = sizeof(uint64);
static const int kMaxOneofUnionSize = sizeof(uint64);
@@ -203,9 +222,7 @@
// Rounds the given byte offset up to the next offset aligned such that any
// type may be stored at it.
-inline int AlignOffset(int offset) {
- return AlignTo(offset, kSafeAlignment);
-}
+inline int AlignOffset(int offset) { return AlignTo(offset, kSafeAlignment); }
#define bitsizeof(T) (sizeof(T) * 8)
@@ -241,15 +258,13 @@
TypeInfo() : prototype(NULL) {}
- ~TypeInfo() {
- delete prototype;
- }
+ ~TypeInfo() { delete prototype; }
};
DynamicMessage(const TypeInfo* type_info);
// This should only be used by GetPrototypeNoLock() to avoid dead lock.
- DynamicMessage(const TypeInfo* type_info, bool lock_factory);
+ DynamicMessage(TypeInfo* type_info, bool lock_factory);
~DynamicMessage();
@@ -273,9 +288,7 @@
// care of for us. This makes DynamicMessage compatible with -fsized-delete.
// It doesn't work for MSVC though.
#ifndef _MSC_VER
- static void operator delete(void* ptr) {
- ::operator delete(ptr);
- }
+ static void operator delete(void* ptr) { ::operator delete(ptr); }
#endif // !_MSC_VER
private:
@@ -313,8 +326,15 @@
SharedCtor(true);
}
-DynamicMessage::DynamicMessage(const TypeInfo* type_info, bool lock_factory)
+DynamicMessage::DynamicMessage(TypeInfo* type_info, bool lock_factory)
: type_info_(type_info), arena_(NULL), cached_byte_size_(0) {
+ // The prototype in type_info has to be set before creating the prototype
+ // instance on memory. e.g., message Foo { map<int32, Foo> a = 1; }. When
+ // creating prototype for Foo, prototype of the map entry will also be
+ // created, which needs the address of the prototype of Foo (the value in
+ // map). To break the cyclic dependency, we have to assign the address of
+ // prototype into type_info first.
+ type_info->prototype = this;
SharedCtor(lock_factory);
}
@@ -330,7 +350,7 @@
const Descriptor* descriptor = type_info_->type;
// Initialize oneof cases.
- for (int i = 0 ; i < descriptor->oneof_decl_count(); ++i) {
+ for (int i = 0; i < descriptor->oneof_decl_count(); ++i) {
new (OffsetToPointer(type_info_->oneof_case_offset + sizeof(uint32) * i))
uint32(0);
}
@@ -357,18 +377,18 @@
} \
break;
- HANDLE_TYPE(INT32 , int32 );
- HANDLE_TYPE(INT64 , int64 );
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
HANDLE_TYPE(UINT32, uint32);
HANDLE_TYPE(UINT64, uint64);
HANDLE_TYPE(DOUBLE, double);
- HANDLE_TYPE(FLOAT , float );
- HANDLE_TYPE(BOOL , bool );
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(BOOL, bool);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_ENUM:
if (!field->is_repeated()) {
- new(field_ptr) int(field->default_value_enum()->number());
+ new (field_ptr) int(field->default_value_enum()->number());
} else {
new (field_ptr) RepeatedField<int>(arena_);
}
@@ -388,7 +408,7 @@
type_info_->offsets[i]))
->Get());
}
- ArenaStringPtr* asp = new(field_ptr) ArenaStringPtr();
+ ArenaStringPtr* asp = new (field_ptr) ArenaStringPtr();
asp->UnsafeSetDefault(default_value);
} else {
new (field_ptr) RepeatedPtrField<std::string>(arena_);
@@ -399,7 +419,7 @@
case FieldDescriptor::CPPTYPE_MESSAGE: {
if (!field->is_repeated()) {
- new(field_ptr) Message*(NULL);
+ new (field_ptr) Message*(NULL);
} else {
if (IsMapFieldInApi(field)) {
// We need to lock in most cases to avoid data racing. Only not lock
@@ -445,7 +465,8 @@
if (type_info_->extensions_offset != -1) {
reinterpret_cast<ExtensionSet*>(
- OffsetToPointer(type_info_->extensions_offset))->~ExtensionSet();
+ OffsetToPointer(type_info_->extensions_offset))
+ ->~ExtensionSet();
}
// We need to manually run the destructors for repeated fields and strings,
@@ -459,13 +480,13 @@
for (int i = 0; i < descriptor->field_count(); i++) {
const FieldDescriptor* field = descriptor->field(i);
if (field->containing_oneof()) {
- void* field_ptr = OffsetToPointer(
- type_info_->oneof_case_offset
- + sizeof(uint32) * field->containing_oneof()->index());
- if (*(reinterpret_cast<const uint32*>(field_ptr)) ==
- field->number()) {
- field_ptr = OffsetToPointer(type_info_->offsets[
- descriptor->field_count() + field->containing_oneof()->index()]);
+ void* field_ptr =
+ OffsetToPointer(type_info_->oneof_case_offset +
+ sizeof(uint32) * field->containing_oneof()->index());
+ if (*(reinterpret_cast<const uint32*>(field_ptr)) == field->number()) {
+ field_ptr = OffsetToPointer(
+ type_info_->offsets[descriptor->field_count() +
+ field->containing_oneof()->index()]);
if (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
switch (field->options().ctype()) {
default:
@@ -490,20 +511,20 @@
if (field->is_repeated()) {
switch (field->cpp_type()) {
-#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
- case FieldDescriptor::CPPTYPE_##UPPERCASE : \
- reinterpret_cast<RepeatedField<LOWERCASE>*>(field_ptr) \
- ->~RepeatedField<LOWERCASE>(); \
- break
+#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
+ case FieldDescriptor::CPPTYPE_##UPPERCASE: \
+ reinterpret_cast<RepeatedField<LOWERCASE>*>(field_ptr) \
+ ->~RepeatedField<LOWERCASE>(); \
+ break
- HANDLE_TYPE( INT32, int32);
- HANDLE_TYPE( INT64, int64);
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
HANDLE_TYPE(UINT32, uint32);
HANDLE_TYPE(UINT64, uint64);
HANDLE_TYPE(DOUBLE, double);
- HANDLE_TYPE( FLOAT, float);
- HANDLE_TYPE( BOOL, bool);
- HANDLE_TYPE( ENUM, int);
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(BOOL, bool);
+ HANDLE_TYPE(ENUM, int);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_STRING:
@@ -535,13 +556,13 @@
type_info_->prototype->OffsetToPointer(
type_info_->offsets[i]))
->Get());
- reinterpret_cast<ArenaStringPtr*>(field_ptr)->Destroy(
- default_value, NULL);
+ reinterpret_cast<ArenaStringPtr*>(field_ptr)->Destroy(default_value,
+ NULL);
break;
}
}
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
- if (!is_prototype()) {
+ if (!is_prototype()) {
Message* message = *reinterpret_cast<Message**>(field_ptr);
if (message != NULL) {
delete message;
@@ -569,7 +590,7 @@
// For singular fields, the field is just a pointer which should
// point to the prototype.
*reinterpret_cast<const Message**>(field_ptr) =
- factory->GetPrototypeNoLock(field->message_type());
+ factory->GetPrototypeNoLock(field->message_type());
}
}
}
@@ -612,20 +633,19 @@
};
DynamicMessageFactory::DynamicMessageFactory()
- : pool_(NULL), delegate_to_generated_factory_(false),
- prototypes_(new PrototypeMap) {
-}
+ : pool_(NULL),
+ delegate_to_generated_factory_(false),
+ prototypes_(new PrototypeMap) {}
DynamicMessageFactory::DynamicMessageFactory(const DescriptorPool* pool)
- : pool_(pool), delegate_to_generated_factory_(false),
- prototypes_(new PrototypeMap) {
-}
+ : pool_(pool),
+ delegate_to_generated_factory_(false),
+ prototypes_(new PrototypeMap) {}
DynamicMessageFactory::~DynamicMessageFactory() {
for (PrototypeMap::Map::iterator iter = prototypes_->map_.begin();
iter != prototypes_->map_.end(); ++iter) {
- DeleteDefaultOneofInstance(iter->second->type,
- iter->second->offsets.get(),
+ DeleteDefaultOneofInstance(iter->second->type, iter->second->offsets.get(),
iter->second->prototype);
delete iter->second;
}
@@ -665,8 +685,7 @@
// or not that field is set.
// Compute size and offsets.
- uint32* offsets =
- new uint32[type->field_count() + type->oneof_decl_count()];
+ uint32* offsets = new uint32[type->field_count() + type->oneof_decl_count()];
type_info->offsets.reset(offsets);
// Decide all field offsets by packing in order.
@@ -681,7 +700,7 @@
} else {
type_info->has_bits_offset = size;
int has_bits_array_size =
- DivideRoundingUp(type->field_count(), bitsizeof(uint32));
+ DivideRoundingUp(type->field_count(), bitsizeof(uint32));
size += has_bits_array_size * sizeof(uint32);
size = AlignOffset(size);
@@ -742,7 +761,6 @@
// alignment is not necessary.
type_info->size = size;
-
// Construct the reflection object.
if (type->oneof_decl_count() > 0) {
@@ -763,35 +781,25 @@
void* base = operator new(size);
memset(base, 0, size);
- // The prototype in type_info has to be set before creating the prototype
- // instance on memory. e.g., message Foo { map<int32, Foo> a = 1; }. When
- // creating prototype for Foo, prototype of the map entry will also be
- // created, which needs the address of the prototype of Foo (the value in
- // map). To break the cyclic dependency, we have to assgin the address of
- // prototype into type_info first.
- type_info->prototype = static_cast<DynamicMessage*>(base);
-
// We have already locked the factory so we should not lock in the constructor
// of dynamic message to avoid dead lock.
DynamicMessage* prototype = new (base) DynamicMessage(type_info, false);
if (type->oneof_decl_count() > 0 || num_weak_fields > 0) {
// Construct default oneof instance.
- ConstructDefaultOneofInstance(type_info->type,
- type_info->offsets.get(),
+ ConstructDefaultOneofInstance(type_info->type, type_info->offsets.get(),
prototype);
}
- internal::ReflectionSchema schema = {
- type_info->prototype,
- type_info->offsets.get(),
- type_info->has_bits_indices.get(),
- type_info->has_bits_offset,
- type_info->internal_metadata_offset,
- type_info->extensions_offset,
- type_info->oneof_case_offset,
- type_info->size,
- type_info->weak_field_map_offset};
+ internal::ReflectionSchema schema = {type_info->prototype,
+ type_info->offsets.get(),
+ type_info->has_bits_indices.get(),
+ type_info->has_bits_offset,
+ type_info->internal_metadata_offset,
+ type_info->extensions_offset,
+ type_info->oneof_case_offset,
+ type_info->size,
+ type_info->weak_field_map_offset};
type_info->reflection.reset(new GeneratedMessageReflection(
type_info->type, schema, type_info->pool, this));
@@ -803,31 +811,31 @@
}
void DynamicMessageFactory::ConstructDefaultOneofInstance(
- const Descriptor* type,
- const uint32 offsets[],
+ const Descriptor* type, const uint32 offsets[],
void* default_oneof_or_weak_instance) {
for (int i = 0; i < type->oneof_decl_count(); i++) {
for (int j = 0; j < type->oneof_decl(i)->field_count(); j++) {
const FieldDescriptor* field = type->oneof_decl(i)->field(j);
- void* field_ptr = reinterpret_cast<uint8*>(
- default_oneof_or_weak_instance) + offsets[field->index()];
+ void* field_ptr =
+ reinterpret_cast<uint8*>(default_oneof_or_weak_instance) +
+ offsets[field->index()];
switch (field->cpp_type()) {
-#define HANDLE_TYPE(CPPTYPE, TYPE) \
- case FieldDescriptor::CPPTYPE_##CPPTYPE: \
- new(field_ptr) TYPE(field->default_value_##TYPE()); \
- break;
+#define HANDLE_TYPE(CPPTYPE, TYPE) \
+ case FieldDescriptor::CPPTYPE_##CPPTYPE: \
+ new (field_ptr) TYPE(field->default_value_##TYPE()); \
+ break;
- HANDLE_TYPE(INT32 , int32 );
- HANDLE_TYPE(INT64 , int64 );
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
HANDLE_TYPE(UINT32, uint32);
HANDLE_TYPE(UINT64, uint64);
HANDLE_TYPE(DOUBLE, double);
- HANDLE_TYPE(FLOAT , float );
- HANDLE_TYPE(BOOL , bool );
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(BOOL, bool);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_ENUM:
- new(field_ptr) int(field->default_value_enum()->number());
+ new (field_ptr) int(field->default_value_enum()->number());
break;
case FieldDescriptor::CPPTYPE_STRING:
switch (field->options().ctype()) {
@@ -840,7 +848,7 @@
break;
case FieldDescriptor::CPPTYPE_MESSAGE: {
- new(field_ptr) Message*(NULL);
+ new (field_ptr) Message*(NULL);
break;
}
}
@@ -849,8 +857,7 @@
}
void DynamicMessageFactory::DeleteDefaultOneofInstance(
- const Descriptor* type,
- const uint32 offsets[],
+ const Descriptor* type, const uint32 offsets[],
const void* default_oneof_instance) {
for (int i = 0; i < type->oneof_decl_count(); i++) {
for (int j = 0; j < type->oneof_decl(i)->field_count(); j++) {
diff --git a/src/google/protobuf/dynamic_message.h b/src/google/protobuf/dynamic_message.h
index 1ea6f66..765f9e3 100644
--- a/src/google/protobuf/dynamic_message.h
+++ b/src/google/protobuf/dynamic_message.h
@@ -42,10 +42,10 @@
#include <memory>
#include <vector>
+#include <google/protobuf/stubs/common.h>
#include <google/protobuf/message.h>
#include <google/protobuf/stubs/mutex.h>
#include <google/protobuf/repeated_field.h>
-#include <google/protobuf/stubs/common.h>
#ifdef SWIG
#error "You cannot SWIG proto headers"
@@ -57,8 +57,8 @@
namespace protobuf {
// Defined in other files.
-class Descriptor; // descriptor.h
-class DescriptorPool; // descriptor.h
+class Descriptor; // descriptor.h
+class DescriptorPool; // descriptor.h
// Constructs implementations of Message which can emulate types which are not
// known at compile-time.
@@ -155,8 +155,7 @@
// Helper for computing a sorted list of map entries via reflection.
class PROTOBUF_EXPORT DynamicMapSorter {
public:
- static std::vector<const Message*> Sort(const Message& message,
- int map_size,
+ static std::vector<const Message*> Sort(const Message& message, int map_size,
const Reflection* reflection,
const FieldDescriptor* field) {
std::vector<const Message*> result(static_cast<size_t>(map_size));
@@ -164,7 +163,8 @@
reflection->GetRepeatedPtrField<Message>(message, field);
size_t i = 0;
for (RepeatedPtrField<Message>::const_pointer_iterator it =
- map_field.pointer_begin(); it != map_field.pointer_end(); ) {
+ map_field.pointer_begin();
+ it != map_field.pointer_end();) {
result[i++] = *it++;
}
GOOGLE_DCHECK_EQ(result.size(), i);
@@ -174,9 +174,9 @@
#ifndef NDEBUG
for (size_t j = 1; j < static_cast<size_t>(map_size); j++) {
if (!comparator(result[j - 1], result[j])) {
- GOOGLE_LOG(ERROR) << (comparator(result[j], result[j - 1]) ?
- "internal error in map key sorting" :
- "map keys are not unique");
+ GOOGLE_LOG(ERROR) << (comparator(result[j], result[j - 1])
+ ? "internal error in map key sorting"
+ : "map keys are not unique");
}
}
#endif
diff --git a/src/google/protobuf/dynamic_message_unittest.cc b/src/google/protobuf/dynamic_message_unittest.cc
index e96f658..42759de 100644
--- a/src/google/protobuf/dynamic_message_unittest.cc
+++ b/src/google/protobuf/dynamic_message_unittest.cc
@@ -72,7 +72,7 @@
const Descriptor* proto3_descriptor_;
const Message* proto3_prototype_;
- DynamicMessageTest(): factory_(&pool_) {}
+ DynamicMessageTest() : factory_(&pool_) {}
virtual void SetUp() {
// We want to make sure that DynamicMessage works (particularly with
@@ -86,11 +86,11 @@
unittest::TestAllTypes::descriptor()->file()->CopyTo(&unittest_file);
unittest_import::ImportMessage::descriptor()->file()->CopyTo(
- &unittest_import_file);
+ &unittest_import_file);
unittest_import::PublicImportMessage::descriptor()->file()->CopyTo(
- &unittest_import_public_file);
- proto2_nofieldpresence_unittest::TestAllTypes::descriptor()->
- file()->CopyTo(&unittest_no_field_presence_file);
+ &unittest_import_public_file);
+ proto2_nofieldpresence_unittest::TestAllTypes::descriptor()->file()->CopyTo(
+ &unittest_no_field_presence_file);
ASSERT_TRUE(pool_.BuildFile(unittest_import_public_file) != NULL);
ASSERT_TRUE(pool_.BuildFile(unittest_import_file) != NULL);
@@ -102,23 +102,22 @@
prototype_ = factory_.GetPrototype(descriptor_);
extensions_descriptor_ =
- pool_.FindMessageTypeByName("protobuf_unittest.TestAllExtensions");
+ pool_.FindMessageTypeByName("protobuf_unittest.TestAllExtensions");
ASSERT_TRUE(extensions_descriptor_ != NULL);
extensions_prototype_ = factory_.GetPrototype(extensions_descriptor_);
packed_descriptor_ =
- pool_.FindMessageTypeByName("protobuf_unittest.TestPackedTypes");
+ pool_.FindMessageTypeByName("protobuf_unittest.TestPackedTypes");
ASSERT_TRUE(packed_descriptor_ != NULL);
packed_prototype_ = factory_.GetPrototype(packed_descriptor_);
oneof_descriptor_ =
- pool_.FindMessageTypeByName("protobuf_unittest.TestOneof2");
+ pool_.FindMessageTypeByName("protobuf_unittest.TestOneof2");
ASSERT_TRUE(oneof_descriptor_ != NULL);
oneof_prototype_ = factory_.GetPrototype(oneof_descriptor_);
- proto3_descriptor_ =
- pool_.FindMessageTypeByName(
- "proto2_nofieldpresence_unittest.TestAllTypes");
+ proto3_descriptor_ = pool_.FindMessageTypeByName(
+ "proto2_nofieldpresence_unittest.TestAllTypes");
ASSERT_TRUE(proto3_descriptor_ != NULL);
proto3_prototype_ = factory_.GetPrototype(proto3_descriptor_);
}
@@ -146,7 +145,7 @@
// one to a unique value then checking that they all still have those
// unique values (i.e. they don't stomp each other).
Arena arena;
- Message* message = prototype_->New(GetParam()? &arena : NULL);
+ Message* message = prototype_->New(GetParam() ? &arena : NULL);
TestUtil::ReflectionTester reflection_tester(descriptor_);
reflection_tester.SetAllFieldsViaReflection(message);
@@ -160,7 +159,7 @@
TEST_P(DynamicMessageTest, Extensions) {
// Check that extensions work.
Arena arena;
- Message* message = extensions_prototype_->New(GetParam()? &arena : NULL);
+ Message* message = extensions_prototype_->New(GetParam() ? &arena : NULL);
TestUtil::ReflectionTester reflection_tester(extensions_descriptor_);
reflection_tester.SetAllFieldsViaReflection(message);
@@ -174,7 +173,7 @@
TEST_P(DynamicMessageTest, PackedFields) {
// Check that packed fields work properly.
Arena arena;
- Message* message = packed_prototype_->New(GetParam()? &arena : NULL);
+ Message* message = packed_prototype_->New(GetParam() ? &arena : NULL);
TestUtil::ReflectionTester reflection_tester(packed_descriptor_);
reflection_tester.SetPackedFieldsViaReflection(message);
@@ -188,23 +187,25 @@
TEST_P(DynamicMessageTest, Oneof) {
// Check that oneof fields work properly.
Arena arena;
- Message* message = oneof_prototype_->New(GetParam()? &arena : NULL);
+ Message* message = oneof_prototype_->New(GetParam() ? &arena : NULL);
// Check default values.
const Descriptor* descriptor = message->GetDescriptor();
const Reflection* reflection = message->GetReflection();
- EXPECT_EQ(0, reflection->GetInt32(
- *message, descriptor->FindFieldByName("foo_int")));
+ EXPECT_EQ(0, reflection->GetInt32(*message,
+ descriptor->FindFieldByName("foo_int")));
EXPECT_EQ("", reflection->GetString(
- *message, descriptor->FindFieldByName("foo_string")));
+ *message, descriptor->FindFieldByName("foo_string")));
+ EXPECT_EQ("", reflection->GetString(*message,
+ descriptor->FindFieldByName("foo_cord")));
EXPECT_EQ("", reflection->GetString(
- *message, descriptor->FindFieldByName("foo_cord")));
+ *message, descriptor->FindFieldByName("foo_string_piece")));
EXPECT_EQ("", reflection->GetString(
- *message, descriptor->FindFieldByName("foo_string_piece")));
- EXPECT_EQ("", reflection->GetString(
- *message, descriptor->FindFieldByName("foo_bytes")));
- EXPECT_EQ(unittest::TestOneof2::FOO, reflection->GetEnum(
- *message, descriptor->FindFieldByName("foo_enum"))->number());
+ *message, descriptor->FindFieldByName("foo_bytes")));
+ EXPECT_EQ(
+ unittest::TestOneof2::FOO,
+ reflection->GetEnum(*message, descriptor->FindFieldByName("foo_enum"))
+ ->number());
const Descriptor* nested_descriptor;
const Message* nested_prototype;
nested_descriptor =
@@ -219,23 +220,26 @@
pool_.FindMessageTypeByName("protobuf_unittest.TestOneof2.FooGroup");
foogroup_prototype = factory_.GetPrototype(foogroup_descriptor);
EXPECT_EQ(foogroup_prototype,
- &reflection->GetMessage(
- *message, descriptor->FindFieldByName("foogroup")));
+ &reflection->GetMessage(*message,
+ descriptor->FindFieldByName("foogroup")));
EXPECT_NE(foogroup_prototype,
&reflection->GetMessage(
*message, descriptor->FindFieldByName("foo_lazy_message")));
- EXPECT_EQ(5, reflection->GetInt32(
- *message, descriptor->FindFieldByName("bar_int")));
+ EXPECT_EQ(5, reflection->GetInt32(*message,
+ descriptor->FindFieldByName("bar_int")));
EXPECT_EQ("STRING", reflection->GetString(
- *message, descriptor->FindFieldByName("bar_string")));
+ *message, descriptor->FindFieldByName("bar_string")));
EXPECT_EQ("CORD", reflection->GetString(
- *message, descriptor->FindFieldByName("bar_cord")));
- EXPECT_EQ("SPIECE", reflection->GetString(
- *message, descriptor->FindFieldByName("bar_string_piece")));
+ *message, descriptor->FindFieldByName("bar_cord")));
+ EXPECT_EQ("SPIECE",
+ reflection->GetString(
+ *message, descriptor->FindFieldByName("bar_string_piece")));
EXPECT_EQ("BYTES", reflection->GetString(
- *message, descriptor->FindFieldByName("bar_bytes")));
- EXPECT_EQ(unittest::TestOneof2::BAR, reflection->GetEnum(
- *message, descriptor->FindFieldByName("bar_enum"))->number());
+ *message, descriptor->FindFieldByName("bar_bytes")));
+ EXPECT_EQ(
+ unittest::TestOneof2::BAR,
+ reflection->GetEnum(*message, descriptor->FindFieldByName("bar_enum"))
+ ->number());
// Check set functions.
TestUtil::ReflectionTester reflection_tester(oneof_descriptor_);
@@ -254,7 +258,7 @@
// to test very much here. Just make sure it appears to be working.
Arena arena;
- Message* message = prototype_->New(GetParam()? &arena : NULL);
+ Message* message = prototype_->New(GetParam() ? &arena : NULL);
TestUtil::ReflectionTester reflection_tester(descriptor_);
int initial_space_used = message->SpaceUsed();
diff --git a/src/google/protobuf/empty.pb.cc b/src/google/protobuf/empty.pb.cc
index 57b8fe8..c10bf94 100644
--- a/src/google/protobuf/empty.pb.cc
+++ b/src/google/protobuf/empty.pb.cc
@@ -36,10 +36,6 @@
PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Empty_google_2fprotobuf_2fempty_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsEmpty_google_2fprotobuf_2fempty_2eproto}, {}};
-void InitDefaults_google_2fprotobuf_2fempty_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Empty_google_2fprotobuf_2fempty_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2fempty_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2fempty_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fempty_2eproto = nullptr;
@@ -73,8 +69,7 @@
".WellKnownTypesb\006proto3"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fempty_2eproto = {
- false, InitDefaults_google_2fprotobuf_2fempty_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2fempty_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2fempty_2eproto,
"google/protobuf/empty.proto", &assign_descriptors_table_google_2fprotobuf_2fempty_2eproto, 183,
};
@@ -82,6 +77,7 @@
static constexpr ::PROTOBUF_NAMESPACE_ID::internal::InitFunc deps[1] =
{
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Empty_google_2fprotobuf_2fempty_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2fempty_2eproto, deps, 0);
}
@@ -157,24 +153,30 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Empty::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
default: {
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Empty::MergePartialFromCodedStream(
diff --git a/src/google/protobuf/extension_set.cc b/src/google/protobuf/extension_set.cc
index d0a63b9..67b0fca 100644
--- a/src/google/protobuf/extension_set.cc
+++ b/src/google/protobuf/extension_set.cc
@@ -76,8 +76,8 @@
case WireFormatLite::WIRETYPE_END_GROUP:
return false;
- // Do not add a default statement. Let the compiler complain when someone
- // adds a new wire type.
+ // Do not add a default statement. Let the compiler complain when someone
+ // adds a new wire type.
}
GOOGLE_LOG(FATAL) << "can't reach here.";
return false;
@@ -99,20 +99,20 @@
// This function is only called at startup, so there is no need for thread-
// safety.
-void Register(const MessageLite* containing_type,
- int number, ExtensionInfo info) {
+void Register(const MessageLite* containing_type, int number,
+ ExtensionInfo info) {
static auto local_static_registry = OnShutdownDelete(new ExtensionRegistry);
global_registry = local_static_registry;
if (!InsertIfNotPresent(local_static_registry,
std::make_pair(containing_type, number), info)) {
GOOGLE_LOG(FATAL) << "Multiple extension registrations for type \""
- << containing_type->GetTypeName()
- << "\", field number " << number << ".";
+ << containing_type->GetTypeName() << "\", field number "
+ << number << ".";
}
}
-const ExtensionInfo* FindRegisteredExtension(
- const MessageLite* containing_type, int number) {
+const ExtensionInfo* FindRegisteredExtension(const MessageLite* containing_type,
+ int number) {
return global_registry == nullptr
? nullptr
: FindOrNull(*global_registry,
@@ -212,8 +212,8 @@
}
}
-void ExtensionSet::DeleteFlatMap(
- const ExtensionSet::KeyValue* flat, uint16 flat_capacity) {
+void ExtensionSet::DeleteFlatMap(const ExtensionSet::KeyValue* flat,
+ uint16 flat_capacity) {
#ifdef __cpp_sized_deallocation
// Arena::CreateArray already requires a trivially destructible type, but
// ensure this constraint is not violated in the future.
@@ -221,9 +221,9 @@
"CreateArray requires a trivially destructible type");
// A const-cast is needed, but this is safe as we are about to deallocate the
// array.
- ::operator delete[](
- const_cast<ExtensionSet::KeyValue*>(flat), sizeof(*flat) * flat_capacity);
-#else // !__cpp_sized_deallocation
+ ::operator delete[](const_cast<ExtensionSet::KeyValue*>(flat),
+ sizeof(*flat) * flat_capacity);
+#else // !__cpp_sized_deallocation
delete[] flat;
#endif // !__cpp_sized_deallocation
}
@@ -278,10 +278,7 @@
namespace {
-enum {
- REPEATED_FIELD,
- OPTIONAL_FIELD
-};
+enum { REPEATED_FIELD, OPTIONAL_FIELD };
} // namespace
@@ -292,74 +289,77 @@
// -------------------------------------------------------------------
// Primitives
-#define PRIMITIVE_ACCESSORS(UPPERCASE, LOWERCASE, CAMELCASE) \
- \
-LOWERCASE ExtensionSet::Get##CAMELCASE(int number, \
- LOWERCASE default_value) const { \
- const Extension* extension = FindOrNull(number); \
- if (extension == NULL || extension->is_cleared) { \
- return default_value; \
- } else { \
- GOOGLE_DCHECK_TYPE(*extension, OPTIONAL_FIELD, UPPERCASE); \
- return extension->LOWERCASE##_value; \
- } \
-} \
- \
-void ExtensionSet::Set##CAMELCASE(int number, FieldType type, \
- LOWERCASE value, \
- const FieldDescriptor* descriptor) { \
- Extension* extension; \
- if (MaybeNewExtension(number, descriptor, &extension)) { \
- extension->type = type; \
- GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_##UPPERCASE); \
- extension->is_repeated = false; \
- } else { \
- GOOGLE_DCHECK_TYPE(*extension, OPTIONAL_FIELD, UPPERCASE); \
- } \
- extension->is_cleared = false; \
- extension->LOWERCASE##_value = value; \
-} \
- \
-LOWERCASE ExtensionSet::GetRepeated##CAMELCASE(int number, int index) const { \
- const Extension* extension = FindOrNull(number); \
- GOOGLE_CHECK(extension != NULL) << "Index out-of-bounds (field is empty)."; \
- GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, UPPERCASE); \
- return extension->repeated_##LOWERCASE##_value->Get(index); \
-} \
- \
-void ExtensionSet::SetRepeated##CAMELCASE( \
- int number, int index, LOWERCASE value) { \
- Extension* extension = FindOrNull(number); \
- GOOGLE_CHECK(extension != NULL) << "Index out-of-bounds (field is empty)."; \
- GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, UPPERCASE); \
- extension->repeated_##LOWERCASE##_value->Set(index, value); \
-} \
- \
-void ExtensionSet::Add##CAMELCASE(int number, FieldType type, \
- bool packed, LOWERCASE value, \
- const FieldDescriptor* descriptor) { \
- Extension* extension; \
- if (MaybeNewExtension(number, descriptor, &extension)) { \
- extension->type = type; \
- GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_##UPPERCASE); \
- extension->is_repeated = true; \
- extension->is_packed = packed; \
- extension->repeated_##LOWERCASE##_value = \
- Arena::CreateMessage<RepeatedField<LOWERCASE> >(arena_); \
- } else { \
- GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, UPPERCASE); \
- GOOGLE_DCHECK_EQ(extension->is_packed, packed); \
- } \
- extension->repeated_##LOWERCASE##_value->Add(value); \
-}
+#define PRIMITIVE_ACCESSORS(UPPERCASE, LOWERCASE, CAMELCASE) \
+ \
+ LOWERCASE ExtensionSet::Get##CAMELCASE(int number, LOWERCASE default_value) \
+ const { \
+ const Extension* extension = FindOrNull(number); \
+ if (extension == NULL || extension->is_cleared) { \
+ return default_value; \
+ } else { \
+ GOOGLE_DCHECK_TYPE(*extension, OPTIONAL_FIELD, UPPERCASE); \
+ return extension->LOWERCASE##_value; \
+ } \
+ } \
+ \
+ void ExtensionSet::Set##CAMELCASE(int number, FieldType type, \
+ LOWERCASE value, \
+ const FieldDescriptor* descriptor) { \
+ Extension* extension; \
+ if (MaybeNewExtension(number, descriptor, &extension)) { \
+ extension->type = type; \
+ GOOGLE_DCHECK_EQ(cpp_type(extension->type), \
+ WireFormatLite::CPPTYPE_##UPPERCASE); \
+ extension->is_repeated = false; \
+ } else { \
+ GOOGLE_DCHECK_TYPE(*extension, OPTIONAL_FIELD, UPPERCASE); \
+ } \
+ extension->is_cleared = false; \
+ extension->LOWERCASE##_value = value; \
+ } \
+ \
+ LOWERCASE ExtensionSet::GetRepeated##CAMELCASE(int number, int index) \
+ const { \
+ const Extension* extension = FindOrNull(number); \
+ GOOGLE_CHECK(extension != NULL) << "Index out-of-bounds (field is empty)."; \
+ GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, UPPERCASE); \
+ return extension->repeated_##LOWERCASE##_value->Get(index); \
+ } \
+ \
+ void ExtensionSet::SetRepeated##CAMELCASE(int number, int index, \
+ LOWERCASE value) { \
+ Extension* extension = FindOrNull(number); \
+ GOOGLE_CHECK(extension != NULL) << "Index out-of-bounds (field is empty)."; \
+ GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, UPPERCASE); \
+ extension->repeated_##LOWERCASE##_value->Set(index, value); \
+ } \
+ \
+ void ExtensionSet::Add##CAMELCASE(int number, FieldType type, bool packed, \
+ LOWERCASE value, \
+ const FieldDescriptor* descriptor) { \
+ Extension* extension; \
+ if (MaybeNewExtension(number, descriptor, &extension)) { \
+ extension->type = type; \
+ GOOGLE_DCHECK_EQ(cpp_type(extension->type), \
+ WireFormatLite::CPPTYPE_##UPPERCASE); \
+ extension->is_repeated = true; \
+ extension->is_packed = packed; \
+ extension->repeated_##LOWERCASE##_value = \
+ Arena::CreateMessage<RepeatedField<LOWERCASE>>(arena_); \
+ } else { \
+ GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, UPPERCASE); \
+ GOOGLE_DCHECK_EQ(extension->is_packed, packed); \
+ } \
+ extension->repeated_##LOWERCASE##_value->Add(value); \
+ }
-PRIMITIVE_ACCESSORS( INT32, int32, Int32)
-PRIMITIVE_ACCESSORS( INT64, int64, Int64)
+PRIMITIVE_ACCESSORS(INT32, int32, Int32)
+PRIMITIVE_ACCESSORS(INT64, int64, Int64)
PRIMITIVE_ACCESSORS(UINT32, uint32, UInt32)
PRIMITIVE_ACCESSORS(UINT64, uint64, UInt64)
-PRIMITIVE_ACCESSORS( FLOAT, float, Float)
+PRIMITIVE_ACCESSORS(FLOAT, float, Float)
PRIMITIVE_ACCESSORS(DOUBLE, double, Double)
-PRIMITIVE_ACCESSORS( BOOL, bool, Bool)
+PRIMITIVE_ACCESSORS(BOOL, bool, Bool)
#undef PRIMITIVE_ACCESSORS
@@ -390,35 +390,35 @@
static_cast<WireFormatLite::FieldType>(field_type))) {
case WireFormatLite::CPPTYPE_INT32:
extension->repeated_int32_value =
- Arena::CreateMessage<RepeatedField<int32> >(arena_);
+ Arena::CreateMessage<RepeatedField<int32>>(arena_);
break;
case WireFormatLite::CPPTYPE_INT64:
extension->repeated_int64_value =
- Arena::CreateMessage<RepeatedField<int64> >(arena_);
+ Arena::CreateMessage<RepeatedField<int64>>(arena_);
break;
case WireFormatLite::CPPTYPE_UINT32:
extension->repeated_uint32_value =
- Arena::CreateMessage<RepeatedField<uint32> >(arena_);
+ Arena::CreateMessage<RepeatedField<uint32>>(arena_);
break;
case WireFormatLite::CPPTYPE_UINT64:
extension->repeated_uint64_value =
- Arena::CreateMessage<RepeatedField<uint64> >(arena_);
+ Arena::CreateMessage<RepeatedField<uint64>>(arena_);
break;
case WireFormatLite::CPPTYPE_DOUBLE:
extension->repeated_double_value =
- Arena::CreateMessage<RepeatedField<double> >(arena_);
+ Arena::CreateMessage<RepeatedField<double>>(arena_);
break;
case WireFormatLite::CPPTYPE_FLOAT:
extension->repeated_float_value =
- Arena::CreateMessage<RepeatedField<float> >(arena_);
+ Arena::CreateMessage<RepeatedField<float>>(arena_);
break;
case WireFormatLite::CPPTYPE_BOOL:
extension->repeated_bool_value =
- Arena::CreateMessage<RepeatedField<bool> >(arena_);
+ Arena::CreateMessage<RepeatedField<bool>>(arena_);
break;
case WireFormatLite::CPPTYPE_ENUM:
extension->repeated_enum_value =
- Arena::CreateMessage<RepeatedField<int> >(arena_);
+ Arena::CreateMessage<RepeatedField<int>>(arena_);
break;
case WireFormatLite::CPPTYPE_STRING:
extension->repeated_string_value =
@@ -426,7 +426,7 @@
break;
case WireFormatLite::CPPTYPE_MESSAGE:
extension->repeated_message_value =
- Arena::CreateMessage<RepeatedPtrField<MessageLite> >(arena_);
+ Arena::CreateMessage<RepeatedPtrField<MessageLite>>(arena_);
break;
}
}
@@ -446,7 +446,6 @@
return extension->repeated_int32_value;
}
-
// -------------------------------------------------------------------
// Enums
@@ -489,8 +488,7 @@
extension->repeated_enum_value->Set(index, value);
}
-void ExtensionSet::AddEnum(int number, FieldType type,
- bool packed, int value,
+void ExtensionSet::AddEnum(int number, FieldType type, bool packed, int value,
const FieldDescriptor* descriptor) {
Extension* extension;
if (MaybeNewExtension(number, descriptor, &extension)) {
@@ -499,7 +497,7 @@
extension->is_repeated = true;
extension->is_packed = packed;
extension->repeated_enum_value =
- Arena::CreateMessage<RepeatedField<int> >(arena_);
+ Arena::CreateMessage<RepeatedField<int>>(arena_);
} else {
GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, ENUM);
GOOGLE_DCHECK_EQ(extension->is_packed, packed);
@@ -748,8 +746,8 @@
// MessageLite* ExtensionSet::ReleaseMessage(const FieldDescriptor* descriptor,
// MessageFactory* factory);
-const MessageLite& ExtensionSet::GetRepeatedMessage(
- int number, int index) const {
+const MessageLite& ExtensionSet::GetRepeatedMessage(int number,
+ int index) const {
const Extension* extension = FindOrNull(number);
GOOGLE_CHECK(extension != NULL) << "Index out-of-bounds (field is empty).";
GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, MESSAGE);
@@ -772,7 +770,7 @@
GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_MESSAGE);
extension->is_repeated = true;
extension->repeated_message_value =
- Arena::CreateMessage<RepeatedPtrField<MessageLite> >(arena_);
+ Arena::CreateMessage<RepeatedPtrField<MessageLite>>(arena_);
} else {
GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, MESSAGE);
}
@@ -801,7 +799,7 @@
GOOGLE_CHECK(extension != NULL) << "Index out-of-bounds (field is empty).";
GOOGLE_DCHECK(extension->is_repeated);
- switch(cpp_type(extension->type)) {
+ switch (cpp_type(extension->type)) {
case WireFormatLite::CPPTYPE_INT32:
extension->repeated_int32_value->RemoveLast();
break;
@@ -848,7 +846,7 @@
GOOGLE_CHECK(extension != NULL) << "Index out-of-bounds (field is empty).";
GOOGLE_DCHECK(extension->is_repeated);
- switch(cpp_type(extension->type)) {
+ switch (cpp_type(extension->type)) {
case WireFormatLite::CPPTYPE_INT32:
extension->repeated_int32_value->SwapElements(index1, index2);
break;
@@ -927,11 +925,11 @@
}
void ExtensionSet::InternalExtensionMergeFrom(
- int number, const Extension& other_extension) {
+ int number, const Extension& other_extension) {
if (other_extension.is_repeated) {
Extension* extension;
- bool is_new = MaybeNewExtension(number, other_extension.descriptor,
- &extension);
+ bool is_new =
+ MaybeNewExtension(number, other_extension.descriptor, &extension);
if (is_new) {
// Extension did not already exist in set.
extension->type = other_extension.type;
@@ -944,31 +942,31 @@
}
switch (cpp_type(other_extension.type)) {
-#define HANDLE_TYPE(UPPERCASE, LOWERCASE, REPEATED_TYPE) \
- case WireFormatLite::CPPTYPE_##UPPERCASE: \
- if (is_new) { \
- extension->repeated_##LOWERCASE##_value = \
- Arena::CreateMessage<REPEATED_TYPE >(arena_); \
- } \
- extension->repeated_##LOWERCASE##_value->MergeFrom( \
- *other_extension.repeated_##LOWERCASE##_value); \
- break;
+#define HANDLE_TYPE(UPPERCASE, LOWERCASE, REPEATED_TYPE) \
+ case WireFormatLite::CPPTYPE_##UPPERCASE: \
+ if (is_new) { \
+ extension->repeated_##LOWERCASE##_value = \
+ Arena::CreateMessage<REPEATED_TYPE>(arena_); \
+ } \
+ extension->repeated_##LOWERCASE##_value->MergeFrom( \
+ *other_extension.repeated_##LOWERCASE##_value); \
+ break;
- HANDLE_TYPE( INT32, int32, RepeatedField < int32>);
- HANDLE_TYPE( INT64, int64, RepeatedField < int64>);
- HANDLE_TYPE( UINT32, uint32, RepeatedField < uint32>);
- HANDLE_TYPE( UINT64, uint64, RepeatedField < uint64>);
- HANDLE_TYPE( FLOAT, float, RepeatedField < float>);
- HANDLE_TYPE( DOUBLE, double, RepeatedField < double>);
- HANDLE_TYPE( BOOL, bool, RepeatedField < bool>);
- HANDLE_TYPE( ENUM, enum, RepeatedField < int>);
+ HANDLE_TYPE(INT32, int32, RepeatedField<int32>);
+ HANDLE_TYPE(INT64, int64, RepeatedField<int64>);
+ HANDLE_TYPE(UINT32, uint32, RepeatedField<uint32>);
+ HANDLE_TYPE(UINT64, uint64, RepeatedField<uint64>);
+ HANDLE_TYPE(FLOAT, float, RepeatedField<float>);
+ HANDLE_TYPE(DOUBLE, double, RepeatedField<double>);
+ HANDLE_TYPE(BOOL, bool, RepeatedField<bool>);
+ HANDLE_TYPE(ENUM, enum, RepeatedField<int>);
HANDLE_TYPE(STRING, string, RepeatedPtrField<std::string>);
#undef HANDLE_TYPE
case WireFormatLite::CPPTYPE_MESSAGE:
if (is_new) {
extension->repeated_message_value =
- Arena::CreateMessage<RepeatedPtrField<MessageLite> >(arena_);
+ Arena::CreateMessage<RepeatedPtrField<MessageLite>>(arena_);
}
// We can't call RepeatedPtrField<MessageLite>::MergeFrom() because
// it would attempt to allocate new objects.
@@ -991,32 +989,30 @@
} else {
if (!other_extension.is_cleared) {
switch (cpp_type(other_extension.type)) {
-#define HANDLE_TYPE(UPPERCASE, LOWERCASE, CAMELCASE) \
- case WireFormatLite::CPPTYPE_##UPPERCASE: \
- Set##CAMELCASE(number, other_extension.type, \
- other_extension.LOWERCASE##_value, \
- other_extension.descriptor); \
- break;
+#define HANDLE_TYPE(UPPERCASE, LOWERCASE, CAMELCASE) \
+ case WireFormatLite::CPPTYPE_##UPPERCASE: \
+ Set##CAMELCASE(number, other_extension.type, \
+ other_extension.LOWERCASE##_value, \
+ other_extension.descriptor); \
+ break;
- HANDLE_TYPE( INT32, int32, Int32);
- HANDLE_TYPE( INT64, int64, Int64);
+ HANDLE_TYPE(INT32, int32, Int32);
+ HANDLE_TYPE(INT64, int64, Int64);
HANDLE_TYPE(UINT32, uint32, UInt32);
HANDLE_TYPE(UINT64, uint64, UInt64);
- HANDLE_TYPE( FLOAT, float, Float);
+ HANDLE_TYPE(FLOAT, float, Float);
HANDLE_TYPE(DOUBLE, double, Double);
- HANDLE_TYPE( BOOL, bool, Bool);
- HANDLE_TYPE( ENUM, enum, Enum);
+ HANDLE_TYPE(BOOL, bool, Bool);
+ HANDLE_TYPE(ENUM, enum, Enum);
#undef HANDLE_TYPE
case WireFormatLite::CPPTYPE_STRING:
- SetString(number, other_extension.type,
- *other_extension.string_value,
+ SetString(number, other_extension.type, *other_extension.string_value,
other_extension.descriptor);
break;
case WireFormatLite::CPPTYPE_MESSAGE: {
Extension* extension;
- bool is_new = MaybeNewExtension(number,
- other_extension.descriptor,
- &extension);
+ bool is_new =
+ MaybeNewExtension(number, other_extension.descriptor, &extension);
if (is_new) {
extension->type = other_extension.type;
extension->is_packed = other_extension.is_packed;
@@ -1036,7 +1032,7 @@
}
} else {
GOOGLE_DCHECK_EQ(extension->type, other_extension.type);
- GOOGLE_DCHECK_EQ(extension->is_packed,other_extension.is_packed);
+ GOOGLE_DCHECK_EQ(extension->is_packed, other_extension.is_packed);
GOOGLE_DCHECK(!extension->is_repeated);
if (other_extension.is_lazy) {
if (extension->is_lazy) {
@@ -1049,9 +1045,9 @@
}
} else {
if (extension->is_lazy) {
- extension->lazymessage_value->MutableMessage(
- *other_extension.message_value)->CheckTypeAndMergeFrom(
- *other_extension.message_value);
+ extension->lazymessage_value
+ ->MutableMessage(*other_extension.message_value)
+ ->CheckTypeAndMergeFrom(*other_extension.message_value);
} else {
extension->message_value->CheckTypeAndMergeFrom(
*other_extension.message_value);
@@ -1085,8 +1081,7 @@
}
}
-void ExtensionSet::SwapExtension(ExtensionSet* other,
- int number) {
+void ExtensionSet::SwapExtension(ExtensionSet* other, int number) {
if (this == other) return;
Extension* this_ext = FindOrNull(number);
Extension* other_ext = other->FindOrNull(number);
@@ -1152,9 +1147,11 @@
return true;
}
-bool ExtensionSet::FindExtensionInfoFromTag(
- uint32 tag, ExtensionFinder* extension_finder, int* field_number,
- ExtensionInfo* extension, bool* was_packed_on_wire) {
+bool ExtensionSet::FindExtensionInfoFromTag(uint32 tag,
+ ExtensionFinder* extension_finder,
+ int* field_number,
+ ExtensionInfo* extension,
+ bool* was_packed_on_wire) {
*field_number = WireFormatLite::GetTagFieldNumber(tag);
WireFormatLite::WireType wire_type = WireFormatLite::GetTagWireType(tag);
return FindExtensionInfoFromFieldNumber(wire_type, *field_number,
@@ -1190,12 +1187,12 @@
int number;
bool was_packed_on_wire;
ExtensionInfo extension;
- if (!FindExtensionInfoFromTag(
- tag, extension_finder, &number, &extension, &was_packed_on_wire)) {
+ if (!FindExtensionInfoFromTag(tag, extension_finder, &number, &extension,
+ &was_packed_on_wire)) {
return field_skipper->SkipField(input, tag);
} else {
- return ParseFieldWithExtensionInfo(
- number, was_packed_on_wire, extension, input, field_skipper);
+ return ParseFieldWithExtensionInfo(number, was_packed_on_wire, extension,
+ input, field_skipper);
}
}
@@ -1225,10 +1222,11 @@
#endif
-bool ExtensionSet::ParseFieldWithExtensionInfo(
- int number, bool was_packed_on_wire, const ExtensionInfo& extension,
- io::CodedInputStream* input,
- FieldSkipper* field_skipper) {
+bool ExtensionSet::ParseFieldWithExtensionInfo(int number,
+ bool was_packed_on_wire,
+ const ExtensionInfo& extension,
+ io::CodedInputStream* input,
+ FieldSkipper* field_skipper) {
// Explicitly not read extension.is_packed, instead check whether the field
// was encoded in packed form on the wire.
if (was_packed_on_wire) {
@@ -1237,39 +1235,40 @@
io::CodedInputStream::Limit limit = input->PushLimit(size);
switch (extension.type) {
-#define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE, CPP_LOWERCASE) \
- case WireFormatLite::TYPE_##UPPERCASE: \
- while (input->BytesUntilLimit() > 0) { \
- CPP_LOWERCASE value; \
- if (!WireFormatLite::ReadPrimitive< \
- CPP_LOWERCASE, WireFormatLite::TYPE_##UPPERCASE>( \
- input, &value)) return false; \
- Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, \
- extension.is_packed, value, \
- extension.descriptor); \
- } \
- break
+#define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE, CPP_LOWERCASE) \
+ case WireFormatLite::TYPE_##UPPERCASE: \
+ while (input->BytesUntilLimit() > 0) { \
+ CPP_LOWERCASE value; \
+ if (!WireFormatLite::ReadPrimitive<CPP_LOWERCASE, \
+ WireFormatLite::TYPE_##UPPERCASE>( \
+ input, &value)) \
+ return false; \
+ Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, \
+ extension.is_packed, value, extension.descriptor); \
+ } \
+ break
- HANDLE_TYPE( INT32, Int32, int32);
- HANDLE_TYPE( INT64, Int64, int64);
- HANDLE_TYPE( UINT32, UInt32, uint32);
- HANDLE_TYPE( UINT64, UInt64, uint64);
- HANDLE_TYPE( SINT32, Int32, int32);
- HANDLE_TYPE( SINT64, Int64, int64);
- HANDLE_TYPE( FIXED32, UInt32, uint32);
- HANDLE_TYPE( FIXED64, UInt64, uint64);
- HANDLE_TYPE(SFIXED32, Int32, int32);
- HANDLE_TYPE(SFIXED64, Int64, int64);
- HANDLE_TYPE( FLOAT, Float, float);
- HANDLE_TYPE( DOUBLE, Double, double);
- HANDLE_TYPE( BOOL, Bool, bool);
+ HANDLE_TYPE(INT32, Int32, int32);
+ HANDLE_TYPE(INT64, Int64, int64);
+ HANDLE_TYPE(UINT32, UInt32, uint32);
+ HANDLE_TYPE(UINT64, UInt64, uint64);
+ HANDLE_TYPE(SINT32, Int32, int32);
+ HANDLE_TYPE(SINT64, Int64, int64);
+ HANDLE_TYPE(FIXED32, UInt32, uint32);
+ HANDLE_TYPE(FIXED64, UInt64, uint64);
+ HANDLE_TYPE(SFIXED32, Int32, int32);
+ HANDLE_TYPE(SFIXED64, Int64, int64);
+ HANDLE_TYPE(FLOAT, Float, float);
+ HANDLE_TYPE(DOUBLE, Double, double);
+ HANDLE_TYPE(BOOL, Bool, bool);
#undef HANDLE_TYPE
case WireFormatLite::TYPE_ENUM:
while (input->BytesUntilLimit() > 0) {
int value;
if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
- input, &value)) return false;
+ input, &value))
+ return false;
if (extension.enum_validity_check.func(
extension.enum_validity_check.arg, value)) {
AddEnum(number, WireFormatLite::TYPE_ENUM, extension.is_packed,
@@ -1292,41 +1291,42 @@
input->PopLimit(limit);
} else {
switch (extension.type) {
-#define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE, CPP_LOWERCASE) \
- case WireFormatLite::TYPE_##UPPERCASE: { \
- CPP_LOWERCASE value; \
- if (!WireFormatLite::ReadPrimitive< \
- CPP_LOWERCASE, WireFormatLite::TYPE_##UPPERCASE>( \
- input, &value)) return false; \
- if (extension.is_repeated) { \
- Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, \
- extension.is_packed, value, \
- extension.descriptor); \
- } else { \
- Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value, \
- extension.descriptor); \
- } \
- } break
+#define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE, CPP_LOWERCASE) \
+ case WireFormatLite::TYPE_##UPPERCASE: { \
+ CPP_LOWERCASE value; \
+ if (!WireFormatLite::ReadPrimitive<CPP_LOWERCASE, \
+ WireFormatLite::TYPE_##UPPERCASE>( \
+ input, &value)) \
+ return false; \
+ if (extension.is_repeated) { \
+ Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, \
+ extension.is_packed, value, extension.descriptor); \
+ } else { \
+ Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value, \
+ extension.descriptor); \
+ } \
+ } break
- HANDLE_TYPE( INT32, Int32, int32);
- HANDLE_TYPE( INT64, Int64, int64);
- HANDLE_TYPE( UINT32, UInt32, uint32);
- HANDLE_TYPE( UINT64, UInt64, uint64);
- HANDLE_TYPE( SINT32, Int32, int32);
- HANDLE_TYPE( SINT64, Int64, int64);
- HANDLE_TYPE( FIXED32, UInt32, uint32);
- HANDLE_TYPE( FIXED64, UInt64, uint64);
- HANDLE_TYPE(SFIXED32, Int32, int32);
- HANDLE_TYPE(SFIXED64, Int64, int64);
- HANDLE_TYPE( FLOAT, Float, float);
- HANDLE_TYPE( DOUBLE, Double, double);
- HANDLE_TYPE( BOOL, Bool, bool);
+ HANDLE_TYPE(INT32, Int32, int32);
+ HANDLE_TYPE(INT64, Int64, int64);
+ HANDLE_TYPE(UINT32, UInt32, uint32);
+ HANDLE_TYPE(UINT64, UInt64, uint64);
+ HANDLE_TYPE(SINT32, Int32, int32);
+ HANDLE_TYPE(SINT64, Int64, int64);
+ HANDLE_TYPE(FIXED32, UInt32, uint32);
+ HANDLE_TYPE(FIXED64, UInt64, uint64);
+ HANDLE_TYPE(SFIXED32, Int32, int32);
+ HANDLE_TYPE(SFIXED64, Int64, int64);
+ HANDLE_TYPE(FLOAT, Float, float);
+ HANDLE_TYPE(DOUBLE, Double, double);
+ HANDLE_TYPE(BOOL, Bool, bool);
#undef HANDLE_TYPE
case WireFormatLite::TYPE_ENUM: {
int value;
if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
- input, &value)) return false;
+ input, &value))
+ return false;
if (!extension.enum_validity_check.func(
extension.enum_validity_check.arg, value)) {
@@ -1342,7 +1342,7 @@
break;
}
- case WireFormatLite::TYPE_STRING: {
+ case WireFormatLite::TYPE_STRING: {
std::string* value =
extension.is_repeated
? AddString(number, WireFormatLite::TYPE_STRING,
@@ -1353,7 +1353,7 @@
break;
}
- case WireFormatLite::TYPE_BYTES: {
+ case WireFormatLite::TYPE_BYTES: {
std::string* value =
extension.is_repeated
? AddString(number, WireFormatLite::TYPE_BYTES,
@@ -1510,20 +1510,20 @@
void ExtensionSet::Extension::Clear() {
if (is_repeated) {
switch (cpp_type(type)) {
-#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
- case WireFormatLite::CPPTYPE_##UPPERCASE: \
- repeated_##LOWERCASE##_value->Clear(); \
- break
+#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
+ case WireFormatLite::CPPTYPE_##UPPERCASE: \
+ repeated_##LOWERCASE##_value->Clear(); \
+ break
- HANDLE_TYPE( INT32, int32);
- HANDLE_TYPE( INT64, int64);
- HANDLE_TYPE( UINT32, uint32);
- HANDLE_TYPE( UINT64, uint64);
- HANDLE_TYPE( FLOAT, float);
- HANDLE_TYPE( DOUBLE, double);
- HANDLE_TYPE( BOOL, bool);
- HANDLE_TYPE( ENUM, enum);
- HANDLE_TYPE( STRING, string);
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
+ HANDLE_TYPE(UINT32, uint32);
+ HANDLE_TYPE(UINT64, uint64);
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(DOUBLE, double);
+ HANDLE_TYPE(BOOL, bool);
+ HANDLE_TYPE(ENUM, enum);
+ HANDLE_TYPE(STRING, string);
HANDLE_TYPE(MESSAGE, message);
#undef HANDLE_TYPE
}
@@ -1553,39 +1553,38 @@
}
void ExtensionSet::Extension::SerializeFieldWithCachedSizes(
- int number,
- io::CodedOutputStream* output) const {
+ int number, io::CodedOutputStream* output) const {
if (is_repeated) {
if (is_packed) {
if (cached_size == 0) return;
- WireFormatLite::WriteTag(number,
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+ WireFormatLite::WriteTag(
+ number, WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
output->WriteVarint32(cached_size);
switch (real_type(type)) {
-#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
- case WireFormatLite::TYPE_##UPPERCASE: \
- for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
- WireFormatLite::Write##CAMELCASE##NoTag( \
- repeated_##LOWERCASE##_value->Get(i), output); \
- } \
- break
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
+ case WireFormatLite::TYPE_##UPPERCASE: \
+ for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
+ WireFormatLite::Write##CAMELCASE##NoTag( \
+ repeated_##LOWERCASE##_value->Get(i), output); \
+ } \
+ break
- HANDLE_TYPE( INT32, Int32, int32);
- HANDLE_TYPE( INT64, Int64, int64);
- HANDLE_TYPE( UINT32, UInt32, uint32);
- HANDLE_TYPE( UINT64, UInt64, uint64);
- HANDLE_TYPE( SINT32, SInt32, int32);
- HANDLE_TYPE( SINT64, SInt64, int64);
- HANDLE_TYPE( FIXED32, Fixed32, uint32);
- HANDLE_TYPE( FIXED64, Fixed64, uint64);
- HANDLE_TYPE(SFIXED32, SFixed32, int32);
- HANDLE_TYPE(SFIXED64, SFixed64, int64);
- HANDLE_TYPE( FLOAT, Float, float);
- HANDLE_TYPE( DOUBLE, Double, double);
- HANDLE_TYPE( BOOL, Bool, bool);
- HANDLE_TYPE( ENUM, Enum, enum);
+ HANDLE_TYPE(INT32, Int32, int32);
+ HANDLE_TYPE(INT64, Int64, int64);
+ HANDLE_TYPE(UINT32, UInt32, uint32);
+ HANDLE_TYPE(UINT64, UInt64, uint64);
+ HANDLE_TYPE(SINT32, SInt32, int32);
+ HANDLE_TYPE(SINT64, SInt64, int64);
+ HANDLE_TYPE(FIXED32, Fixed32, uint32);
+ HANDLE_TYPE(FIXED64, Fixed64, uint64);
+ HANDLE_TYPE(SFIXED32, SFixed32, int32);
+ HANDLE_TYPE(SFIXED64, SFixed64, int64);
+ HANDLE_TYPE(FLOAT, Float, float);
+ HANDLE_TYPE(DOUBLE, Double, double);
+ HANDLE_TYPE(BOOL, Bool, bool);
+ HANDLE_TYPE(ENUM, Enum, enum);
#undef HANDLE_TYPE
case WireFormatLite::TYPE_STRING:
@@ -1597,59 +1596,59 @@
}
} else {
switch (real_type(type)) {
-#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
- case WireFormatLite::TYPE_##UPPERCASE: \
- for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
- WireFormatLite::Write##CAMELCASE(number, \
- repeated_##LOWERCASE##_value->Get(i), output); \
- } \
- break
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
+ case WireFormatLite::TYPE_##UPPERCASE: \
+ for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
+ WireFormatLite::Write##CAMELCASE( \
+ number, repeated_##LOWERCASE##_value->Get(i), output); \
+ } \
+ break
- HANDLE_TYPE( INT32, Int32, int32);
- HANDLE_TYPE( INT64, Int64, int64);
- HANDLE_TYPE( UINT32, UInt32, uint32);
- HANDLE_TYPE( UINT64, UInt64, uint64);
- HANDLE_TYPE( SINT32, SInt32, int32);
- HANDLE_TYPE( SINT64, SInt64, int64);
- HANDLE_TYPE( FIXED32, Fixed32, uint32);
- HANDLE_TYPE( FIXED64, Fixed64, uint64);
- HANDLE_TYPE(SFIXED32, SFixed32, int32);
- HANDLE_TYPE(SFIXED64, SFixed64, int64);
- HANDLE_TYPE( FLOAT, Float, float);
- HANDLE_TYPE( DOUBLE, Double, double);
- HANDLE_TYPE( BOOL, Bool, bool);
- HANDLE_TYPE( STRING, String, string);
- HANDLE_TYPE( BYTES, Bytes, string);
- HANDLE_TYPE( ENUM, Enum, enum);
- HANDLE_TYPE( GROUP, Group, message);
- HANDLE_TYPE( MESSAGE, Message, message);
+ HANDLE_TYPE(INT32, Int32, int32);
+ HANDLE_TYPE(INT64, Int64, int64);
+ HANDLE_TYPE(UINT32, UInt32, uint32);
+ HANDLE_TYPE(UINT64, UInt64, uint64);
+ HANDLE_TYPE(SINT32, SInt32, int32);
+ HANDLE_TYPE(SINT64, SInt64, int64);
+ HANDLE_TYPE(FIXED32, Fixed32, uint32);
+ HANDLE_TYPE(FIXED64, Fixed64, uint64);
+ HANDLE_TYPE(SFIXED32, SFixed32, int32);
+ HANDLE_TYPE(SFIXED64, SFixed64, int64);
+ HANDLE_TYPE(FLOAT, Float, float);
+ HANDLE_TYPE(DOUBLE, Double, double);
+ HANDLE_TYPE(BOOL, Bool, bool);
+ HANDLE_TYPE(STRING, String, string);
+ HANDLE_TYPE(BYTES, Bytes, string);
+ HANDLE_TYPE(ENUM, Enum, enum);
+ HANDLE_TYPE(GROUP, Group, message);
+ HANDLE_TYPE(MESSAGE, Message, message);
#undef HANDLE_TYPE
}
}
} else if (!is_cleared) {
switch (real_type(type)) {
-#define HANDLE_TYPE(UPPERCASE, CAMELCASE, VALUE) \
- case WireFormatLite::TYPE_##UPPERCASE: \
- WireFormatLite::Write##CAMELCASE(number, VALUE, output); \
- break
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE, VALUE) \
+ case WireFormatLite::TYPE_##UPPERCASE: \
+ WireFormatLite::Write##CAMELCASE(number, VALUE, output); \
+ break
- HANDLE_TYPE( INT32, Int32, int32_value);
- HANDLE_TYPE( INT64, Int64, int64_value);
- HANDLE_TYPE( UINT32, UInt32, uint32_value);
- HANDLE_TYPE( UINT64, UInt64, uint64_value);
- HANDLE_TYPE( SINT32, SInt32, int32_value);
- HANDLE_TYPE( SINT64, SInt64, int64_value);
- HANDLE_TYPE( FIXED32, Fixed32, uint32_value);
- HANDLE_TYPE( FIXED64, Fixed64, uint64_value);
- HANDLE_TYPE(SFIXED32, SFixed32, int32_value);
- HANDLE_TYPE(SFIXED64, SFixed64, int64_value);
- HANDLE_TYPE( FLOAT, Float, float_value);
- HANDLE_TYPE( DOUBLE, Double, double_value);
- HANDLE_TYPE( BOOL, Bool, bool_value);
- HANDLE_TYPE( STRING, String, *string_value);
- HANDLE_TYPE( BYTES, Bytes, *string_value);
- HANDLE_TYPE( ENUM, Enum, enum_value);
- HANDLE_TYPE( GROUP, Group, *message_value);
+ HANDLE_TYPE(INT32, Int32, int32_value);
+ HANDLE_TYPE(INT64, Int64, int64_value);
+ HANDLE_TYPE(UINT32, UInt32, uint32_value);
+ HANDLE_TYPE(UINT64, UInt64, uint64_value);
+ HANDLE_TYPE(SINT32, SInt32, int32_value);
+ HANDLE_TYPE(SINT64, SInt64, int64_value);
+ HANDLE_TYPE(FIXED32, Fixed32, uint32_value);
+ HANDLE_TYPE(FIXED64, Fixed64, uint64_value);
+ HANDLE_TYPE(SFIXED32, SFixed32, int32_value);
+ HANDLE_TYPE(SFIXED64, SFixed64, int64_value);
+ HANDLE_TYPE(FLOAT, Float, float_value);
+ HANDLE_TYPE(DOUBLE, Double, double_value);
+ HANDLE_TYPE(BOOL, Bool, bool_value);
+ HANDLE_TYPE(STRING, String, *string_value);
+ HANDLE_TYPE(BYTES, Bytes, *string_value);
+ HANDLE_TYPE(ENUM, Enum, enum_value);
+ HANDLE_TYPE(GROUP, Group, *message_value);
#undef HANDLE_TYPE
case WireFormatLite::TYPE_MESSAGE:
if (is_lazy) {
@@ -1668,36 +1667,36 @@
if (is_repeated) {
if (is_packed) {
switch (real_type(type)) {
-#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
- case WireFormatLite::TYPE_##UPPERCASE: \
- for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
- result += WireFormatLite::CAMELCASE##Size( \
- repeated_##LOWERCASE##_value->Get(i)); \
- } \
- break
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
+ case WireFormatLite::TYPE_##UPPERCASE: \
+ for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
+ result += WireFormatLite::CAMELCASE##Size( \
+ repeated_##LOWERCASE##_value->Get(i)); \
+ } \
+ break
- HANDLE_TYPE( INT32, Int32, int32);
- HANDLE_TYPE( INT64, Int64, int64);
- HANDLE_TYPE( UINT32, UInt32, uint32);
- HANDLE_TYPE( UINT64, UInt64, uint64);
- HANDLE_TYPE( SINT32, SInt32, int32);
- HANDLE_TYPE( SINT64, SInt64, int64);
- HANDLE_TYPE( ENUM, Enum, enum);
+ HANDLE_TYPE(INT32, Int32, int32);
+ HANDLE_TYPE(INT64, Int64, int64);
+ HANDLE_TYPE(UINT32, UInt32, uint32);
+ HANDLE_TYPE(UINT64, UInt64, uint64);
+ HANDLE_TYPE(SINT32, SInt32, int32);
+ HANDLE_TYPE(SINT64, SInt64, int64);
+ HANDLE_TYPE(ENUM, Enum, enum);
#undef HANDLE_TYPE
// Stuff with fixed size.
-#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
- case WireFormatLite::TYPE_##UPPERCASE: \
- result += WireFormatLite::k##CAMELCASE##Size * \
- FromIntSize(repeated_##LOWERCASE##_value->size()); \
- break
- HANDLE_TYPE( FIXED32, Fixed32, uint32);
- HANDLE_TYPE( FIXED64, Fixed64, uint64);
- HANDLE_TYPE(SFIXED32, SFixed32, int32);
- HANDLE_TYPE(SFIXED64, SFixed64, int64);
- HANDLE_TYPE( FLOAT, Float, float);
- HANDLE_TYPE( DOUBLE, Double, double);
- HANDLE_TYPE( BOOL, Bool, bool);
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
+ case WireFormatLite::TYPE_##UPPERCASE: \
+ result += WireFormatLite::k##CAMELCASE##Size * \
+ FromIntSize(repeated_##LOWERCASE##_value->size()); \
+ break
+ HANDLE_TYPE(FIXED32, Fixed32, uint32);
+ HANDLE_TYPE(FIXED64, Fixed64, uint64);
+ HANDLE_TYPE(SFIXED32, SFixed32, int32);
+ HANDLE_TYPE(SFIXED64, SFixed64, int64);
+ HANDLE_TYPE(FLOAT, Float, float);
+ HANDLE_TYPE(DOUBLE, Double, double);
+ HANDLE_TYPE(BOOL, Bool, bool);
#undef HANDLE_TYPE
case WireFormatLite::TYPE_STRING:
@@ -1711,71 +1710,69 @@
cached_size = ToCachedSize(result);
if (result > 0) {
result += io::CodedOutputStream::VarintSize32(result);
- result += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(number,
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
+ result += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ number, WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
}
} else {
size_t tag_size = WireFormatLite::TagSize(number, real_type(type));
switch (real_type(type)) {
#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
- case WireFormatLite::TYPE_##UPPERCASE: \
- result += tag_size * \
- FromIntSize(repeated_##LOWERCASE##_value->size()); \
- for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
- result += WireFormatLite::CAMELCASE##Size( \
- repeated_##LOWERCASE##_value->Get(i)); \
- } \
- break
+ case WireFormatLite::TYPE_##UPPERCASE: \
+ result += tag_size * FromIntSize(repeated_##LOWERCASE##_value->size()); \
+ for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
+ result += WireFormatLite::CAMELCASE##Size( \
+ repeated_##LOWERCASE##_value->Get(i)); \
+ } \
+ break
- HANDLE_TYPE( INT32, Int32, int32);
- HANDLE_TYPE( INT64, Int64, int64);
- HANDLE_TYPE( UINT32, UInt32, uint32);
- HANDLE_TYPE( UINT64, UInt64, uint64);
- HANDLE_TYPE( SINT32, SInt32, int32);
- HANDLE_TYPE( SINT64, SInt64, int64);
- HANDLE_TYPE( STRING, String, string);
- HANDLE_TYPE( BYTES, Bytes, string);
- HANDLE_TYPE( ENUM, Enum, enum);
- HANDLE_TYPE( GROUP, Group, message);
- HANDLE_TYPE( MESSAGE, Message, message);
+ HANDLE_TYPE(INT32, Int32, int32);
+ HANDLE_TYPE(INT64, Int64, int64);
+ HANDLE_TYPE(UINT32, UInt32, uint32);
+ HANDLE_TYPE(UINT64, UInt64, uint64);
+ HANDLE_TYPE(SINT32, SInt32, int32);
+ HANDLE_TYPE(SINT64, SInt64, int64);
+ HANDLE_TYPE(STRING, String, string);
+ HANDLE_TYPE(BYTES, Bytes, string);
+ HANDLE_TYPE(ENUM, Enum, enum);
+ HANDLE_TYPE(GROUP, Group, message);
+ HANDLE_TYPE(MESSAGE, Message, message);
#undef HANDLE_TYPE
// Stuff with fixed size.
-#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
- case WireFormatLite::TYPE_##UPPERCASE: \
- result += (tag_size + WireFormatLite::k##CAMELCASE##Size) * \
- FromIntSize(repeated_##LOWERCASE##_value->size()); \
- break
- HANDLE_TYPE( FIXED32, Fixed32, uint32);
- HANDLE_TYPE( FIXED64, Fixed64, uint64);
- HANDLE_TYPE(SFIXED32, SFixed32, int32);
- HANDLE_TYPE(SFIXED64, SFixed64, int64);
- HANDLE_TYPE( FLOAT, Float, float);
- HANDLE_TYPE( DOUBLE, Double, double);
- HANDLE_TYPE( BOOL, Bool, bool);
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
+ case WireFormatLite::TYPE_##UPPERCASE: \
+ result += (tag_size + WireFormatLite::k##CAMELCASE##Size) * \
+ FromIntSize(repeated_##LOWERCASE##_value->size()); \
+ break
+ HANDLE_TYPE(FIXED32, Fixed32, uint32);
+ HANDLE_TYPE(FIXED64, Fixed64, uint64);
+ HANDLE_TYPE(SFIXED32, SFixed32, int32);
+ HANDLE_TYPE(SFIXED64, SFixed64, int64);
+ HANDLE_TYPE(FLOAT, Float, float);
+ HANDLE_TYPE(DOUBLE, Double, double);
+ HANDLE_TYPE(BOOL, Bool, bool);
#undef HANDLE_TYPE
}
}
} else if (!is_cleared) {
result += WireFormatLite::TagSize(number, real_type(type));
switch (real_type(type)) {
-#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
- case WireFormatLite::TYPE_##UPPERCASE: \
- result += WireFormatLite::CAMELCASE##Size(LOWERCASE); \
- break
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
+ case WireFormatLite::TYPE_##UPPERCASE: \
+ result += WireFormatLite::CAMELCASE##Size(LOWERCASE); \
+ break
- HANDLE_TYPE( INT32, Int32, int32_value);
- HANDLE_TYPE( INT64, Int64, int64_value);
- HANDLE_TYPE( UINT32, UInt32, uint32_value);
- HANDLE_TYPE( UINT64, UInt64, uint64_value);
- HANDLE_TYPE( SINT32, SInt32, int32_value);
- HANDLE_TYPE( SINT64, SInt64, int64_value);
- HANDLE_TYPE( STRING, String, *string_value);
- HANDLE_TYPE( BYTES, Bytes, *string_value);
- HANDLE_TYPE( ENUM, Enum, enum_value);
- HANDLE_TYPE( GROUP, Group, *message_value);
+ HANDLE_TYPE(INT32, Int32, int32_value);
+ HANDLE_TYPE(INT64, Int64, int64_value);
+ HANDLE_TYPE(UINT32, UInt32, uint32_value);
+ HANDLE_TYPE(UINT64, UInt64, uint64_value);
+ HANDLE_TYPE(SINT32, SInt32, int32_value);
+ HANDLE_TYPE(SINT64, SInt64, int64_value);
+ HANDLE_TYPE(STRING, String, *string_value);
+ HANDLE_TYPE(BYTES, Bytes, *string_value);
+ HANDLE_TYPE(ENUM, Enum, enum_value);
+ HANDLE_TYPE(GROUP, Group, *message_value);
#undef HANDLE_TYPE
case WireFormatLite::TYPE_MESSAGE: {
if (is_lazy) {
@@ -1788,17 +1785,17 @@
}
// Stuff with fixed size.
-#define HANDLE_TYPE(UPPERCASE, CAMELCASE) \
- case WireFormatLite::TYPE_##UPPERCASE: \
- result += WireFormatLite::k##CAMELCASE##Size; \
- break
- HANDLE_TYPE( FIXED32, Fixed32);
- HANDLE_TYPE( FIXED64, Fixed64);
- HANDLE_TYPE(SFIXED32, SFixed32);
- HANDLE_TYPE(SFIXED64, SFixed64);
- HANDLE_TYPE( FLOAT, Float);
- HANDLE_TYPE( DOUBLE, Double);
- HANDLE_TYPE( BOOL, Bool);
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE) \
+ case WireFormatLite::TYPE_##UPPERCASE: \
+ result += WireFormatLite::k##CAMELCASE##Size; \
+ break
+ HANDLE_TYPE(FIXED32, Fixed32);
+ HANDLE_TYPE(FIXED64, Fixed64);
+ HANDLE_TYPE(SFIXED32, SFixed32);
+ HANDLE_TYPE(SFIXED64, SFixed64);
+ HANDLE_TYPE(FLOAT, Float);
+ HANDLE_TYPE(DOUBLE, Double);
+ HANDLE_TYPE(BOOL, Bool);
#undef HANDLE_TYPE
}
}
@@ -1809,19 +1806,19 @@
int ExtensionSet::Extension::GetSize() const {
GOOGLE_DCHECK(is_repeated);
switch (cpp_type(type)) {
-#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
- case WireFormatLite::CPPTYPE_##UPPERCASE: \
- return repeated_##LOWERCASE##_value->size()
+#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
+ case WireFormatLite::CPPTYPE_##UPPERCASE: \
+ return repeated_##LOWERCASE##_value->size()
- HANDLE_TYPE( INT32, int32);
- HANDLE_TYPE( INT64, int64);
- HANDLE_TYPE( UINT32, uint32);
- HANDLE_TYPE( UINT64, uint64);
- HANDLE_TYPE( FLOAT, float);
- HANDLE_TYPE( DOUBLE, double);
- HANDLE_TYPE( BOOL, bool);
- HANDLE_TYPE( ENUM, enum);
- HANDLE_TYPE( STRING, string);
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
+ HANDLE_TYPE(UINT32, uint32);
+ HANDLE_TYPE(UINT64, uint64);
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(DOUBLE, double);
+ HANDLE_TYPE(BOOL, bool);
+ HANDLE_TYPE(ENUM, enum);
+ HANDLE_TYPE(STRING, string);
HANDLE_TYPE(MESSAGE, message);
#undef HANDLE_TYPE
}
@@ -1835,20 +1832,20 @@
void ExtensionSet::Extension::Free() {
if (is_repeated) {
switch (cpp_type(type)) {
-#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
- case WireFormatLite::CPPTYPE_##UPPERCASE: \
- delete repeated_##LOWERCASE##_value; \
- break
+#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
+ case WireFormatLite::CPPTYPE_##UPPERCASE: \
+ delete repeated_##LOWERCASE##_value; \
+ break
- HANDLE_TYPE( INT32, int32);
- HANDLE_TYPE( INT64, int64);
- HANDLE_TYPE( UINT32, uint32);
- HANDLE_TYPE( UINT64, uint64);
- HANDLE_TYPE( FLOAT, float);
- HANDLE_TYPE( DOUBLE, double);
- HANDLE_TYPE( BOOL, bool);
- HANDLE_TYPE( ENUM, enum);
- HANDLE_TYPE( STRING, string);
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
+ HANDLE_TYPE(UINT32, uint32);
+ HANDLE_TYPE(UINT64, uint64);
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(DOUBLE, double);
+ HANDLE_TYPE(BOOL, bool);
+ HANDLE_TYPE(ENUM, enum);
+ HANDLE_TYPE(STRING, string);
HANDLE_TYPE(MESSAGE, message);
#undef HANDLE_TYPE
}
@@ -2029,8 +2026,7 @@
}
void ExtensionSet::Extension::SerializeMessageSetItemWithCachedSizes(
- int number,
- io::CodedOutputStream* output) const {
+ int number, io::CodedOutputStream* output) const {
if (type != WireFormatLite::TYPE_MESSAGE || is_repeated) {
// Not a valid MessageSet extension, but serialize it the normal way.
SerializeFieldWithCachedSizes(number, output);
@@ -2043,18 +2039,15 @@
output->WriteTag(WireFormatLite::kMessageSetItemStartTag);
// Write type ID.
- WireFormatLite::WriteUInt32(WireFormatLite::kMessageSetTypeIdNumber,
- number,
+ WireFormatLite::WriteUInt32(WireFormatLite::kMessageSetTypeIdNumber, number,
output);
// Write message.
if (is_lazy) {
- lazymessage_value->WriteMessage(
- WireFormatLite::kMessageSetMessageNumber, output);
+ lazymessage_value->WriteMessage(WireFormatLite::kMessageSetMessageNumber,
+ output);
} else {
WireFormatLite::WriteMessageMaybeToArray(
- WireFormatLite::kMessageSetMessageNumber,
- *message_value,
- output);
+ WireFormatLite::kMessageSetMessageNumber, *message_value, output);
}
// End group.
diff --git a/src/google/protobuf/extension_set_heavy.cc b/src/google/protobuf/extension_set_heavy.cc
index f48207b..32ca435 100644
--- a/src/google/protobuf/extension_set_heavy.cc
+++ b/src/google/protobuf/extension_set_heavy.cc
@@ -58,8 +58,7 @@
namespace internal {
// A FieldSkipper used to store unknown MessageSet fields into UnknownFieldSet.
-class MessageSetFieldSkipper
- : public UnknownFieldSetFieldSkipper {
+class MessageSetFieldSkipper : public UnknownFieldSetFieldSkipper {
public:
explicit MessageSetFieldSkipper(UnknownFieldSet* unknown_fields)
: UnknownFieldSetFieldSkipper(unknown_fields) {}
@@ -68,15 +67,15 @@
virtual bool SkipMessageSetField(io::CodedInputStream* input,
int field_number);
};
-bool MessageSetFieldSkipper::SkipMessageSetField(
- io::CodedInputStream* input, int field_number) {
+bool MessageSetFieldSkipper::SkipMessageSetField(io::CodedInputStream* input,
+ int field_number) {
uint32 length;
if (!input->ReadVarint32(&length)) return false;
if (unknown_fields_ == NULL) {
return input->Skip(length);
} else {
- return input->ReadString(
- unknown_fields_->AddLengthDelimited(field_number), length);
+ return input->ReadString(unknown_fields_->AddLengthDelimited(field_number),
+ length);
}
}
@@ -141,10 +140,10 @@
return static_cast<WireFormatLite::FieldType>(type);
}
-#define GOOGLE_DCHECK_TYPE(EXTENSION, LABEL, CPPTYPE) \
- GOOGLE_DCHECK_EQ((EXTENSION).is_repeated ? FieldDescriptor::LABEL_REPEATED \
- : FieldDescriptor::LABEL_OPTIONAL, \
- FieldDescriptor::LABEL_##LABEL); \
+#define GOOGLE_DCHECK_TYPE(EXTENSION, LABEL, CPPTYPE) \
+ GOOGLE_DCHECK_EQ((EXTENSION).is_repeated ? FieldDescriptor::LABEL_REPEATED \
+ : FieldDescriptor::LABEL_OPTIONAL, \
+ FieldDescriptor::LABEL_##LABEL); \
GOOGLE_DCHECK_EQ(cpp_type((EXTENSION).type), FieldDescriptor::CPPTYPE_##CPPTYPE)
const MessageLite& ExtensionSet::GetMessage(int number,
@@ -242,7 +241,8 @@
}
}
-ExtensionSet::Extension* ExtensionSet::MaybeNewRepeatedExtension(const FieldDescriptor* descriptor) {
+ExtensionSet::Extension* ExtensionSet::MaybeNewRepeatedExtension(
+ const FieldDescriptor* descriptor) {
Extension* extension;
if (MaybeNewExtension(descriptor->number(), descriptor, &extension)) {
extension->type = descriptor->type();
@@ -288,8 +288,8 @@
}
static bool ValidateEnumUsingDescriptor(const void* arg, int number) {
- return reinterpret_cast<const EnumDescriptor*>(arg)
- ->FindValueByNumber(number) != NULL;
+ return reinterpret_cast<const EnumDescriptor*>(arg)->FindValueByNumber(
+ number) != NULL;
}
bool DescriptorPoolExtensionFinder::Find(int number, ExtensionInfo* output) {
@@ -429,15 +429,15 @@
repeated_##LOWERCASE##_value->SpaceUsedExcludingSelfLong(); \
break
- HANDLE_TYPE( INT32, int32);
- HANDLE_TYPE( INT64, int64);
- HANDLE_TYPE( UINT32, uint32);
- HANDLE_TYPE( UINT64, uint64);
- HANDLE_TYPE( FLOAT, float);
- HANDLE_TYPE( DOUBLE, double);
- HANDLE_TYPE( BOOL, bool);
- HANDLE_TYPE( ENUM, enum);
- HANDLE_TYPE( STRING, string);
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
+ HANDLE_TYPE(UINT32, uint32);
+ HANDLE_TYPE(UINT64, uint64);
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(DOUBLE, double);
+ HANDLE_TYPE(BOOL, bool);
+ HANDLE_TYPE(ENUM, enum);
+ HANDLE_TYPE(STRING, string);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_MESSAGE:
@@ -522,33 +522,33 @@
if (is_packed) {
if (cached_size == 0) return target;
- target = WireFormatLite::WriteTagToArray(number,
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED, target);
+ target = WireFormatLite::WriteTagToArray(
+ number, WireFormatLite::WIRETYPE_LENGTH_DELIMITED, target);
target = WireFormatLite::WriteInt32NoTagToArray(cached_size, target);
switch (real_type(type)) {
-#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
- case FieldDescriptor::TYPE_##UPPERCASE: \
- for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
- target = WireFormatLite::Write##CAMELCASE##NoTagToArray( \
- repeated_##LOWERCASE##_value->Get(i), target); \
- } \
- break
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
+ case FieldDescriptor::TYPE_##UPPERCASE: \
+ for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
+ target = WireFormatLite::Write##CAMELCASE##NoTagToArray( \
+ repeated_##LOWERCASE##_value->Get(i), target); \
+ } \
+ break
- HANDLE_TYPE( INT32, Int32, int32);
- HANDLE_TYPE( INT64, Int64, int64);
- HANDLE_TYPE( UINT32, UInt32, uint32);
- HANDLE_TYPE( UINT64, UInt64, uint64);
- HANDLE_TYPE( SINT32, SInt32, int32);
- HANDLE_TYPE( SINT64, SInt64, int64);
- HANDLE_TYPE( FIXED32, Fixed32, uint32);
- HANDLE_TYPE( FIXED64, Fixed64, uint64);
- HANDLE_TYPE(SFIXED32, SFixed32, int32);
- HANDLE_TYPE(SFIXED64, SFixed64, int64);
- HANDLE_TYPE( FLOAT, Float, float);
- HANDLE_TYPE( DOUBLE, Double, double);
- HANDLE_TYPE( BOOL, Bool, bool);
- HANDLE_TYPE( ENUM, Enum, enum);
+ HANDLE_TYPE(INT32, Int32, int32);
+ HANDLE_TYPE(INT64, Int64, int64);
+ HANDLE_TYPE(UINT32, UInt32, uint32);
+ HANDLE_TYPE(UINT64, UInt64, uint64);
+ HANDLE_TYPE(SINT32, SInt32, int32);
+ HANDLE_TYPE(SINT64, SInt64, int64);
+ HANDLE_TYPE(FIXED32, Fixed32, uint32);
+ HANDLE_TYPE(FIXED64, Fixed64, uint64);
+ HANDLE_TYPE(SFIXED32, SFixed32, int32);
+ HANDLE_TYPE(SFIXED64, SFixed64, int64);
+ HANDLE_TYPE(FLOAT, Float, float);
+ HANDLE_TYPE(DOUBLE, Double, double);
+ HANDLE_TYPE(BOOL, Bool, bool);
+ HANDLE_TYPE(ENUM, Enum, enum);
#undef HANDLE_TYPE
case FieldDescriptor::TYPE_STRING:
@@ -560,30 +560,30 @@
}
} else {
switch (real_type(type)) {
-#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
- case FieldDescriptor::TYPE_##UPPERCASE: \
- for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
- target = WireFormatLite::Write##CAMELCASE##ToArray(number, \
- repeated_##LOWERCASE##_value->Get(i), target); \
- } \
- break
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
+ case FieldDescriptor::TYPE_##UPPERCASE: \
+ for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
+ target = WireFormatLite::Write##CAMELCASE##ToArray( \
+ number, repeated_##LOWERCASE##_value->Get(i), target); \
+ } \
+ break
- HANDLE_TYPE( INT32, Int32, int32);
- HANDLE_TYPE( INT64, Int64, int64);
- HANDLE_TYPE( UINT32, UInt32, uint32);
- HANDLE_TYPE( UINT64, UInt64, uint64);
- HANDLE_TYPE( SINT32, SInt32, int32);
- HANDLE_TYPE( SINT64, SInt64, int64);
- HANDLE_TYPE( FIXED32, Fixed32, uint32);
- HANDLE_TYPE( FIXED64, Fixed64, uint64);
- HANDLE_TYPE(SFIXED32, SFixed32, int32);
- HANDLE_TYPE(SFIXED64, SFixed64, int64);
- HANDLE_TYPE( FLOAT, Float, float);
- HANDLE_TYPE( DOUBLE, Double, double);
- HANDLE_TYPE( BOOL, Bool, bool);
- HANDLE_TYPE( STRING, String, string);
- HANDLE_TYPE( BYTES, Bytes, string);
- HANDLE_TYPE( ENUM, Enum, enum);
+ HANDLE_TYPE(INT32, Int32, int32);
+ HANDLE_TYPE(INT64, Int64, int64);
+ HANDLE_TYPE(UINT32, UInt32, uint32);
+ HANDLE_TYPE(UINT64, UInt64, uint64);
+ HANDLE_TYPE(SINT32, SInt32, int32);
+ HANDLE_TYPE(SINT64, SInt64, int64);
+ HANDLE_TYPE(FIXED32, Fixed32, uint32);
+ HANDLE_TYPE(FIXED64, Fixed64, uint64);
+ HANDLE_TYPE(SFIXED32, SFixed32, int32);
+ HANDLE_TYPE(SFIXED64, SFixed64, int64);
+ HANDLE_TYPE(FLOAT, Float, float);
+ HANDLE_TYPE(DOUBLE, Double, double);
+ HANDLE_TYPE(BOOL, Bool, bool);
+ HANDLE_TYPE(STRING, String, string);
+ HANDLE_TYPE(BYTES, Bytes, string);
+ HANDLE_TYPE(ENUM, Enum, enum);
#undef HANDLE_TYPE
#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
case FieldDescriptor::TYPE_##UPPERCASE: \
@@ -593,36 +593,35 @@
} \
break
- HANDLE_TYPE( GROUP, Group, message);
- HANDLE_TYPE( MESSAGE, Message, message);
+ HANDLE_TYPE(GROUP, Group, message);
+ HANDLE_TYPE(MESSAGE, Message, message);
#undef HANDLE_TYPE
}
}
} else if (!is_cleared) {
switch (real_type(type)) {
-#define HANDLE_TYPE(UPPERCASE, CAMELCASE, VALUE) \
- case FieldDescriptor::TYPE_##UPPERCASE: \
- target = WireFormatLite::Write##CAMELCASE##ToArray( \
- number, VALUE, target); \
- break
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE, VALUE) \
+ case FieldDescriptor::TYPE_##UPPERCASE: \
+ target = WireFormatLite::Write##CAMELCASE##ToArray(number, VALUE, target); \
+ break
- HANDLE_TYPE( INT32, Int32, int32_value);
- HANDLE_TYPE( INT64, Int64, int64_value);
- HANDLE_TYPE( UINT32, UInt32, uint32_value);
- HANDLE_TYPE( UINT64, UInt64, uint64_value);
- HANDLE_TYPE( SINT32, SInt32, int32_value);
- HANDLE_TYPE( SINT64, SInt64, int64_value);
- HANDLE_TYPE( FIXED32, Fixed32, uint32_value);
- HANDLE_TYPE( FIXED64, Fixed64, uint64_value);
- HANDLE_TYPE(SFIXED32, SFixed32, int32_value);
- HANDLE_TYPE(SFIXED64, SFixed64, int64_value);
- HANDLE_TYPE( FLOAT, Float, float_value);
- HANDLE_TYPE( DOUBLE, Double, double_value);
- HANDLE_TYPE( BOOL, Bool, bool_value);
- HANDLE_TYPE( STRING, String, *string_value);
- HANDLE_TYPE( BYTES, Bytes, *string_value);
- HANDLE_TYPE( ENUM, Enum, enum_value);
- HANDLE_TYPE( GROUP, Group, *message_value);
+ HANDLE_TYPE(INT32, Int32, int32_value);
+ HANDLE_TYPE(INT64, Int64, int64_value);
+ HANDLE_TYPE(UINT32, UInt32, uint32_value);
+ HANDLE_TYPE(UINT64, UInt64, uint64_value);
+ HANDLE_TYPE(SINT32, SInt32, int32_value);
+ HANDLE_TYPE(SINT64, SInt64, int64_value);
+ HANDLE_TYPE(FIXED32, Fixed32, uint32_value);
+ HANDLE_TYPE(FIXED64, Fixed64, uint64_value);
+ HANDLE_TYPE(SFIXED32, SFixed32, int32_value);
+ HANDLE_TYPE(SFIXED64, SFixed64, int64_value);
+ HANDLE_TYPE(FLOAT, Float, float_value);
+ HANDLE_TYPE(DOUBLE, Double, double_value);
+ HANDLE_TYPE(BOOL, Bool, bool_value);
+ HANDLE_TYPE(STRING, String, *string_value);
+ HANDLE_TYPE(BYTES, Bytes, *string_value);
+ HANDLE_TYPE(ENUM, Enum, enum_value);
+ HANDLE_TYPE(GROUP, Group, *message_value);
#undef HANDLE_TYPE
case FieldDescriptor::TYPE_MESSAGE:
if (is_lazy) {
@@ -670,11 +669,11 @@
bool ExtensionSet::ParseFieldMaybeLazily(
int wire_type, int field_number, io::CodedInputStream* input,
- ExtensionFinder* extension_finder,
- MessageSetFieldSkipper* field_skipper) {
- return ParseField(WireFormatLite::MakeTag(
- field_number, static_cast<WireFormatLite::WireType>(wire_type)),
- input, extension_finder, field_skipper);
+ ExtensionFinder* extension_finder, MessageSetFieldSkipper* field_skipper) {
+ return ParseField(
+ WireFormatLite::MakeTag(field_number,
+ static_cast<WireFormatLite::WireType>(wire_type)),
+ input, extension_finder, field_skipper);
}
bool ExtensionSet::ParseMessageSet(io::CodedInputStream* input,
diff --git a/src/google/protobuf/extension_set_unittest.cc b/src/google/protobuf/extension_set_unittest.cc
index e33d14d..6dd6f7d 100644
--- a/src/google/protobuf/extension_set_unittest.cc
+++ b/src/google/protobuf/extension_set_unittest.cc
@@ -78,9 +78,9 @@
&message.GetExtension(unittest::optionalgroup_extension));
EXPECT_EQ(&unittest::TestAllTypes::NestedMessage::default_instance(),
&message.GetExtension(unittest::optional_nested_message_extension));
- EXPECT_EQ(&unittest::ForeignMessage::default_instance(),
- &message.GetExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_EQ(
+ &unittest::ForeignMessage::default_instance(),
+ &message.GetExtension(unittest::optional_foreign_message_extension));
EXPECT_EQ(&unittest_import::ImportMessage::default_instance(),
&message.GetExtension(unittest::optional_import_message_extension));
}
@@ -114,9 +114,9 @@
&message.GetExtension(unittest::optionalgroup_extension));
EXPECT_NE(&unittest::TestAllTypes::NestedMessage::default_instance(),
&message.GetExtension(unittest::optional_nested_message_extension));
- EXPECT_NE(&unittest::ForeignMessage::default_instance(),
- &message.GetExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_NE(
+ &unittest::ForeignMessage::default_instance(),
+ &message.GetExtension(unittest::optional_foreign_message_extension));
EXPECT_NE(&unittest_import::ImportMessage::default_instance(),
&message.GetExtension(unittest::optional_import_message_extension));
@@ -133,7 +133,7 @@
TestUtil::SetAllExtensions(&message);
int64 original_value =
- message.GetExtension(unittest::optional_int64_extension);
+ message.GetExtension(unittest::optional_int64_extension);
// Clear the field and make sure it shows up as cleared.
message.ClearExtension(unittest::optional_int64_extension);
@@ -151,20 +151,18 @@
TEST(ExtensionSetTest, SetAllocatedExtension) {
unittest::TestAllExtensions message;
- EXPECT_FALSE(message.HasExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_foreign_message_extension));
// Add a extension using SetAllocatedExtension
unittest::ForeignMessage* foreign_message = new unittest::ForeignMessage();
message.SetAllocatedExtension(unittest::optional_foreign_message_extension,
foreign_message);
- EXPECT_TRUE(message.HasExtension(
- unittest::optional_foreign_message_extension));
- EXPECT_EQ(foreign_message,
- message.MutableExtension(
- unittest::optional_foreign_message_extension));
- EXPECT_EQ(foreign_message,
- &message.GetExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_TRUE(
+ message.HasExtension(unittest::optional_foreign_message_extension));
+ EXPECT_EQ(foreign_message, message.MutableExtension(
+ unittest::optional_foreign_message_extension));
+ EXPECT_EQ(foreign_message, &message.GetExtension(
+ unittest::optional_foreign_message_extension));
// SetAllocatedExtension should delete the previously existing extension.
// (We reply on unittest to check memory leaks for this case)
@@ -174,8 +172,8 @@
// SetAllocatedExtension with a NULL parameter is equivalent to ClearExtenion.
message.SetAllocatedExtension(unittest::optional_foreign_message_extension,
NULL);
- EXPECT_FALSE(message.HasExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_foreign_message_extension));
}
TEST(ExtensionSetTest, ReleaseExtension) {
@@ -186,8 +184,7 @@
unittest::TestMessageSetExtension1* extension =
new unittest::TestMessageSetExtension1();
message.SetAllocatedExtension(
- unittest::TestMessageSetExtension1::message_set_extension,
- extension);
+ unittest::TestMessageSetExtension1::message_set_extension, extension);
EXPECT_TRUE(message.HasExtension(
unittest::TestMessageSetExtension1::message_set_extension));
// Release the extension using ReleaseExtension
@@ -200,8 +197,7 @@
// ReleaseExtension will return the underlying object even after
// ClearExtension is called.
message.SetAllocatedExtension(
- unittest::TestMessageSetExtension1::message_set_extension,
- extension);
+ unittest::TestMessageSetExtension1::message_set_extension, extension);
message.ClearExtension(
unittest::TestMessageSetExtension1::message_set_extension);
released_extension = message.ReleaseExtension(
@@ -216,8 +212,7 @@
Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
unittest::ForeignMessage extension;
message->UnsafeArenaSetAllocatedExtension(
- unittest::optional_foreign_message_extension,
- &extension);
+ unittest::optional_foreign_message_extension, &extension);
// No copy when set.
unittest::ForeignMessage* mutable_extension =
message->MutableExtension(unittest::optional_foreign_message_extension);
@@ -227,21 +222,19 @@
message->UnsafeArenaReleaseExtension(
unittest::optional_foreign_message_extension);
EXPECT_EQ(&extension, released_extension);
- EXPECT_FALSE(message->HasExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_FALSE(
+ message->HasExtension(unittest::optional_foreign_message_extension));
// Set the ownership back and let the destructors run. It should not take
// ownership, so this should not crash.
message->UnsafeArenaSetAllocatedExtension(
- unittest::optional_foreign_message_extension,
- &extension);
+ unittest::optional_foreign_message_extension, &extension);
}
TEST(ExtensionSetTest, UnsafeArenaSetAllocatedAndRelease) {
unittest::TestAllExtensions message;
unittest::ForeignMessage* extension = new unittest::ForeignMessage();
message.UnsafeArenaSetAllocatedExtension(
- unittest::optional_foreign_message_extension,
- extension);
+ unittest::optional_foreign_message_extension, extension);
// No copy when set.
unittest::ForeignMessage* mutable_extension =
message.MutableExtension(unittest::optional_foreign_message_extension);
@@ -251,13 +244,12 @@
message.UnsafeArenaReleaseExtension(
unittest::optional_foreign_message_extension);
EXPECT_EQ(extension, released_extension);
- EXPECT_FALSE(message.HasExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_foreign_message_extension));
// Set the ownership back and let the destructors run. It should take
// ownership, so this should not leak.
message.UnsafeArenaSetAllocatedExtension(
- unittest::optional_foreign_message_extension,
- extension);
+ unittest::optional_foreign_message_extension, extension);
}
TEST(ExtensionSetTest, ArenaUnsafeArenaReleaseOfHeapAlloc) {
@@ -265,17 +257,16 @@
unittest::TestAllExtensions* message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
unittest::ForeignMessage* extension = new unittest::ForeignMessage;
- message->SetAllocatedExtension(
- unittest::optional_foreign_message_extension,
- extension);
+ message->SetAllocatedExtension(unittest::optional_foreign_message_extension,
+ extension);
// The arena should maintain ownership of the heap allocated proto because we
// used UnsafeArenaReleaseExtension. The leak checker will ensure this.
unittest::ForeignMessage* released_extension =
message->UnsafeArenaReleaseExtension(
unittest::optional_foreign_message_extension);
EXPECT_EQ(extension, released_extension);
- EXPECT_FALSE(message->HasExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_FALSE(
+ message->HasExtension(unittest::optional_foreign_message_extension));
}
@@ -345,10 +336,8 @@
TestUtil::ExpectExtensionsClear(message2);
// Swap two extensions.
- fields.push_back(
- reflection->FindKnownExtensionByNumber(12));
- fields.push_back(
- reflection->FindKnownExtensionByNumber(25));
+ fields.push_back(reflection->FindKnownExtensionByNumber(12));
+ fields.push_back(reflection->FindKnownExtensionByNumber(25));
reflection->SwapFields(&message1, &message2, fields);
EXPECT_TRUE(message1.HasExtension(unittest::optional_int32_extension));
@@ -427,23 +416,22 @@
Arena arena;
unittest::TestAllExtensions* message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
- EXPECT_FALSE(message->HasExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_FALSE(
+ message->HasExtension(unittest::optional_foreign_message_extension));
// Add a extension using SetAllocatedExtension
unittest::ForeignMessage* foreign_message = new unittest::ForeignMessage();
message->SetAllocatedExtension(unittest::optional_foreign_message_extension,
foreign_message);
// foreign_message is now owned by the arena.
- EXPECT_EQ(foreign_message,
- message->MutableExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_EQ(foreign_message, message->MutableExtension(
+ unittest::optional_foreign_message_extension));
// Underlying message is copied, and returned.
- unittest::ForeignMessage* released_message = message->ReleaseExtension(
- unittest::optional_foreign_message_extension);
+ unittest::ForeignMessage* released_message =
+ message->ReleaseExtension(unittest::optional_foreign_message_extension);
delete released_message;
- EXPECT_FALSE(message->HasExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_FALSE(
+ message->HasExtension(unittest::optional_foreign_message_extension));
}
TEST(ExtensionSetTest, SwapExtensionBothFullWithArena) {
@@ -615,14 +603,20 @@
source.set_optional_foreign_enum(unittest::FOREIGN_BAZ);
source.SerializeToString(&data);
EXPECT_TRUE(destination.ParseFromString(data));
- EXPECT_TRUE(destination.GetExtension(
- unittest::TestNestedExtension::optionalgroup_extension).has_a());
- EXPECT_EQ(117, destination.GetExtension(
- unittest::TestNestedExtension::optionalgroup_extension).a());
+ EXPECT_TRUE(
+ destination
+ .GetExtension(unittest::TestNestedExtension::optionalgroup_extension)
+ .has_a());
+ EXPECT_EQ(117, destination
+ .GetExtension(
+ unittest::TestNestedExtension::optionalgroup_extension)
+ .a());
EXPECT_TRUE(destination.HasExtension(
unittest::TestNestedExtension::optional_foreign_enum_extension));
- EXPECT_EQ(unittest::FOREIGN_BAZ, destination.GetExtension(
- unittest::TestNestedExtension::optional_foreign_enum_extension));
+ EXPECT_EQ(
+ unittest::FOREIGN_BAZ,
+ destination.GetExtension(
+ unittest::TestNestedExtension::optional_foreign_enum_extension));
}
TEST(ExtensionSetTest, Parsing) {
@@ -743,36 +737,38 @@
TEST(ExtensionSetTest, SpaceUsedExcludingSelf) {
// Scalar primitive extensions should increase the extension set size by a
// minimum of the size of the primitive type.
-#define TEST_SCALAR_EXTENSIONS_SPACE_USED(type, value) \
- do { \
- unittest::TestAllExtensions message; \
- const int base_size = message.SpaceUsed(); \
- message.SetExtension(unittest::optional_##type##_extension, value); \
- int min_expected_size = base_size + \
- sizeof(message.GetExtension(unittest::optional_##type##_extension)); \
- EXPECT_LE(min_expected_size, message.SpaceUsed()); \
+#define TEST_SCALAR_EXTENSIONS_SPACE_USED(type, value) \
+ do { \
+ unittest::TestAllExtensions message; \
+ const int base_size = message.SpaceUsed(); \
+ message.SetExtension(unittest::optional_##type##_extension, value); \
+ int min_expected_size = \
+ base_size + \
+ sizeof(message.GetExtension(unittest::optional_##type##_extension)); \
+ EXPECT_LE(min_expected_size, message.SpaceUsed()); \
} while (0)
- TEST_SCALAR_EXTENSIONS_SPACE_USED(int32 , 101);
- TEST_SCALAR_EXTENSIONS_SPACE_USED(int64 , 102);
- TEST_SCALAR_EXTENSIONS_SPACE_USED(uint32 , 103);
- TEST_SCALAR_EXTENSIONS_SPACE_USED(uint64 , 104);
- TEST_SCALAR_EXTENSIONS_SPACE_USED(sint32 , 105);
- TEST_SCALAR_EXTENSIONS_SPACE_USED(sint64 , 106);
- TEST_SCALAR_EXTENSIONS_SPACE_USED(fixed32 , 107);
- TEST_SCALAR_EXTENSIONS_SPACE_USED(fixed64 , 108);
+ TEST_SCALAR_EXTENSIONS_SPACE_USED(int32, 101);
+ TEST_SCALAR_EXTENSIONS_SPACE_USED(int64, 102);
+ TEST_SCALAR_EXTENSIONS_SPACE_USED(uint32, 103);
+ TEST_SCALAR_EXTENSIONS_SPACE_USED(uint64, 104);
+ TEST_SCALAR_EXTENSIONS_SPACE_USED(sint32, 105);
+ TEST_SCALAR_EXTENSIONS_SPACE_USED(sint64, 106);
+ TEST_SCALAR_EXTENSIONS_SPACE_USED(fixed32, 107);
+ TEST_SCALAR_EXTENSIONS_SPACE_USED(fixed64, 108);
TEST_SCALAR_EXTENSIONS_SPACE_USED(sfixed32, 109);
TEST_SCALAR_EXTENSIONS_SPACE_USED(sfixed64, 110);
- TEST_SCALAR_EXTENSIONS_SPACE_USED(float , 111);
- TEST_SCALAR_EXTENSIONS_SPACE_USED(double , 112);
- TEST_SCALAR_EXTENSIONS_SPACE_USED(bool , true);
+ TEST_SCALAR_EXTENSIONS_SPACE_USED(float, 111);
+ TEST_SCALAR_EXTENSIONS_SPACE_USED(double, 112);
+ TEST_SCALAR_EXTENSIONS_SPACE_USED(bool, true);
#undef TEST_SCALAR_EXTENSIONS_SPACE_USED
{
unittest::TestAllExtensions message;
const int base_size = message.SpaceUsed();
message.SetExtension(unittest::optional_nested_enum_extension,
unittest::TestAllTypes::FOO);
- int min_expected_size = base_size +
+ int min_expected_size =
+ base_size +
sizeof(message.GetExtension(unittest::optional_nested_enum_extension));
EXPECT_LE(min_expected_size, message.SpaceUsed());
}
@@ -794,8 +790,8 @@
const int base_size = message.SpaceUsed();
unittest::ForeignMessage foreign;
foreign.set_c(42);
- message.MutableExtension(unittest::optional_foreign_message_extension)->
- CopyFrom(foreign);
+ message.MutableExtension(unittest::optional_foreign_message_extension)
+ ->CopyFrom(foreign);
int min_expected_size = base_size + foreign.SpaceUsed();
EXPECT_LE(min_expected_size, message.SpaceUsed());
}
@@ -810,45 +806,49 @@
// SpaceUsed()
// - Adds a large number of values (requiring allocation in the repeated
// field), and ensures that that allocation is included in SpaceUsed()
-#define TEST_REPEATED_EXTENSIONS_SPACE_USED(type, cpptype, value) \
- do { \
- unittest::TestAllExtensions message; \
- const int base_size = message.SpaceUsed(); \
- int min_expected_size = sizeof(RepeatedField<cpptype>) + base_size; \
- message.AddExtension(unittest::repeated_##type##_extension, value); \
- message.ClearExtension(unittest::repeated_##type##_extension); \
- const int empty_repeated_field_size = message.SpaceUsed(); \
- EXPECT_LE(min_expected_size, empty_repeated_field_size) << #type; \
- message.AddExtension(unittest::repeated_##type##_extension, value); \
- message.AddExtension(unittest::repeated_##type##_extension, value); \
- EXPECT_EQ(empty_repeated_field_size, message.SpaceUsed()) << #type; \
- message.ClearExtension(unittest::repeated_##type##_extension); \
- const int old_capacity = \
- message.GetRepeatedExtension(unittest::repeated_##type##_extension) \
- .Capacity(); \
- EXPECT_GE(old_capacity, kMinRepeatedFieldAllocationSize); \
- for (int i = 0; i < 16; ++i) { \
- message.AddExtension(unittest::repeated_##type##_extension, value); \
- } \
- int expected_size = sizeof(cpptype) * \
- (message.GetRepeatedExtension(unittest::repeated_##type##_extension) \
- .Capacity() - old_capacity) + empty_repeated_field_size; \
- EXPECT_LE(expected_size, message.SpaceUsed()) << #type; \
+#define TEST_REPEATED_EXTENSIONS_SPACE_USED(type, cpptype, value) \
+ do { \
+ unittest::TestAllExtensions message; \
+ const int base_size = message.SpaceUsed(); \
+ int min_expected_size = sizeof(RepeatedField<cpptype>) + base_size; \
+ message.AddExtension(unittest::repeated_##type##_extension, value); \
+ message.ClearExtension(unittest::repeated_##type##_extension); \
+ const int empty_repeated_field_size = message.SpaceUsed(); \
+ EXPECT_LE(min_expected_size, empty_repeated_field_size) << #type; \
+ message.AddExtension(unittest::repeated_##type##_extension, value); \
+ message.AddExtension(unittest::repeated_##type##_extension, value); \
+ EXPECT_EQ(empty_repeated_field_size, message.SpaceUsed()) << #type; \
+ message.ClearExtension(unittest::repeated_##type##_extension); \
+ const int old_capacity = \
+ message.GetRepeatedExtension(unittest::repeated_##type##_extension) \
+ .Capacity(); \
+ EXPECT_GE(old_capacity, kMinRepeatedFieldAllocationSize); \
+ for (int i = 0; i < 16; ++i) { \
+ message.AddExtension(unittest::repeated_##type##_extension, value); \
+ } \
+ int expected_size = \
+ sizeof(cpptype) * \
+ (message \
+ .GetRepeatedExtension(unittest::repeated_##type##_extension) \
+ .Capacity() - \
+ old_capacity) + \
+ empty_repeated_field_size; \
+ EXPECT_LE(expected_size, message.SpaceUsed()) << #type; \
} while (0)
- TEST_REPEATED_EXTENSIONS_SPACE_USED(int32 , int32 , 101);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(int64 , int64 , 102);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(uint32 , uint32, 103);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(uint64 , uint64, 104);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(sint32 , int32 , 105);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(sint64 , int64 , 106);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(fixed32 , uint32, 107);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(fixed64 , uint64, 108);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(sfixed32, int32 , 109);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(sfixed64, int64 , 110);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(float , float , 111);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(double , double, 112);
- TEST_REPEATED_EXTENSIONS_SPACE_USED(bool , bool , true);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(int32, int32, 101);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(int64, int64, 102);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(uint32, uint32, 103);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(uint64, uint64, 104);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(sint32, int32, 105);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(sint64, int64, 106);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(fixed32, uint32, 107);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(fixed64, uint64, 108);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(sfixed32, int32, 109);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(sfixed64, int64, 110);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(float, float, 111);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(double, double, 112);
+ TEST_REPEATED_EXTENSIONS_SPACE_USED(bool, bool, true);
TEST_REPEATED_EXTENSIONS_SPACE_USED(nested_enum, int,
unittest::TestAllTypes::FOO);
#undef TEST_REPEATED_EXTENSIONS_SPACE_USED
@@ -864,21 +864,21 @@
for (int i = 0; i < 16; ++i) {
message.AddExtension(unittest::repeated_string_extension, value);
}
- min_expected_size += (sizeof(value) + value.size()) *
- (16 - kMinRepeatedFieldAllocationSize);
+ min_expected_size +=
+ (sizeof(value) + value.size()) * (16 - kMinRepeatedFieldAllocationSize);
EXPECT_LE(min_expected_size, message.SpaceUsed());
}
// Repeated messages
{
unittest::TestAllExtensions message;
const int base_size = message.SpaceUsed();
- int min_expected_size = sizeof(RepeatedPtrField<unittest::ForeignMessage>) +
- base_size;
+ int min_expected_size =
+ sizeof(RepeatedPtrField<unittest::ForeignMessage>) + base_size;
unittest::ForeignMessage prototype;
prototype.set_c(2);
for (int i = 0; i < 16; ++i) {
- message.AddExtension(unittest::repeated_foreign_message_extension)->
- CopyFrom(prototype);
+ message.AddExtension(unittest::repeated_foreign_message_extension)
+ ->CopyFrom(prototype);
}
min_expected_size +=
(16 - kMinRepeatedFieldAllocationSize) * prototype.SpaceUsed();
@@ -887,7 +887,7 @@
}
// N.B.: We do not test range-based for here because we remain C++03 compatible.
-template<typename T, typename M, typename ID>
+template <typename T, typename M, typename ID>
inline T SumAllExtensions(const M& message, ID extension, T zero) {
T sum = zero;
typename RepeatedField<T>::const_iterator iter =
@@ -900,12 +900,11 @@
return sum;
}
-template<typename T, typename M, typename ID>
-inline void IncAllExtensions(M* message, ID extension,
- T val) {
+template <typename T, typename M, typename ID>
+inline void IncAllExtensions(M* message, ID extension, T val) {
typename RepeatedField<T>::iterator iter =
message->MutableRepeatedExtension(extension)->begin();
- typename RepeatedField<T>::iterator end =
+ typename RepeatedField<T>::iterator end =
message->MutableRepeatedExtension(extension)->end();
for (; iter != end; ++iter) {
*iter += val;
@@ -916,14 +915,19 @@
unittest::TestAllExtensions message;
// Test empty repeated-field case (b/12926163)
- ASSERT_EQ(0, message.GetRepeatedExtension(
- unittest::repeated_int32_extension).size());
- ASSERT_EQ(0, message.GetRepeatedExtension(
- unittest::repeated_nested_enum_extension).size());
- ASSERT_EQ(0, message.GetRepeatedExtension(
- unittest::repeated_string_extension).size());
- ASSERT_EQ(0, message.GetRepeatedExtension(
- unittest::repeated_nested_message_extension).size());
+ ASSERT_EQ(
+ 0,
+ message.GetRepeatedExtension(unittest::repeated_int32_extension).size());
+ ASSERT_EQ(
+ 0, message.GetRepeatedExtension(unittest::repeated_nested_enum_extension)
+ .size());
+ ASSERT_EQ(
+ 0,
+ message.GetRepeatedExtension(unittest::repeated_string_extension).size());
+ ASSERT_EQ(
+ 0,
+ message.GetRepeatedExtension(unittest::repeated_nested_message_extension)
+ .size());
unittest::TestAllTypes::NestedMessage nested_message;
nested_message.set_bb(42);
@@ -949,111 +953,110 @@
std::string("test"));
message.AddExtension(unittest::repeated_bytes_extension,
std::string("test\xFF"));
- message.AddExtension(
- unittest::repeated_nested_message_extension)->CopyFrom(nested_message);
- message.AddExtension(unittest::repeated_nested_enum_extension,
- nested_enum);
+ message.AddExtension(unittest::repeated_nested_message_extension)
+ ->CopyFrom(nested_message);
+ message.AddExtension(unittest::repeated_nested_enum_extension, nested_enum);
}
- ASSERT_EQ(10, SumAllExtensions<int32>(
- message, unittest::repeated_int32_extension, 0));
- IncAllExtensions<int32>(
- &message, unittest::repeated_int32_extension, 1);
- ASSERT_EQ(20, SumAllExtensions<int32>(
- message, unittest::repeated_int32_extension, 0));
+ ASSERT_EQ(10, SumAllExtensions<int32>(message,
+ unittest::repeated_int32_extension, 0));
+ IncAllExtensions<int32>(&message, unittest::repeated_int32_extension, 1);
+ ASSERT_EQ(20, SumAllExtensions<int32>(message,
+ unittest::repeated_int32_extension, 0));
- ASSERT_EQ(20, SumAllExtensions<int64>(
- message, unittest::repeated_int64_extension, 0));
- IncAllExtensions<int64>(
- &message, unittest::repeated_int64_extension, 1);
- ASSERT_EQ(30, SumAllExtensions<int64>(
- message, unittest::repeated_int64_extension, 0));
+ ASSERT_EQ(20, SumAllExtensions<int64>(message,
+ unittest::repeated_int64_extension, 0));
+ IncAllExtensions<int64>(&message, unittest::repeated_int64_extension, 1);
+ ASSERT_EQ(30, SumAllExtensions<int64>(message,
+ unittest::repeated_int64_extension, 0));
ASSERT_EQ(30, SumAllExtensions<uint32>(
- message, unittest::repeated_uint32_extension, 0));
- IncAllExtensions<uint32>(
- &message, unittest::repeated_uint32_extension, 1);
+ message, unittest::repeated_uint32_extension, 0));
+ IncAllExtensions<uint32>(&message, unittest::repeated_uint32_extension, 1);
ASSERT_EQ(40, SumAllExtensions<uint32>(
- message, unittest::repeated_uint32_extension, 0));
+ message, unittest::repeated_uint32_extension, 0));
ASSERT_EQ(40, SumAllExtensions<uint64>(
- message, unittest::repeated_uint64_extension, 0));
- IncAllExtensions<uint64>(
- &message, unittest::repeated_uint64_extension, 1);
+ message, unittest::repeated_uint64_extension, 0));
+ IncAllExtensions<uint64>(&message, unittest::repeated_uint64_extension, 1);
ASSERT_EQ(50, SumAllExtensions<uint64>(
- message, unittest::repeated_uint64_extension, 0));
+ message, unittest::repeated_uint64_extension, 0));
ASSERT_EQ(50, SumAllExtensions<int32>(
- message, unittest::repeated_sint32_extension, 0));
- IncAllExtensions<int32>(
- &message, unittest::repeated_sint32_extension, 1);
+ message, unittest::repeated_sint32_extension, 0));
+ IncAllExtensions<int32>(&message, unittest::repeated_sint32_extension, 1);
ASSERT_EQ(60, SumAllExtensions<int32>(
- message, unittest::repeated_sint32_extension, 0));
+ message, unittest::repeated_sint32_extension, 0));
ASSERT_EQ(60, SumAllExtensions<int64>(
- message, unittest::repeated_sint64_extension, 0));
- IncAllExtensions<int64>(
- &message, unittest::repeated_sint64_extension, 1);
+ message, unittest::repeated_sint64_extension, 0));
+ IncAllExtensions<int64>(&message, unittest::repeated_sint64_extension, 1);
ASSERT_EQ(70, SumAllExtensions<int64>(
- message, unittest::repeated_sint64_extension, 0));
+ message, unittest::repeated_sint64_extension, 0));
ASSERT_EQ(70, SumAllExtensions<uint32>(
- message, unittest::repeated_fixed32_extension, 0));
- IncAllExtensions<uint32>(
- &message, unittest::repeated_fixed32_extension, 1);
+ message, unittest::repeated_fixed32_extension, 0));
+ IncAllExtensions<uint32>(&message, unittest::repeated_fixed32_extension, 1);
ASSERT_EQ(80, SumAllExtensions<uint32>(
- message, unittest::repeated_fixed32_extension, 0));
+ message, unittest::repeated_fixed32_extension, 0));
ASSERT_EQ(80, SumAllExtensions<uint64>(
- message, unittest::repeated_fixed64_extension, 0));
- IncAllExtensions<uint64>(
- &message, unittest::repeated_fixed64_extension, 1);
+ message, unittest::repeated_fixed64_extension, 0));
+ IncAllExtensions<uint64>(&message, unittest::repeated_fixed64_extension, 1);
ASSERT_EQ(90, SumAllExtensions<uint64>(
- message, unittest::repeated_fixed64_extension, 0));
+ message, unittest::repeated_fixed64_extension, 0));
// Usually, floating-point arithmetic cannot be trusted to be exact, so it is
// a Bad Idea to assert equality in a test like this. However, we're dealing
// with integers with a small number of significant mantissa bits, so we
// should actually have exact precision here.
- ASSERT_EQ(90, SumAllExtensions<float>(
- message, unittest::repeated_float_extension, 0));
- IncAllExtensions<float>(
- &message, unittest::repeated_float_extension, 1);
+ ASSERT_EQ(90, SumAllExtensions<float>(message,
+ unittest::repeated_float_extension, 0));
+ IncAllExtensions<float>(&message, unittest::repeated_float_extension, 1);
ASSERT_EQ(100, SumAllExtensions<float>(
- message, unittest::repeated_float_extension, 0));
+ message, unittest::repeated_float_extension, 0));
ASSERT_EQ(100, SumAllExtensions<double>(
- message, unittest::repeated_double_extension, 0));
- IncAllExtensions<double>(
- &message, unittest::repeated_double_extension, 1);
+ message, unittest::repeated_double_extension, 0));
+ IncAllExtensions<double>(&message, unittest::repeated_double_extension, 1);
ASSERT_EQ(110, SumAllExtensions<double>(
- message, unittest::repeated_double_extension, 0));
+ message, unittest::repeated_double_extension, 0));
RepeatedPtrField<std::string>::iterator string_iter;
RepeatedPtrField<std::string>::iterator string_end;
- for (string_iter = message.MutableRepeatedExtension(
- unittest::repeated_string_extension)->begin(),
- string_end = message.MutableRepeatedExtension(
- unittest::repeated_string_extension)->end();
+ for (string_iter =
+ message
+ .MutableRepeatedExtension(unittest::repeated_string_extension)
+ ->begin(),
+ string_end =
+ message
+ .MutableRepeatedExtension(unittest::repeated_string_extension)
+ ->end();
string_iter != string_end; ++string_iter) {
*string_iter += "test";
}
RepeatedPtrField<std::string>::const_iterator string_const_iter;
RepeatedPtrField<std::string>::const_iterator string_const_end;
- for (string_const_iter = message.GetRepeatedExtension(
- unittest::repeated_string_extension).begin(),
- string_const_end = message.GetRepeatedExtension(
- unittest::repeated_string_extension).end();
+ for (string_const_iter =
+ message.GetRepeatedExtension(unittest::repeated_string_extension)
+ .begin(),
+ string_const_end =
+ message.GetRepeatedExtension(unittest::repeated_string_extension)
+ .end();
string_iter != string_end; ++string_iter) {
ASSERT_TRUE(*string_iter == "testtest");
}
RepeatedField<unittest::TestAllTypes_NestedEnum>::iterator enum_iter;
RepeatedField<unittest::TestAllTypes_NestedEnum>::iterator enum_end;
- for (enum_iter = message.MutableRepeatedExtension(
- unittest::repeated_nested_enum_extension)->begin(),
- enum_end = message.MutableRepeatedExtension(
- unittest::repeated_nested_enum_extension)->end();
+ for (enum_iter = message
+ .MutableRepeatedExtension(
+ unittest::repeated_nested_enum_extension)
+ ->begin(),
+ enum_end = message
+ .MutableRepeatedExtension(
+ unittest::repeated_nested_enum_extension)
+ ->end();
enum_iter != enum_end; ++enum_iter) {
*enum_iter = unittest::TestAllTypes::NestedEnum_MAX;
}
@@ -1073,25 +1076,31 @@
ASSERT_EQ(*enum_const_iter, unittest::TestAllTypes::NestedEnum_MAX);
}
- RepeatedPtrField<unittest::TestAllTypes_NestedMessage>::iterator
- msg_iter;
- RepeatedPtrField<unittest::TestAllTypes_NestedMessage>::iterator
- msg_end;
- for (msg_iter = message.MutableRepeatedExtension(
- unittest::repeated_nested_message_extension)->begin(),
- msg_end = message.MutableRepeatedExtension(
- unittest::repeated_nested_message_extension)->end();
+ RepeatedPtrField<unittest::TestAllTypes_NestedMessage>::iterator msg_iter;
+ RepeatedPtrField<unittest::TestAllTypes_NestedMessage>::iterator msg_end;
+ for (msg_iter = message
+ .MutableRepeatedExtension(
+ unittest::repeated_nested_message_extension)
+ ->begin(),
+ msg_end = message
+ .MutableRepeatedExtension(
+ unittest::repeated_nested_message_extension)
+ ->end();
msg_iter != msg_end; ++msg_iter) {
msg_iter->set_bb(1234);
}
- RepeatedPtrField<unittest::TestAllTypes_NestedMessage>::
- const_iterator msg_const_iter;
- RepeatedPtrField<unittest::TestAllTypes_NestedMessage>::
- const_iterator msg_const_end;
- for (msg_const_iter = message.GetRepeatedExtension(
- unittest::repeated_nested_message_extension).begin(),
- msg_const_end = message.GetRepeatedExtension(
- unittest::repeated_nested_message_extension).end();
+ RepeatedPtrField<unittest::TestAllTypes_NestedMessage>::const_iterator
+ msg_const_iter;
+ RepeatedPtrField<unittest::TestAllTypes_NestedMessage>::const_iterator
+ msg_const_end;
+ for (msg_const_iter = message
+ .GetRepeatedExtension(
+ unittest::repeated_nested_message_extension)
+ .begin(),
+ msg_const_end = message
+ .GetRepeatedExtension(
+ unittest::repeated_nested_message_extension)
+ .end();
msg_const_iter != msg_const_end; ++msg_const_iter) {
ASSERT_EQ(msg_const_iter->bb(), 1234);
}
@@ -1099,30 +1108,30 @@
// Test range-based for as well, but only if compiled as C++11.
#if __cplusplus >= 201103L
// Test one primitive field.
- for (auto& x : *message.MutableRepeatedExtension(
- unittest::repeated_int32_extension)) {
+ for (auto& x :
+ *message.MutableRepeatedExtension(unittest::repeated_int32_extension)) {
x = 4321;
}
- for (const auto& x : message.GetRepeatedExtension(
- unittest::repeated_int32_extension)) {
+ for (const auto& x :
+ message.GetRepeatedExtension(unittest::repeated_int32_extension)) {
ASSERT_EQ(x, 4321);
}
// Test one string field.
- for (auto& x : *message.MutableRepeatedExtension(
- unittest::repeated_string_extension)) {
+ for (auto& x :
+ *message.MutableRepeatedExtension(unittest::repeated_string_extension)) {
x = "test_range_based_for";
}
- for (const auto& x : message.GetRepeatedExtension(
- unittest::repeated_string_extension)) {
+ for (const auto& x :
+ message.GetRepeatedExtension(unittest::repeated_string_extension)) {
ASSERT_TRUE(x == "test_range_based_for");
}
// Test one message field.
for (auto& x : *message.MutableRepeatedExtension(
- unittest::repeated_nested_message_extension)) {
+ unittest::repeated_nested_message_extension)) {
x.set_bb(4321);
}
for (const auto& x : *message.MutableRepeatedExtension(
- unittest::repeated_nested_message_extension)) {
+ unittest::repeated_nested_message_extension)) {
ASSERT_EQ(x.bb(), 4321);
}
#endif
@@ -1132,12 +1141,13 @@
TEST(ExtensionSetTest, AbsentExtension) {
unittest::TestAllExtensions message;
message.MutableRepeatedExtension(unittest::repeated_nested_message_extension)
- ->Add()->set_bb(123);
- ASSERT_EQ(1, message.ExtensionSize(
- unittest::repeated_nested_message_extension));
- EXPECT_EQ(
- 123, message.GetExtension(
- unittest::repeated_nested_message_extension, 0).bb());
+ ->Add()
+ ->set_bb(123);
+ ASSERT_EQ(1,
+ message.ExtensionSize(unittest::repeated_nested_message_extension));
+ EXPECT_EQ(123,
+ message.GetExtension(unittest::repeated_nested_message_extension, 0)
+ .bb());
}
#ifdef PROTOBUF_HAS_DEATH_TEST
@@ -1145,9 +1155,9 @@
TEST(ExtensionSetTest, InvalidEnumDeath) {
unittest::TestAllExtensions message;
EXPECT_DEBUG_DEATH(
- message.SetExtension(unittest::optional_foreign_enum_extension,
- static_cast<unittest::ForeignEnum>(53)),
- "IsValid");
+ message.SetExtension(unittest::optional_foreign_enum_extension,
+ static_cast<unittest::ForeignEnum>(53)),
+ "IsValid");
}
#endif // PROTOBUF_HAS_DEATH_TEST
@@ -1223,8 +1233,8 @@
// An unknown enum value (for a known field).
message.mutable_unknown_fields()->AddVarint(
- unittest::TestDynamicExtensions::kDynamicEnumExtensionFieldNumber,
- 12345);
+ unittest::TestDynamicExtensions::kDynamicEnumExtensionFieldNumber,
+ 12345);
// A regular unknown field.
message.mutable_unknown_fields()->AddLengthDelimited(54321, "unknown");
@@ -1244,24 +1254,24 @@
// Can we print it?
EXPECT_EQ(
- "[dynamic_extensions.scalar_extension]: 123\n"
- "[dynamic_extensions.enum_extension]: FOREIGN_BAR\n"
- "[dynamic_extensions.dynamic_enum_extension]: DYNAMIC_BAZ\n"
- "[dynamic_extensions.message_extension] {\n"
- " c: 456\n"
- "}\n"
- "[dynamic_extensions.dynamic_message_extension] {\n"
- " dynamic_field: 789\n"
- "}\n"
- "[dynamic_extensions.repeated_extension]: \"foo\"\n"
- "[dynamic_extensions.repeated_extension]: \"bar\"\n"
- "[dynamic_extensions.packed_extension]: 12\n"
- "[dynamic_extensions.packed_extension]: -34\n"
- "[dynamic_extensions.packed_extension]: 56\n"
- "[dynamic_extensions.packed_extension]: -78\n"
- "2002: 12345\n"
- "54321: \"unknown\"\n",
- message.DebugString());
+ "[dynamic_extensions.scalar_extension]: 123\n"
+ "[dynamic_extensions.enum_extension]: FOREIGN_BAR\n"
+ "[dynamic_extensions.dynamic_enum_extension]: DYNAMIC_BAZ\n"
+ "[dynamic_extensions.message_extension] {\n"
+ " c: 456\n"
+ "}\n"
+ "[dynamic_extensions.dynamic_message_extension] {\n"
+ " dynamic_field: 789\n"
+ "}\n"
+ "[dynamic_extensions.repeated_extension]: \"foo\"\n"
+ "[dynamic_extensions.repeated_extension]: \"bar\"\n"
+ "[dynamic_extensions.packed_extension]: 12\n"
+ "[dynamic_extensions.packed_extension]: -34\n"
+ "[dynamic_extensions.packed_extension]: 56\n"
+ "[dynamic_extensions.packed_extension]: -78\n"
+ "2002: 12345\n"
+ "54321: \"unknown\"\n",
+ message.DebugString());
// Can we serialize it?
EXPECT_TRUE(
@@ -1302,9 +1312,8 @@
file->FindExtensionByName("dynamic_message_extension");
ASSERT_TRUE(dynamic_message_extension != NULL);
const Message& parent = unittest::TestAllExtensions::default_instance();
- const Message& sub_message =
- parent.GetReflection()->GetMessage(parent, dynamic_message_extension,
- &dynamic_factory);
+ const Message& sub_message = parent.GetReflection()->GetMessage(
+ parent, dynamic_message_extension, &dynamic_factory);
const Message* prototype =
dynamic_factory.GetPrototype(dynamic_message_extension->message_type());
EXPECT_EQ(prototype, &sub_message);
diff --git a/src/google/protobuf/field_mask.pb.cc b/src/google/protobuf/field_mask.pb.cc
index 0c54eb7..e360a6d 100644
--- a/src/google/protobuf/field_mask.pb.cc
+++ b/src/google/protobuf/field_mask.pb.cc
@@ -36,10 +36,6 @@
PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_FieldMask_google_2fprotobuf_2ffield_5fmask_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsFieldMask_google_2fprotobuf_2ffield_5fmask_2eproto}, {}};
-void InitDefaults_google_2fprotobuf_2ffield_5fmask_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldMask_google_2fprotobuf_2ffield_5fmask_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2ffield_5fmask_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2ffield_5fmask_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2ffield_5fmask_2eproto = nullptr;
@@ -75,8 +71,7 @@
"rotobuf.WellKnownTypesb\006proto3"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ffield_5fmask_2eproto = {
- false, InitDefaults_google_2fprotobuf_2ffield_5fmask_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2ffield_5fmask_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2ffield_5fmask_2eproto,
"google/protobuf/field_mask.proto", &assign_descriptors_table_google_2fprotobuf_2ffield_5fmask_2eproto, 230,
};
@@ -84,6 +79,7 @@
static constexpr ::PROTOBUF_NAMESPACE_ID::internal::InitFunc deps[1] =
{
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldMask_google_2fprotobuf_2ffield_5fmask_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2ffield_5fmask_2eproto, deps, 0);
}
@@ -165,35 +161,43 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* FieldMask::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// repeated string paths = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
- do {
+ while (true) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_paths(), ptr, ctx, "google.protobuf.FieldMask.paths");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 10 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 10) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool FieldMask::MergePartialFromCodedStream(
diff --git a/src/google/protobuf/generated_enum_reflection.h b/src/google/protobuf/generated_enum_reflection.h
index c683368..c25e51b 100644
--- a/src/google/protobuf/generated_enum_reflection.h
+++ b/src/google/protobuf/generated_enum_reflection.h
@@ -41,8 +41,8 @@
#include <string>
-#include <google/protobuf/port.h>
#include <google/protobuf/generated_enum_util.h>
+#include <google/protobuf/port.h>
#ifdef SWIG
#error "You cannot SWIG proto headers"
@@ -52,7 +52,7 @@
namespace google {
namespace protobuf {
- class EnumDescriptor;
+class EnumDescriptor;
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/generated_enum_util.h b/src/google/protobuf/generated_enum_util.h
index 5c4dd65..55db124 100644
--- a/src/google/protobuf/generated_enum_util.h
+++ b/src/google/protobuf/generated_enum_util.h
@@ -42,7 +42,8 @@
// This type trait can be used to cause templates to only match proto2 enum
// types.
-template <typename T> struct is_proto_enum : ::std::false_type {};
+template <typename T>
+struct is_proto_enum : ::std::false_type {};
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/generated_message_reflection.cc b/src/google/protobuf/generated_message_reflection.cc
index 443a5db..9b2209a 100644
--- a/src/google/protobuf/generated_message_reflection.cc
+++ b/src/google/protobuf/generated_message_reflection.cc
@@ -59,9 +59,7 @@
namespace internal {
namespace {
-bool IsMapFieldInApi(const FieldDescriptor* field) {
- return field->is_map();
-}
+bool IsMapFieldInApi(const FieldDescriptor* field) { return field->is_map(); }
} // anonymous namespace
bool ParseNamedEnum(const EnumDescriptor* descriptor, const std::string& name,
@@ -99,89 +97,102 @@
return *GetConstPointerAtOffset<To>(&message, offset);
}
-void ReportReflectionUsageError(
- const Descriptor* descriptor, const FieldDescriptor* field,
- const char* method, const char* description) {
- GOOGLE_LOG(FATAL)
- << "Protocol Buffer reflection usage error:\n"
- " Method : google::protobuf::Reflection::" << method << "\n"
- " Message type: " << descriptor->full_name() << "\n"
- " Field : " << field->full_name() << "\n"
- " Problem : " << description;
+void ReportReflectionUsageError(const Descriptor* descriptor,
+ const FieldDescriptor* field,
+ const char* method, const char* description) {
+ GOOGLE_LOG(FATAL) << "Protocol Buffer reflection usage error:\n"
+ " Method : google::protobuf::Reflection::"
+ << method
+ << "\n"
+ " Message type: "
+ << descriptor->full_name()
+ << "\n"
+ " Field : "
+ << field->full_name()
+ << "\n"
+ " Problem : "
+ << description;
}
const char* cpptype_names_[FieldDescriptor::MAX_CPPTYPE + 1] = {
- "INVALID_CPPTYPE",
- "CPPTYPE_INT32",
- "CPPTYPE_INT64",
- "CPPTYPE_UINT32",
- "CPPTYPE_UINT64",
- "CPPTYPE_DOUBLE",
- "CPPTYPE_FLOAT",
- "CPPTYPE_BOOL",
- "CPPTYPE_ENUM",
- "CPPTYPE_STRING",
- "CPPTYPE_MESSAGE"
-};
+ "INVALID_CPPTYPE", "CPPTYPE_INT32", "CPPTYPE_INT64", "CPPTYPE_UINT32",
+ "CPPTYPE_UINT64", "CPPTYPE_DOUBLE", "CPPTYPE_FLOAT", "CPPTYPE_BOOL",
+ "CPPTYPE_ENUM", "CPPTYPE_STRING", "CPPTYPE_MESSAGE"};
static void ReportReflectionUsageTypeError(
const Descriptor* descriptor, const FieldDescriptor* field,
- const char* method,
- FieldDescriptor::CppType expected_type) {
+ const char* method, FieldDescriptor::CppType expected_type) {
GOOGLE_LOG(FATAL)
- << "Protocol Buffer reflection usage error:\n"
- " Method : google::protobuf::Reflection::" << method << "\n"
- " Message type: " << descriptor->full_name() << "\n"
- " Field : " << field->full_name() << "\n"
- " Problem : Field is not the right type for this message:\n"
- " Expected : " << cpptype_names_[expected_type] << "\n"
- " Field type: " << cpptype_names_[field->cpp_type()];
+ << "Protocol Buffer reflection usage error:\n"
+ " Method : google::protobuf::Reflection::"
+ << method
+ << "\n"
+ " Message type: "
+ << descriptor->full_name()
+ << "\n"
+ " Field : "
+ << field->full_name()
+ << "\n"
+ " Problem : Field is not the right type for this message:\n"
+ " Expected : "
+ << cpptype_names_[expected_type]
+ << "\n"
+ " Field type: "
+ << cpptype_names_[field->cpp_type()];
}
static void ReportReflectionUsageEnumTypeError(
const Descriptor* descriptor, const FieldDescriptor* field,
const char* method, const EnumValueDescriptor* value) {
- GOOGLE_LOG(FATAL)
- << "Protocol Buffer reflection usage error:\n"
- " Method : google::protobuf::Reflection::" << method << "\n"
- " Message type: " << descriptor->full_name() << "\n"
- " Field : " << field->full_name() << "\n"
- " Problem : Enum value did not match field type:\n"
- " Expected : " << field->enum_type()->full_name() << "\n"
- " Actual : " << value->full_name();
+ GOOGLE_LOG(FATAL) << "Protocol Buffer reflection usage error:\n"
+ " Method : google::protobuf::Reflection::"
+ << method
+ << "\n"
+ " Message type: "
+ << descriptor->full_name()
+ << "\n"
+ " Field : "
+ << field->full_name()
+ << "\n"
+ " Problem : Enum value did not match field type:\n"
+ " Expected : "
+ << field->enum_type()->full_name()
+ << "\n"
+ " Actual : "
+ << value->full_name();
}
-#define USAGE_CHECK(CONDITION, METHOD, ERROR_DESCRIPTION) \
- if (!(CONDITION)) \
- ReportReflectionUsageError(descriptor_, field, #METHOD, ERROR_DESCRIPTION)
-#define USAGE_CHECK_EQ(A, B, METHOD, ERROR_DESCRIPTION) \
+#define USAGE_CHECK(CONDITION, METHOD, ERROR_DESCRIPTION) \
+ if (!(CONDITION)) \
+ ReportReflectionUsageError(descriptor_, field, #METHOD, ERROR_DESCRIPTION)
+#define USAGE_CHECK_EQ(A, B, METHOD, ERROR_DESCRIPTION) \
USAGE_CHECK((A) == (B), METHOD, ERROR_DESCRIPTION)
-#define USAGE_CHECK_NE(A, B, METHOD, ERROR_DESCRIPTION) \
+#define USAGE_CHECK_NE(A, B, METHOD, ERROR_DESCRIPTION) \
USAGE_CHECK((A) != (B), METHOD, ERROR_DESCRIPTION)
-#define USAGE_CHECK_TYPE(METHOD, CPPTYPE) \
- if (field->cpp_type() != FieldDescriptor::CPPTYPE_##CPPTYPE) \
- ReportReflectionUsageTypeError(descriptor_, field, #METHOD, \
- FieldDescriptor::CPPTYPE_##CPPTYPE)
+#define USAGE_CHECK_TYPE(METHOD, CPPTYPE) \
+ if (field->cpp_type() != FieldDescriptor::CPPTYPE_##CPPTYPE) \
+ ReportReflectionUsageTypeError(descriptor_, field, #METHOD, \
+ FieldDescriptor::CPPTYPE_##CPPTYPE)
-#define USAGE_CHECK_ENUM_VALUE(METHOD) \
- if (value->type() != field->enum_type()) \
- ReportReflectionUsageEnumTypeError(descriptor_, field, #METHOD, value)
+#define USAGE_CHECK_ENUM_VALUE(METHOD) \
+ if (value->type() != field->enum_type()) \
+ ReportReflectionUsageEnumTypeError(descriptor_, field, #METHOD, value)
-#define USAGE_CHECK_MESSAGE_TYPE(METHOD) \
- USAGE_CHECK_EQ(field->containing_type(), descriptor_, \
- METHOD, "Field does not match message type.");
-#define USAGE_CHECK_SINGULAR(METHOD) \
- USAGE_CHECK_NE(field->label(), FieldDescriptor::LABEL_REPEATED, METHOD, \
+#define USAGE_CHECK_MESSAGE_TYPE(METHOD) \
+ USAGE_CHECK_EQ(field->containing_type(), descriptor_, METHOD, \
+ "Field does not match message type.");
+#define USAGE_CHECK_SINGULAR(METHOD) \
+ USAGE_CHECK_NE(field->label(), FieldDescriptor::LABEL_REPEATED, METHOD, \
"Field is repeated; the method requires a singular field.")
-#define USAGE_CHECK_REPEATED(METHOD) \
- USAGE_CHECK_EQ(field->label(), FieldDescriptor::LABEL_REPEATED, METHOD, \
+#define USAGE_CHECK_REPEATED(METHOD) \
+ USAGE_CHECK_EQ(field->label(), FieldDescriptor::LABEL_REPEATED, METHOD, \
"Field is singular; the method requires a repeated field.")
-#define USAGE_CHECK_ALL(METHOD, LABEL, CPPTYPE) \
- USAGE_CHECK_MESSAGE_TYPE(METHOD); \
- USAGE_CHECK_##LABEL(METHOD); \
- USAGE_CHECK_TYPE(METHOD, CPPTYPE)
+#define USAGE_CHECK_ALL(METHOD, LABEL, CPPTYPE) \
+ USAGE_CHECK_MESSAGE_TYPE(METHOD); \
+ USAGE_CHECK_##LABEL(METHOD); \
+ USAGE_CHECK_TYPE(METHOD, CPPTYPE)
} // namespace
@@ -226,20 +237,20 @@
const FieldDescriptor* field = descriptor_->field(i);
if (field->is_repeated()) {
switch (field->cpp_type()) {
-#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
- case FieldDescriptor::CPPTYPE_##UPPERCASE : \
- total_size += GetRaw<RepeatedField<LOWERCASE> >(message, field) \
- .SpaceUsedExcludingSelfLong(); \
- break
+#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
+ case FieldDescriptor::CPPTYPE_##UPPERCASE: \
+ total_size += GetRaw<RepeatedField<LOWERCASE> >(message, field) \
+ .SpaceUsedExcludingSelfLong(); \
+ break
- HANDLE_TYPE( INT32, int32);
- HANDLE_TYPE( INT64, int64);
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
HANDLE_TYPE(UINT32, uint32);
HANDLE_TYPE(UINT64, uint64);
HANDLE_TYPE(DOUBLE, double);
- HANDLE_TYPE( FLOAT, float);
- HANDLE_TYPE( BOOL, bool);
- HANDLE_TYPE( ENUM, int);
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(BOOL, bool);
+ HANDLE_TYPE(ENUM, int);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_STRING:
@@ -272,14 +283,14 @@
continue;
}
switch (field->cpp_type()) {
- case FieldDescriptor::CPPTYPE_INT32 :
- case FieldDescriptor::CPPTYPE_INT64 :
+ case FieldDescriptor::CPPTYPE_INT32:
+ case FieldDescriptor::CPPTYPE_INT64:
case FieldDescriptor::CPPTYPE_UINT32:
case FieldDescriptor::CPPTYPE_UINT64:
case FieldDescriptor::CPPTYPE_DOUBLE:
- case FieldDescriptor::CPPTYPE_FLOAT :
- case FieldDescriptor::CPPTYPE_BOOL :
- case FieldDescriptor::CPPTYPE_ENUM :
+ case FieldDescriptor::CPPTYPE_FLOAT:
+ case FieldDescriptor::CPPTYPE_BOOL:
+ case FieldDescriptor::CPPTYPE_ENUM:
// Field is inline, so we've already counted it.
break;
@@ -331,26 +342,24 @@
return total_size;
}
-void GeneratedMessageReflection::SwapField(
- Message* message1,
- Message* message2,
- const FieldDescriptor* field) const {
+void GeneratedMessageReflection::SwapField(Message* message1, Message* message2,
+ const FieldDescriptor* field) const {
if (field->is_repeated()) {
switch (field->cpp_type()) {
-#define SWAP_ARRAYS(CPPTYPE, TYPE) \
- case FieldDescriptor::CPPTYPE_##CPPTYPE: \
- MutableRaw<RepeatedField<TYPE> >(message1, field)->Swap( \
- MutableRaw<RepeatedField<TYPE> >(message2, field)); \
- break;
+#define SWAP_ARRAYS(CPPTYPE, TYPE) \
+ case FieldDescriptor::CPPTYPE_##CPPTYPE: \
+ MutableRaw<RepeatedField<TYPE> >(message1, field) \
+ ->Swap(MutableRaw<RepeatedField<TYPE> >(message2, field)); \
+ break;
- SWAP_ARRAYS(INT32 , int32 );
- SWAP_ARRAYS(INT64 , int64 );
+ SWAP_ARRAYS(INT32, int32);
+ SWAP_ARRAYS(INT64, int64);
SWAP_ARRAYS(UINT32, uint32);
SWAP_ARRAYS(UINT64, uint64);
- SWAP_ARRAYS(FLOAT , float );
+ SWAP_ARRAYS(FLOAT, float);
SWAP_ARRAYS(DOUBLE, double);
- SWAP_ARRAYS(BOOL , bool );
- SWAP_ARRAYS(ENUM , int );
+ SWAP_ARRAYS(BOOL, bool);
+ SWAP_ARRAYS(ENUM, int);
#undef SWAP_ARRAYS
case FieldDescriptor::CPPTYPE_STRING:
@@ -365,8 +374,8 @@
break;
case FieldDescriptor::CPPTYPE_MESSAGE:
if (IsMapFieldInApi(field)) {
- MutableRaw<MapFieldBase>(message1, field)->Swap(
- MutableRaw<MapFieldBase>(message2, field));
+ MutableRaw<MapFieldBase>(message1, field)
+ ->Swap(MutableRaw<MapFieldBase>(message2, field));
} else {
MutableRaw<RepeatedPtrFieldBase>(message1, field)
->Swap<GenericTypeHandler<Message> >(
@@ -379,20 +388,20 @@
}
} else {
switch (field->cpp_type()) {
-#define SWAP_VALUES(CPPTYPE, TYPE) \
- case FieldDescriptor::CPPTYPE_##CPPTYPE: \
- std::swap(*MutableRaw<TYPE>(message1, field), \
- *MutableRaw<TYPE>(message2, field)); \
- break;
+#define SWAP_VALUES(CPPTYPE, TYPE) \
+ case FieldDescriptor::CPPTYPE_##CPPTYPE: \
+ std::swap(*MutableRaw<TYPE>(message1, field), \
+ *MutableRaw<TYPE>(message2, field)); \
+ break;
- SWAP_VALUES(INT32 , int32 );
- SWAP_VALUES(INT64 , int64 );
+ SWAP_VALUES(INT32, int32);
+ SWAP_VALUES(INT64, int64);
SWAP_VALUES(UINT32, uint32);
SWAP_VALUES(UINT64, uint64);
- SWAP_VALUES(FLOAT , float );
+ SWAP_VALUES(FLOAT, float);
SWAP_VALUES(DOUBLE, double);
- SWAP_VALUES(BOOL , bool );
- SWAP_VALUES(ENUM , int );
+ SWAP_VALUES(BOOL, bool);
+ SWAP_VALUES(ENUM, int);
#undef SWAP_VALUES
case FieldDescriptor::CPPTYPE_MESSAGE:
if (GetArena(message1) == GetArena(message2)) {
@@ -421,35 +430,33 @@
case FieldDescriptor::CPPTYPE_STRING:
switch (field->options().ctype()) {
default: // TODO(kenton): Support other string reps.
- case FieldOptions::STRING:
- {
- Arena* arena1 = GetArena(message1);
- Arena* arena2 = GetArena(message2);
+ case FieldOptions::STRING: {
+ Arena* arena1 = GetArena(message1);
+ Arena* arena2 = GetArena(message2);
- if (IsInlined(field)) {
- InlinedStringField* string1 =
- MutableRaw<InlinedStringField>(message1, field);
- InlinedStringField* string2 =
- MutableRaw<InlinedStringField>(message2, field);
- string1->Swap(string2);
- break;
- }
-
- ArenaStringPtr* string1 =
- MutableRaw<ArenaStringPtr>(message1, field);
- ArenaStringPtr* string2 =
- MutableRaw<ArenaStringPtr>(message2, field);
- const std::string* default_ptr =
- &DefaultRaw<ArenaStringPtr>(field).Get();
- if (arena1 == arena2) {
- string1->Swap(string2, default_ptr, arena1);
- } else {
- const std::string temp = string1->Get();
- string1->Set(default_ptr, string2->Get(), arena1);
- string2->Set(default_ptr, temp, arena2);
- }
+ if (IsInlined(field)) {
+ InlinedStringField* string1 =
+ MutableRaw<InlinedStringField>(message1, field);
+ InlinedStringField* string2 =
+ MutableRaw<InlinedStringField>(message2, field);
+ string1->Swap(string2);
+ break;
}
- break;
+
+ ArenaStringPtr* string1 =
+ MutableRaw<ArenaStringPtr>(message1, field);
+ ArenaStringPtr* string2 =
+ MutableRaw<ArenaStringPtr>(message2, field);
+ const std::string* default_ptr =
+ &DefaultRaw<ArenaStringPtr>(field).Get();
+ if (arena1 == arena2) {
+ string1->Swap(string2, default_ptr, arena1);
+ } else {
+ const std::string temp = string1->Get();
+ string1->Set(default_ptr, string2->Get(), arena1);
+ string2->Set(default_ptr, temp, arena2);
+ }
+ } break;
}
break;
@@ -460,8 +467,7 @@
}
void GeneratedMessageReflection::SwapOneofField(
- Message* message1,
- Message* message2,
+ Message* message1, Message* message2,
const OneofDescriptor* oneof_descriptor) const {
uint32 oneof_case1 = GetOneofCase(*message1, oneof_descriptor);
uint32 oneof_case2 = GetOneofCase(*message2, oneof_descriptor);
@@ -481,21 +487,21 @@
const FieldDescriptor* field1 = NULL;
if (oneof_case1 > 0) {
field1 = descriptor_->FindFieldByNumber(oneof_case1);
- //oneof_descriptor->field(oneof_case1);
+ // oneof_descriptor->field(oneof_case1);
switch (field1->cpp_type()) {
-#define GET_TEMP_VALUE(CPPTYPE, TYPE) \
- case FieldDescriptor::CPPTYPE_##CPPTYPE: \
- temp_##TYPE = GetField<TYPE>(*message1, field1); \
- break;
+#define GET_TEMP_VALUE(CPPTYPE, TYPE) \
+ case FieldDescriptor::CPPTYPE_##CPPTYPE: \
+ temp_##TYPE = GetField<TYPE>(*message1, field1); \
+ break;
- GET_TEMP_VALUE(INT32 , int32 );
- GET_TEMP_VALUE(INT64 , int64 );
+ GET_TEMP_VALUE(INT32, int32);
+ GET_TEMP_VALUE(INT64, int64);
GET_TEMP_VALUE(UINT32, uint32);
GET_TEMP_VALUE(UINT64, uint64);
- GET_TEMP_VALUE(FLOAT , float );
+ GET_TEMP_VALUE(FLOAT, float);
GET_TEMP_VALUE(DOUBLE, double);
- GET_TEMP_VALUE(BOOL , bool );
- GET_TEMP_VALUE(ENUM , int );
+ GET_TEMP_VALUE(BOOL, bool);
+ GET_TEMP_VALUE(ENUM, int);
#undef GET_TEMP_VALUE
case FieldDescriptor::CPPTYPE_MESSAGE:
temp_message = ReleaseMessage(message1, field1);
@@ -512,27 +518,24 @@
// Sets message1's oneof field from the message2's oneof field.
if (oneof_case2 > 0) {
- const FieldDescriptor* field2 =
- descriptor_->FindFieldByNumber(oneof_case2);
+ const FieldDescriptor* field2 = descriptor_->FindFieldByNumber(oneof_case2);
switch (field2->cpp_type()) {
-#define SET_ONEOF_VALUE1(CPPTYPE, TYPE) \
- case FieldDescriptor::CPPTYPE_##CPPTYPE: \
- SetField<TYPE>(message1, field2, GetField<TYPE>(*message2, field2)); \
- break;
+#define SET_ONEOF_VALUE1(CPPTYPE, TYPE) \
+ case FieldDescriptor::CPPTYPE_##CPPTYPE: \
+ SetField<TYPE>(message1, field2, GetField<TYPE>(*message2, field2)); \
+ break;
- SET_ONEOF_VALUE1(INT32 , int32 );
- SET_ONEOF_VALUE1(INT64 , int64 );
+ SET_ONEOF_VALUE1(INT32, int32);
+ SET_ONEOF_VALUE1(INT64, int64);
SET_ONEOF_VALUE1(UINT32, uint32);
SET_ONEOF_VALUE1(UINT64, uint64);
- SET_ONEOF_VALUE1(FLOAT , float );
+ SET_ONEOF_VALUE1(FLOAT, float);
SET_ONEOF_VALUE1(DOUBLE, double);
- SET_ONEOF_VALUE1(BOOL , bool );
- SET_ONEOF_VALUE1(ENUM , int );
+ SET_ONEOF_VALUE1(BOOL, bool);
+ SET_ONEOF_VALUE1(ENUM, int);
#undef SET_ONEOF_VALUE1
case FieldDescriptor::CPPTYPE_MESSAGE:
- SetAllocatedMessage(message1,
- ReleaseMessage(message2, field2),
- field2);
+ SetAllocatedMessage(message1, ReleaseMessage(message2, field2), field2);
break;
case FieldDescriptor::CPPTYPE_STRING:
@@ -549,19 +552,19 @@
// Sets message2's oneof field from the temp variable.
if (oneof_case1 > 0) {
switch (field1->cpp_type()) {
-#define SET_ONEOF_VALUE2(CPPTYPE, TYPE) \
- case FieldDescriptor::CPPTYPE_##CPPTYPE: \
- SetField<TYPE>(message2, field1, temp_##TYPE); \
- break;
+#define SET_ONEOF_VALUE2(CPPTYPE, TYPE) \
+ case FieldDescriptor::CPPTYPE_##CPPTYPE: \
+ SetField<TYPE>(message2, field1, temp_##TYPE); \
+ break;
- SET_ONEOF_VALUE2(INT32 , int32 );
- SET_ONEOF_VALUE2(INT64 , int64 );
+ SET_ONEOF_VALUE2(INT32, int32);
+ SET_ONEOF_VALUE2(INT64, int64);
SET_ONEOF_VALUE2(UINT32, uint32);
SET_ONEOF_VALUE2(UINT64, uint64);
- SET_ONEOF_VALUE2(FLOAT , float );
+ SET_ONEOF_VALUE2(FLOAT, float);
SET_ONEOF_VALUE2(DOUBLE, double);
- SET_ONEOF_VALUE2(BOOL , bool );
- SET_ONEOF_VALUE2(ENUM , int );
+ SET_ONEOF_VALUE2(BOOL, bool);
+ SET_ONEOF_VALUE2(ENUM, int);
#undef SET_ONEOF_VALUE2
case FieldDescriptor::CPPTYPE_MESSAGE:
SetAllocatedMessage(message2, temp_message, field1);
@@ -579,26 +582,27 @@
}
}
-void GeneratedMessageReflection::Swap(
- Message* message1,
- Message* message2) const {
+void GeneratedMessageReflection::Swap(Message* message1,
+ Message* message2) const {
if (message1 == message2) return;
// TODO(kenton): Other Reflection methods should probably check this too.
GOOGLE_CHECK_EQ(message1->GetReflection(), this)
- << "First argument to Swap() (of type \""
- << message1->GetDescriptor()->full_name()
- << "\") is not compatible with this reflection object (which is for type \""
- << descriptor_->full_name()
- << "\"). Note that the exact same class is required; not just the same "
- "descriptor.";
+ << "First argument to Swap() (of type \""
+ << message1->GetDescriptor()->full_name()
+ << "\") is not compatible with this reflection object (which is for type "
+ "\""
+ << descriptor_->full_name()
+ << "\"). Note that the exact same class is required; not just the same "
+ "descriptor.";
GOOGLE_CHECK_EQ(message2->GetReflection(), this)
- << "Second argument to Swap() (of type \""
- << message2->GetDescriptor()->full_name()
- << "\") is not compatible with this reflection object (which is for type \""
- << descriptor_->full_name()
- << "\"). Note that the exact same class is required; not just the same "
- "descriptor.";
+ << "Second argument to Swap() (of type \""
+ << message2->GetDescriptor()->full_name()
+ << "\") is not compatible with this reflection object (which is for type "
+ "\""
+ << descriptor_->full_name()
+ << "\"). Note that the exact same class is required; not just the same "
+ "descriptor.";
// Check that both messages are in the same arena (or both on the heap). We
// need to copy all data if not, due to ownership semantics.
@@ -653,26 +657,27 @@
}
void GeneratedMessageReflection::SwapFields(
- Message* message1,
- Message* message2,
+ Message* message1, Message* message2,
const std::vector<const FieldDescriptor*>& fields) const {
if (message1 == message2) return;
// TODO(kenton): Other Reflection methods should probably check this too.
GOOGLE_CHECK_EQ(message1->GetReflection(), this)
- << "First argument to SwapFields() (of type \""
- << message1->GetDescriptor()->full_name()
- << "\") is not compatible with this reflection object (which is for type \""
- << descriptor_->full_name()
- << "\"). Note that the exact same class is required; not just the same "
- "descriptor.";
+ << "First argument to SwapFields() (of type \""
+ << message1->GetDescriptor()->full_name()
+ << "\") is not compatible with this reflection object (which is for type "
+ "\""
+ << descriptor_->full_name()
+ << "\"). Note that the exact same class is required; not just the same "
+ "descriptor.";
GOOGLE_CHECK_EQ(message2->GetReflection(), this)
- << "Second argument to SwapFields() (of type \""
- << message2->GetDescriptor()->full_name()
- << "\") is not compatible with this reflection object (which is for type \""
- << descriptor_->full_name()
- << "\"). Note that the exact same class is required; not just the same "
- "descriptor.";
+ << "Second argument to SwapFields() (of type \""
+ << message2->GetDescriptor()->full_name()
+ << "\") is not compatible with this reflection object (which is for type "
+ "\""
+ << descriptor_->full_name()
+ << "\"). Note that the exact same class is required; not just the same "
+ "descriptor.";
std::set<int> swapped_oneof;
@@ -681,8 +686,7 @@
const FieldDescriptor* field = fields[i];
if (field->is_extension()) {
MutableExtensionSet(message1)->SwapExtension(
- MutableExtensionSet(message2),
- field->number());
+ MutableExtensionSet(message2), field->number());
} else {
if (field->containing_oneof()) {
int oneof_index = field->containing_oneof()->index();
@@ -732,18 +736,18 @@
return GetExtensionSet(message).ExtensionSize(field->number());
} else {
switch (field->cpp_type()) {
-#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
- case FieldDescriptor::CPPTYPE_##UPPERCASE : \
- return GetRaw<RepeatedField<LOWERCASE> >(message, field).size()
+#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
+ case FieldDescriptor::CPPTYPE_##UPPERCASE: \
+ return GetRaw<RepeatedField<LOWERCASE> >(message, field).size()
- HANDLE_TYPE( INT32, int32);
- HANDLE_TYPE( INT64, int64);
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
HANDLE_TYPE(UINT32, uint32);
HANDLE_TYPE(UINT64, uint64);
HANDLE_TYPE(DOUBLE, double);
- HANDLE_TYPE( FLOAT, float);
- HANDLE_TYPE( BOOL, bool);
- HANDLE_TYPE( ENUM, int);
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(BOOL, bool);
+ HANDLE_TYPE(ENUM, int);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_STRING:
@@ -784,24 +788,23 @@
// We need to set the field back to its default value.
switch (field->cpp_type()) {
-#define CLEAR_TYPE(CPPTYPE, TYPE) \
- case FieldDescriptor::CPPTYPE_##CPPTYPE: \
- *MutableRaw<TYPE>(message, field) = \
- field->default_value_##TYPE(); \
- break;
+#define CLEAR_TYPE(CPPTYPE, TYPE) \
+ case FieldDescriptor::CPPTYPE_##CPPTYPE: \
+ *MutableRaw<TYPE>(message, field) = field->default_value_##TYPE(); \
+ break;
- CLEAR_TYPE(INT32 , int32 );
- CLEAR_TYPE(INT64 , int64 );
+ CLEAR_TYPE(INT32, int32);
+ CLEAR_TYPE(INT64, int64);
CLEAR_TYPE(UINT32, uint32);
CLEAR_TYPE(UINT64, uint64);
- CLEAR_TYPE(FLOAT , float );
+ CLEAR_TYPE(FLOAT, float);
CLEAR_TYPE(DOUBLE, double);
- CLEAR_TYPE(BOOL , bool );
+ CLEAR_TYPE(BOOL, bool);
#undef CLEAR_TYPE
case FieldDescriptor::CPPTYPE_ENUM:
*MutableRaw<int>(message, field) =
- field->default_value_enum()->number();
+ field->default_value_enum()->number();
break;
case FieldDescriptor::CPPTYPE_STRING: {
@@ -811,15 +814,15 @@
if (IsInlined(field)) {
const std::string* default_ptr =
&DefaultRaw<InlinedStringField>(field).GetNoArena();
- MutableRaw<InlinedStringField>(message, field)->SetNoArena(
- default_ptr, *default_ptr);
+ MutableRaw<InlinedStringField>(message, field)
+ ->SetNoArena(default_ptr, *default_ptr);
break;
}
const std::string* default_ptr =
&DefaultRaw<ArenaStringPtr>(field).Get();
- MutableRaw<ArenaStringPtr>(message, field)->SetAllocated(
- default_ptr, NULL, GetArena(message));
+ MutableRaw<ArenaStringPtr>(message, field)
+ ->SetAllocated(default_ptr, NULL, GetArena(message));
break;
}
}
@@ -842,19 +845,19 @@
}
} else {
switch (field->cpp_type()) {
-#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
- case FieldDescriptor::CPPTYPE_##UPPERCASE : \
- MutableRaw<RepeatedField<LOWERCASE> >(message, field)->Clear(); \
- break
+#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
+ case FieldDescriptor::CPPTYPE_##UPPERCASE: \
+ MutableRaw<RepeatedField<LOWERCASE> >(message, field)->Clear(); \
+ break
- HANDLE_TYPE( INT32, int32);
- HANDLE_TYPE( INT64, int64);
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
HANDLE_TYPE(UINT32, uint32);
HANDLE_TYPE(UINT64, uint64);
HANDLE_TYPE(DOUBLE, double);
- HANDLE_TYPE( FLOAT, float);
- HANDLE_TYPE( BOOL, bool);
- HANDLE_TYPE( ENUM, int);
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(BOOL, bool);
+ HANDLE_TYPE(ENUM, int);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_STRING: {
@@ -883,8 +886,7 @@
}
void GeneratedMessageReflection::RemoveLast(
- Message* message,
- const FieldDescriptor* field) const {
+ Message* message, const FieldDescriptor* field) const {
USAGE_CHECK_MESSAGE_TYPE(RemoveLast);
USAGE_CHECK_REPEATED(RemoveLast);
@@ -892,19 +894,19 @@
MutableExtensionSet(message)->RemoveLast(field->number());
} else {
switch (field->cpp_type()) {
-#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
- case FieldDescriptor::CPPTYPE_##UPPERCASE : \
- MutableRaw<RepeatedField<LOWERCASE> >(message, field)->RemoveLast(); \
- break
+#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
+ case FieldDescriptor::CPPTYPE_##UPPERCASE: \
+ MutableRaw<RepeatedField<LOWERCASE> >(message, field)->RemoveLast(); \
+ break
- HANDLE_TYPE( INT32, int32);
- HANDLE_TYPE( INT64, int64);
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
HANDLE_TYPE(UINT32, uint32);
HANDLE_TYPE(UINT64, uint64);
HANDLE_TYPE(DOUBLE, double);
- HANDLE_TYPE( FLOAT, float);
- HANDLE_TYPE( BOOL, bool);
- HANDLE_TYPE( ENUM, int);
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(BOOL, bool);
+ HANDLE_TYPE(ENUM, int);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_STRING:
@@ -924,7 +926,7 @@
->RemoveLast<GenericTypeHandler<Message> >();
} else {
MutableRaw<RepeatedPtrFieldBase>(message, field)
- ->RemoveLast<GenericTypeHandler<Message> >();
+ ->RemoveLast<GenericTypeHandler<Message> >();
}
break;
}
@@ -932,8 +934,7 @@
}
Message* GeneratedMessageReflection::ReleaseLast(
- Message* message,
- const FieldDescriptor* field) const {
+ Message* message, const FieldDescriptor* field) const {
USAGE_CHECK_ALL(ReleaseLast, REPEATED, MESSAGE);
if (field->is_extension()) {
@@ -946,16 +947,14 @@
->ReleaseLast<GenericTypeHandler<Message> >();
} else {
return MutableRaw<RepeatedPtrFieldBase>(message, field)
- ->ReleaseLast<GenericTypeHandler<Message> >();
+ ->ReleaseLast<GenericTypeHandler<Message> >();
}
}
}
-void GeneratedMessageReflection::SwapElements(
- Message* message,
- const FieldDescriptor* field,
- int index1,
- int index2) const {
+void GeneratedMessageReflection::SwapElements(Message* message,
+ const FieldDescriptor* field,
+ int index1, int index2) const {
USAGE_CHECK_MESSAGE_TYPE(Swap);
USAGE_CHECK_REPEATED(Swap);
@@ -963,20 +962,20 @@
MutableExtensionSet(message)->SwapElements(field->number(), index1, index2);
} else {
switch (field->cpp_type()) {
-#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
- case FieldDescriptor::CPPTYPE_##UPPERCASE : \
- MutableRaw<RepeatedField<LOWERCASE> >(message, field) \
- ->SwapElements(index1, index2); \
- break
+#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
+ case FieldDescriptor::CPPTYPE_##UPPERCASE: \
+ MutableRaw<RepeatedField<LOWERCASE> >(message, field) \
+ ->SwapElements(index1, index2); \
+ break
- HANDLE_TYPE( INT32, int32);
- HANDLE_TYPE( INT64, int64);
+ HANDLE_TYPE(INT32, int32);
+ HANDLE_TYPE(INT64, int64);
HANDLE_TYPE(UINT32, uint32);
HANDLE_TYPE(UINT64, uint64);
HANDLE_TYPE(DOUBLE, double);
- HANDLE_TYPE( FLOAT, float);
- HANDLE_TYPE( BOOL, bool);
- HANDLE_TYPE( ENUM, int);
+ HANDLE_TYPE(FLOAT, float);
+ HANDLE_TYPE(BOOL, bool);
+ HANDLE_TYPE(ENUM, int);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_STRING:
@@ -987,7 +986,7 @@
->SwapElements(index1, index2);
} else {
MutableRaw<RepeatedPtrFieldBase>(message, field)
- ->SwapElements(index1, index2);
+ ->SwapElements(index1, index2);
}
break;
}
@@ -1003,8 +1002,8 @@
}
};
-inline bool IsIndexInHasBitSet(
- const uint32* has_bit_set, uint32 has_bit_index) {
+inline bool IsIndexInHasBitSet(const uint32* has_bit_set,
+ uint32 has_bit_index) {
GOOGLE_DCHECK_NE(has_bit_index, ~0u);
return ((has_bit_set[has_bit_index / 32] >> (has_bit_index % 32)) &
static_cast<uint32>(1)) != 0;
@@ -1012,8 +1011,7 @@
} // namespace
void GeneratedMessageReflection::ListFields(
- const Message& message,
- std::vector<const FieldDescriptor*>* output) const {
+ const Message& message, std::vector<const FieldDescriptor*>* output) const {
output->clear();
// Optimization: The default instance never has any fields set.
@@ -1065,74 +1063,71 @@
// -------------------------------------------------------------------
#undef DEFINE_PRIMITIVE_ACCESSORS
-#define DEFINE_PRIMITIVE_ACCESSORS(TYPENAME, TYPE, PASSTYPE, CPPTYPE) \
- PASSTYPE GeneratedMessageReflection::Get##TYPENAME( \
- const Message& message, const FieldDescriptor* field) const { \
- USAGE_CHECK_ALL(Get##TYPENAME, SINGULAR, CPPTYPE); \
- if (field->is_extension()) { \
- return GetExtensionSet(message).Get##TYPENAME( \
- field->number(), field->default_value_##PASSTYPE()); \
- } else { \
- return GetField<TYPE>(message, field); \
- } \
- } \
- \
- void GeneratedMessageReflection::Set##TYPENAME( \
- Message* message, const FieldDescriptor* field, \
- PASSTYPE value) const { \
- USAGE_CHECK_ALL(Set##TYPENAME, SINGULAR, CPPTYPE); \
- if (field->is_extension()) { \
- return MutableExtensionSet(message)->Set##TYPENAME( \
- field->number(), field->type(), value, field); \
- } else { \
- SetField<TYPE>(message, field, value); \
- } \
- } \
- \
- PASSTYPE GeneratedMessageReflection::GetRepeated##TYPENAME( \
- const Message& message, \
- const FieldDescriptor* field, int index) const { \
- USAGE_CHECK_ALL(GetRepeated##TYPENAME, REPEATED, CPPTYPE); \
- if (field->is_extension()) { \
- return GetExtensionSet(message).GetRepeated##TYPENAME( \
- field->number(), index); \
- } else { \
- return GetRepeatedField<TYPE>(message, field, index); \
- } \
- } \
- \
- void GeneratedMessageReflection::SetRepeated##TYPENAME( \
- Message* message, const FieldDescriptor* field, \
- int index, PASSTYPE value) const { \
- USAGE_CHECK_ALL(SetRepeated##TYPENAME, REPEATED, CPPTYPE); \
- if (field->is_extension()) { \
- MutableExtensionSet(message)->SetRepeated##TYPENAME( \
- field->number(), index, value); \
- } else { \
- SetRepeatedField<TYPE>(message, field, index, value); \
- } \
- } \
- \
- void GeneratedMessageReflection::Add##TYPENAME( \
- Message* message, const FieldDescriptor* field, \
- PASSTYPE value) const { \
- USAGE_CHECK_ALL(Add##TYPENAME, REPEATED, CPPTYPE); \
- if (field->is_extension()) { \
- MutableExtensionSet(message)->Add##TYPENAME( \
- field->number(), field->type(), field->options().packed(), value, \
- field); \
- } else { \
- AddField<TYPE>(message, field, value); \
- } \
+#define DEFINE_PRIMITIVE_ACCESSORS(TYPENAME, TYPE, PASSTYPE, CPPTYPE) \
+ PASSTYPE GeneratedMessageReflection::Get##TYPENAME( \
+ const Message& message, const FieldDescriptor* field) const { \
+ USAGE_CHECK_ALL(Get##TYPENAME, SINGULAR, CPPTYPE); \
+ if (field->is_extension()) { \
+ return GetExtensionSet(message).Get##TYPENAME( \
+ field->number(), field->default_value_##PASSTYPE()); \
+ } else { \
+ return GetField<TYPE>(message, field); \
+ } \
+ } \
+ \
+ void GeneratedMessageReflection::Set##TYPENAME( \
+ Message* message, const FieldDescriptor* field, PASSTYPE value) const { \
+ USAGE_CHECK_ALL(Set##TYPENAME, SINGULAR, CPPTYPE); \
+ if (field->is_extension()) { \
+ return MutableExtensionSet(message)->Set##TYPENAME( \
+ field->number(), field->type(), value, field); \
+ } else { \
+ SetField<TYPE>(message, field, value); \
+ } \
+ } \
+ \
+ PASSTYPE GeneratedMessageReflection::GetRepeated##TYPENAME( \
+ const Message& message, const FieldDescriptor* field, int index) const { \
+ USAGE_CHECK_ALL(GetRepeated##TYPENAME, REPEATED, CPPTYPE); \
+ if (field->is_extension()) { \
+ return GetExtensionSet(message).GetRepeated##TYPENAME(field->number(), \
+ index); \
+ } else { \
+ return GetRepeatedField<TYPE>(message, field, index); \
+ } \
+ } \
+ \
+ void GeneratedMessageReflection::SetRepeated##TYPENAME( \
+ Message* message, const FieldDescriptor* field, int index, \
+ PASSTYPE value) const { \
+ USAGE_CHECK_ALL(SetRepeated##TYPENAME, REPEATED, CPPTYPE); \
+ if (field->is_extension()) { \
+ MutableExtensionSet(message)->SetRepeated##TYPENAME(field->number(), \
+ index, value); \
+ } else { \
+ SetRepeatedField<TYPE>(message, field, index, value); \
+ } \
+ } \
+ \
+ void GeneratedMessageReflection::Add##TYPENAME( \
+ Message* message, const FieldDescriptor* field, PASSTYPE value) const { \
+ USAGE_CHECK_ALL(Add##TYPENAME, REPEATED, CPPTYPE); \
+ if (field->is_extension()) { \
+ MutableExtensionSet(message)->Add##TYPENAME( \
+ field->number(), field->type(), field->options().packed(), value, \
+ field); \
+ } else { \
+ AddField<TYPE>(message, field, value); \
+ } \
}
-DEFINE_PRIMITIVE_ACCESSORS(Int32 , int32 , int32 , INT32 )
-DEFINE_PRIMITIVE_ACCESSORS(Int64 , int64 , int64 , INT64 )
+DEFINE_PRIMITIVE_ACCESSORS(Int32, int32, int32, INT32)
+DEFINE_PRIMITIVE_ACCESSORS(Int64, int64, int64, INT64)
DEFINE_PRIMITIVE_ACCESSORS(UInt32, uint32, uint32, UINT32)
DEFINE_PRIMITIVE_ACCESSORS(UInt64, uint64, uint64, UINT64)
-DEFINE_PRIMITIVE_ACCESSORS(Float , float , float , FLOAT )
+DEFINE_PRIMITIVE_ACCESSORS(Float, float, float, FLOAT)
DEFINE_PRIMITIVE_ACCESSORS(Double, double, double, DOUBLE)
-DEFINE_PRIMITIVE_ACCESSORS(Bool , bool , bool , BOOL )
+DEFINE_PRIMITIVE_ACCESSORS(Bool, bool, bool, BOOL)
#undef DEFINE_PRIMITIVE_ACCESSORS
// -------------------------------------------------------------------
@@ -1191,8 +1186,8 @@
default: // TODO(kenton): Support other string reps.
case FieldOptions::STRING: {
if (IsInlined(field)) {
- MutableField<InlinedStringField>(message, field)->SetNoArena(
- NULL, value);
+ MutableField<InlinedStringField>(message, field)
+ ->SetNoArena(NULL, value);
break;
}
@@ -1200,8 +1195,8 @@
&DefaultRaw<ArenaStringPtr>(field).Get();
if (field->containing_oneof() && !HasOneofField(*message, field)) {
ClearOneof(message, field->containing_oneof());
- MutableField<ArenaStringPtr>(message, field)->UnsafeSetDefault(
- default_ptr);
+ MutableField<ArenaStringPtr>(message, field)
+ ->UnsafeSetDefault(default_ptr);
}
MutableField<ArenaStringPtr>(message, field)
->Mutable(default_ptr, GetArena(message))
@@ -1248,8 +1243,8 @@
const std::string& value) const {
USAGE_CHECK_ALL(SetRepeatedString, REPEATED, STRING);
if (field->is_extension()) {
- MutableExtensionSet(message)->SetRepeatedString(
- field->number(), index, value);
+ MutableExtensionSet(message)->SetRepeatedString(field->number(), index,
+ value);
} else {
switch (field->options().ctype()) {
default: // TODO(kenton): Support other string reps.
@@ -1266,8 +1261,8 @@
const std::string& value) const {
USAGE_CHECK_ALL(AddString, REPEATED, STRING);
if (field->is_extension()) {
- MutableExtensionSet(message)->AddString(field->number(),
- field->type(), value, field);
+ MutableExtensionSet(message)->AddString(field->number(), field->type(),
+ value, field);
} else {
switch (field->options().ctype()) {
default: // TODO(kenton): Support other string reps.
@@ -1299,7 +1294,7 @@
int32 value;
if (field->is_extension()) {
value = GetExtensionSet(message).GetEnum(
- field->number(), field->default_value_enum()->number());
+ field->number(), field->default_value_enum()->number());
} else {
value = GetField<int>(message, field);
}
@@ -1314,9 +1309,9 @@
SetEnumValueInternal(message, field, value->number());
}
-void GeneratedMessageReflection::SetEnumValue(
- Message* message, const FieldDescriptor* field,
- int value) const {
+void GeneratedMessageReflection::SetEnumValue(Message* message,
+ const FieldDescriptor* field,
+ int value) const {
USAGE_CHECK_ALL(SetEnumValue, SINGULAR, ENUM);
if (!CreateUnknownEnumValues(descriptor_->file())) {
// Check that the value is valid if we don't support direct storage of
@@ -1332,11 +1327,10 @@
}
void GeneratedMessageReflection::SetEnumValueInternal(
- Message* message, const FieldDescriptor* field,
- int value) const {
+ Message* message, const FieldDescriptor* field, int value) const {
if (field->is_extension()) {
- MutableExtensionSet(message)->SetEnum(field->number(), field->type(),
- value, field);
+ MutableExtensionSet(message)->SetEnum(field->number(), field->type(), value,
+ field);
} else {
SetField<int>(message, field, value);
}
@@ -1363,8 +1357,7 @@
}
void GeneratedMessageReflection::SetRepeatedEnum(
- Message* message,
- const FieldDescriptor* field, int index,
+ Message* message, const FieldDescriptor* field, int index,
const EnumValueDescriptor* value) const {
// Usage checked by SetRepeatedEnumValue.
USAGE_CHECK_ENUM_VALUE(SetRepeatedEnum);
@@ -1372,8 +1365,7 @@
}
void GeneratedMessageReflection::SetRepeatedEnumValue(
- Message* message,
- const FieldDescriptor* field, int index,
+ Message* message, const FieldDescriptor* field, int index,
int value) const {
USAGE_CHECK_ALL(SetRepeatedEnum, REPEATED, ENUM);
if (!CreateUnknownEnumValues(descriptor_->file())) {
@@ -1390,12 +1382,11 @@
}
void GeneratedMessageReflection::SetRepeatedEnumValueInternal(
- Message* message,
- const FieldDescriptor* field, int index,
+ Message* message, const FieldDescriptor* field, int index,
int value) const {
if (field->is_extension()) {
- MutableExtensionSet(message)->SetRepeatedEnum(
- field->number(), index, value);
+ MutableExtensionSet(message)->SetRepeatedEnum(field->number(), index,
+ value);
} else {
SetRepeatedField<int>(message, field, index, value);
}
@@ -1409,9 +1400,9 @@
AddEnumValueInternal(message, field, value->number());
}
-void GeneratedMessageReflection::AddEnumValue(
- Message* message, const FieldDescriptor* field,
- int value) const {
+void GeneratedMessageReflection::AddEnumValue(Message* message,
+ const FieldDescriptor* field,
+ int value) const {
USAGE_CHECK_ALL(AddEnum, REPEATED, ENUM);
if (!CreateUnknownEnumValues(descriptor_->file())) {
// Check that the value is valid if we don't support direct storage of
@@ -1427,12 +1418,11 @@
}
void GeneratedMessageReflection::AddEnumValueInternal(
- Message* message, const FieldDescriptor* field,
- int value) const {
+ Message* message, const FieldDescriptor* field, int value) const {
if (field->is_extension()) {
MutableExtensionSet(message)->AddEnum(field->number(), field->type(),
- field->options().packed(),
- value, field);
+ field->options().packed(), value,
+ field);
} else {
AddField<int>(message, field, value);
}
@@ -1448,9 +1438,8 @@
if (factory == NULL) factory = message_factory_;
if (field->is_extension()) {
- return static_cast<const Message&>(
- GetExtensionSet(message).GetMessage(
- field->number(), field->message_type(), factory));
+ return static_cast<const Message&>(GetExtensionSet(message).GetMessage(
+ field->number(), field->message_type(), factory));
} else {
const Message* result = GetRaw<const Message*>(message, field);
if (result == NULL) {
@@ -1496,8 +1485,7 @@
}
void GeneratedMessageReflection::UnsafeArenaSetAllocatedMessage(
- Message* message,
- Message* sub_message,
+ Message* message, Message* sub_message,
const FieldDescriptor* field) const {
USAGE_CHECK_ALL(SetAllocatedMessage, SINGULAR, MESSAGE);
@@ -1530,14 +1518,12 @@
}
void GeneratedMessageReflection::SetAllocatedMessage(
- Message* message,
- Message* sub_message,
+ Message* message, Message* sub_message,
const FieldDescriptor* field) const {
// If message and sub-message are in different memory ownership domains
// (different arenas, or one is on heap and one is not), then we may need to
// do a copy.
- if (sub_message != NULL &&
- sub_message->GetArena() != message->GetArena()) {
+ if (sub_message != NULL && sub_message->GetArena() != message->GetArena()) {
if (sub_message->GetArena() == NULL && message->GetArena() != NULL) {
// Case 1: parent is on an arena and child is heap-allocated. We can add
// the child to the arena's Own() list to free on arena destruction, then
@@ -1558,8 +1544,7 @@
}
Message* GeneratedMessageReflection::UnsafeArenaReleaseMessage(
- Message* message,
- const FieldDescriptor* field,
+ Message* message, const FieldDescriptor* field,
MessageFactory* factory) const {
USAGE_CHECK_ALL(ReleaseMessage, SINGULAR, MESSAGE);
@@ -1588,8 +1573,7 @@
}
Message* GeneratedMessageReflection::ReleaseMessage(
- Message* message,
- const FieldDescriptor* field,
+ Message* message, const FieldDescriptor* field,
MessageFactory* factory) const {
Message* released = UnsafeArenaReleaseMessage(message, field, factory);
if (GetArena(message) != NULL && released != NULL) {
@@ -1625,8 +1609,8 @@
if (field->is_extension()) {
return static_cast<Message*>(
- MutableExtensionSet(message)->MutableRepeatedMessage(
- field->number(), index));
+ MutableExtensionSet(message)->MutableRepeatedMessage(field->number(),
+ index));
} else {
if (IsMapFieldInApi(field)) {
return MutableRaw<MapFieldBase>(message, field)
@@ -1634,14 +1618,14 @@
->Mutable<GenericTypeHandler<Message> >(index);
} else {
return MutableRaw<RepeatedPtrFieldBase>(message, field)
- ->Mutable<GenericTypeHandler<Message> >(index);
+ ->Mutable<GenericTypeHandler<Message> >(index);
}
}
}
-Message* GeneratedMessageReflection::AddMessage(
- Message* message, const FieldDescriptor* field,
- MessageFactory* factory) const {
+Message* GeneratedMessageReflection::AddMessage(Message* message,
+ const FieldDescriptor* field,
+ MessageFactory* factory) const {
USAGE_CHECK_ALL(AddMessage, REPEATED, MESSAGE);
if (factory == NULL) factory = message_factory_;
@@ -1682,8 +1666,7 @@
}
void GeneratedMessageReflection::AddAllocatedMessage(
- Message* message, const FieldDescriptor* field,
- Message* new_entry) const {
+ Message* message, const FieldDescriptor* field, Message* new_entry) const {
USAGE_CHECK_ALL(AddAllocatedMessage, REPEATED, MESSAGE);
if (field->is_extension()) {
@@ -1702,12 +1685,11 @@
void* GeneratedMessageReflection::MutableRawRepeatedField(
Message* message, const FieldDescriptor* field,
- FieldDescriptor::CppType cpptype,
- int ctype, const Descriptor* desc) const {
+ FieldDescriptor::CppType cpptype, int ctype, const Descriptor* desc) const {
USAGE_CHECK_REPEATED("MutableRawRepeatedField");
if (field->cpp_type() != cpptype)
- ReportReflectionUsageTypeError(descriptor_,
- field, "MutableRawRepeatedField", cpptype);
+ ReportReflectionUsageTypeError(descriptor_, field,
+ "MutableRawRepeatedField", cpptype);
if (desc != NULL)
GOOGLE_CHECK_EQ(field->message_type(), desc) << "wrong submessage type";
if (field->is_extension()) {
@@ -1725,12 +1707,11 @@
const void* GeneratedMessageReflection::GetRawRepeatedField(
const Message& message, const FieldDescriptor* field,
- FieldDescriptor::CppType cpptype,
- int ctype, const Descriptor* desc) const {
+ FieldDescriptor::CppType cpptype, int ctype, const Descriptor* desc) const {
USAGE_CHECK_REPEATED("GetRawRepeatedField");
if (field->cpp_type() != cpptype)
- ReportReflectionUsageTypeError(descriptor_,
- field, "GetRawRepeatedField", cpptype);
+ ReportReflectionUsageTypeError(descriptor_, field, "GetRawRepeatedField",
+ cpptype);
if (ctype >= 0)
GOOGLE_CHECK_EQ(field->options().ctype(), ctype) << "subtype mismatch";
if (desc != NULL)
@@ -1741,8 +1722,8 @@
// Map is not supported in extensions, it is acceptable to use
// extension_set::MutableRawRepeatedField which does not change the message.
return MutableExtensionSet(const_cast<Message*>(&message))
- ->MutableRawRepeatedField(
- field->number(), field->type(), field->is_packed(), field);
+ ->MutableRawRepeatedField(field->number(), field->type(),
+ field->is_packed(), field);
} else {
// Trigger transform for MapField
if (IsMapFieldInApi(field)) {
@@ -1753,8 +1734,7 @@
}
const FieldDescriptor* GeneratedMessageReflection::GetOneofFieldDescriptor(
- const Message& message,
- const OneofDescriptor* oneof_descriptor) const {
+ const Message& message, const OneofDescriptor* oneof_descriptor) const {
uint32 field_number = GetOneofCase(message, oneof_descriptor);
if (field_number == 0) {
return NULL;
@@ -1762,67 +1742,51 @@
return descriptor_->FindFieldByNumber(field_number);
}
-bool GeneratedMessageReflection::ContainsMapKey(
- const Message& message,
- const FieldDescriptor* field,
- const MapKey& key) const {
- USAGE_CHECK(IsMapFieldInApi(field),
- "LookupMapValue",
+bool GeneratedMessageReflection::ContainsMapKey(const Message& message,
+ const FieldDescriptor* field,
+ const MapKey& key) const {
+ USAGE_CHECK(IsMapFieldInApi(field), "LookupMapValue",
"Field is not a map field.");
return GetRaw<MapFieldBase>(message, field).ContainsMapKey(key);
}
bool GeneratedMessageReflection::InsertOrLookupMapValue(
- Message* message,
- const FieldDescriptor* field,
- const MapKey& key,
+ Message* message, const FieldDescriptor* field, const MapKey& key,
MapValueRef* val) const {
- USAGE_CHECK(IsMapFieldInApi(field),
- "InsertOrLookupMapValue",
+ USAGE_CHECK(IsMapFieldInApi(field), "InsertOrLookupMapValue",
"Field is not a map field.");
val->SetType(field->message_type()->FindFieldByName("value")->cpp_type());
- return MutableRaw<MapFieldBase>(message, field)->InsertOrLookupMapValue(
- key, val);
+ return MutableRaw<MapFieldBase>(message, field)
+ ->InsertOrLookupMapValue(key, val);
}
-bool GeneratedMessageReflection::DeleteMapValue(
- Message* message,
- const FieldDescriptor* field,
- const MapKey& key) const {
- USAGE_CHECK(IsMapFieldInApi(field),
- "DeleteMapValue",
+bool GeneratedMessageReflection::DeleteMapValue(Message* message,
+ const FieldDescriptor* field,
+ const MapKey& key) const {
+ USAGE_CHECK(IsMapFieldInApi(field), "DeleteMapValue",
"Field is not a map field.");
return MutableRaw<MapFieldBase>(message, field)->DeleteMapValue(key);
}
MapIterator GeneratedMessageReflection::MapBegin(
- Message* message,
- const FieldDescriptor* field) const {
- USAGE_CHECK(IsMapFieldInApi(field),
- "MapBegin",
- "Field is not a map field.");
+ Message* message, const FieldDescriptor* field) const {
+ USAGE_CHECK(IsMapFieldInApi(field), "MapBegin", "Field is not a map field.");
MapIterator iter(message, field);
GetRaw<MapFieldBase>(*message, field).MapBegin(&iter);
return iter;
}
MapIterator GeneratedMessageReflection::MapEnd(
- Message* message,
- const FieldDescriptor* field) const {
- USAGE_CHECK(IsMapFieldInApi(field),
- "MapEnd",
- "Field is not a map field.");
+ Message* message, const FieldDescriptor* field) const {
+ USAGE_CHECK(IsMapFieldInApi(field), "MapEnd", "Field is not a map field.");
MapIterator iter(message, field);
GetRaw<MapFieldBase>(*message, field).MapEnd(&iter);
return iter;
}
-int GeneratedMessageReflection::MapSize(
- const Message& message,
- const FieldDescriptor* field) const {
- USAGE_CHECK(IsMapFieldInApi(field),
- "MapSize",
- "Field is not a map field.");
+int GeneratedMessageReflection::MapSize(const Message& message,
+ const FieldDescriptor* field) const {
+ USAGE_CHECK(IsMapFieldInApi(field), "MapSize", "Field is not a map field.");
return GetRaw<MapFieldBase>(message, field).size();
}
@@ -1847,8 +1811,7 @@
const FieldDescriptor* extension = type->extension(i);
if (extension->containing_type() == descriptor_ &&
extension->type() == FieldDescriptor::TYPE_MESSAGE &&
- extension->is_optional() &&
- extension->message_type() == type) {
+ extension->is_optional() && extension->message_type() == type) {
// Found it.
return extension;
}
@@ -1903,12 +1866,11 @@
}
template <typename Type>
-Type* GeneratedMessageReflection::MutableRaw(Message* message,
- const FieldDescriptor* field) const {
+Type* GeneratedMessageReflection::MutableRaw(
+ Message* message, const FieldDescriptor* field) const {
return GetPointerAtOffset<Type>(message, schema_.GetFieldOffset(field));
}
-
inline const uint32* GeneratedMessageReflection::GetHasBits(
const Message& message) const {
GOOGLE_DCHECK(schema_.HasHasbits());
@@ -1981,7 +1943,7 @@
// present only if their message-field pointer is non-NULL.
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
return !schema_.IsDefaultInstance(message) &&
- GetRaw<const Message*>(message, field) != NULL;
+ GetRaw<const Message*>(message, field) != NULL;
} else {
// Non-message field (and non-oneof, since that was handled in HasField()
// before calling us), and singular (again, checked in HasField). So, this
@@ -1999,7 +1961,8 @@
default: {
if (IsInlined(field)) {
return !GetField<InlinedStringField>(message, field)
- .GetNoArena().empty();
+ .GetNoArena()
+ .empty();
}
return GetField<ArenaStringPtr>(message, field).Get().size() > 0;
}
@@ -2109,8 +2072,8 @@
case FieldOptions::STRING: {
const std::string* default_ptr =
&DefaultRaw<ArenaStringPtr>(field).Get();
- MutableField<ArenaStringPtr>(message, field)->
- Destroy(default_ptr, GetArena(message));
+ MutableField<ArenaStringPtr>(message, field)
+ ->Destroy(default_ptr, GetArena(message));
break;
}
}
@@ -2139,21 +2102,22 @@
}
template <typename Type>
-inline void GeneratedMessageReflection::SetField(
- Message* message, const FieldDescriptor* field, const Type& value) const {
+inline void GeneratedMessageReflection::SetField(Message* message,
+ const FieldDescriptor* field,
+ const Type& value) const {
if (field->containing_oneof() && !HasOneofField(*message, field)) {
ClearOneof(message, field->containing_oneof());
}
*MutableRaw<Type>(message, field) = value;
- field->containing_oneof() ?
- SetOneofCase(message, field) : SetBit(message, field);
+ field->containing_oneof() ? SetOneofCase(message, field)
+ : SetBit(message, field);
}
template <typename Type>
inline Type* GeneratedMessageReflection::MutableField(
Message* message, const FieldDescriptor* field) const {
- field->containing_oneof() ?
- SetOneofCase(message, field) : SetBit(message, field);
+ field->containing_oneof() ? SetOneofCase(message, field)
+ : SetBit(message, field);
return MutableRaw<Type>(message, field);
}
@@ -2171,8 +2135,8 @@
template <typename Type>
inline void GeneratedMessageReflection::SetRepeatedField(
- Message* message, const FieldDescriptor* field,
- int index, Type value) const {
+ Message* message, const FieldDescriptor* field, int index,
+ Type value) const {
MutableRaw<RepeatedField<Type> >(message, field)->Set(index, value);
}
@@ -2180,13 +2144,14 @@
inline Type* GeneratedMessageReflection::MutableRepeatedField(
Message* message, const FieldDescriptor* field, int index) const {
RepeatedPtrField<Type>* repeated =
- MutableRaw<RepeatedPtrField<Type> >(message, field);
+ MutableRaw<RepeatedPtrField<Type> >(message, field);
return repeated->Mutable(index);
}
template <typename Type>
-inline void GeneratedMessageReflection::AddField(
- Message* message, const FieldDescriptor* field, const Type& value) const {
+inline void GeneratedMessageReflection::AddField(Message* message,
+ const FieldDescriptor* field,
+ const Type& value) const {
MutableRaw<RepeatedField<Type> >(message, field)->Add(value);
}
@@ -2194,7 +2159,7 @@
inline Type* GeneratedMessageReflection::AddField(
Message* message, const FieldDescriptor* field) const {
RepeatedPtrField<Type>* repeated =
- MutableRaw<RepeatedPtrField<Type> >(message, field);
+ MutableRaw<RepeatedPtrField<Type> >(message, field);
return repeated->Add();
}
@@ -2204,8 +2169,7 @@
void* GeneratedMessageReflection::RepeatedFieldData(
Message* message, const FieldDescriptor* field,
- FieldDescriptor::CppType cpp_type,
- const Descriptor* message_type) const {
+ FieldDescriptor::CppType cpp_type, const Descriptor* message_type) const {
GOOGLE_CHECK(field->is_repeated());
GOOGLE_CHECK(field->cpp_type() == cpp_type ||
(field->cpp_type() == FieldDescriptor::CPPTYPE_ENUM &&
@@ -2226,16 +2190,14 @@
MapFieldBase* GeneratedMessageReflection::MutableMapData(
Message* message, const FieldDescriptor* field) const {
- USAGE_CHECK(IsMapFieldInApi(field),
- "GetMapData",
+ USAGE_CHECK(IsMapFieldInApi(field), "GetMapData",
"Field is not a map field.");
return MutableRaw<MapFieldBase>(message, field);
}
const MapFieldBase* GeneratedMessageReflection::GetMapData(
const Message& message, const FieldDescriptor* field) const {
- USAGE_CHECK(IsMapFieldInApi(field),
- "GetMapData",
+ USAGE_CHECK(IsMapFieldInApi(field), "GetMapData",
"Field is not a map field.");
return &(GetRaw<MapFieldBase>(message, field));
}
@@ -2261,7 +2223,7 @@
return result;
}
-template<typename Schema>
+template <typename Schema>
class AssignDescriptorsHelper {
public:
AssignDescriptorsHelper(MessageFactory* factory,
@@ -2309,7 +2271,7 @@
Metadata* file_level_metadata_;
const EnumDescriptor** file_level_enum_descriptors_;
const Schema* schemas_;
- const Message* const * default_instance_data_;
+ const Message* const* default_instance_data_;
const uint32* offsets_;
};
@@ -2382,8 +2344,6 @@
void AddDescriptorsImpl(const DescriptorTable* table, const InitFunc* deps,
int num_deps) {
- // Ensure default instances of this proto file are initialized.
- table->init_defaults();
// Ensure all dependent descriptors are registered to the generated descriptor
// pool and message factory.
for (int i = 0; i < num_deps; i++) {
@@ -2419,7 +2379,7 @@
for (int i = 0; i < size; i++) {
const GeneratedMessageReflection* reflection =
static_cast<const GeneratedMessageReflection*>(
- file_level_metadata[i].reflection);
+ file_level_metadata[i].reflection);
if (reflection) {
// It's not a map type
MessageFactory::InternalRegisterGeneratedMessage(
diff --git a/src/google/protobuf/generated_message_reflection.h b/src/google/protobuf/generated_message_reflection.h
index 17a41bf..820a148 100644
--- a/src/google/protobuf/generated_message_reflection.h
+++ b/src/google/protobuf/generated_message_reflection.h
@@ -83,8 +83,8 @@
class GeneratedMessageReflection;
// Defined in other files.
-class ExtensionSet; // extension_set.h
-class WeakFieldMap; // weak_field_map.h
+class ExtensionSet; // extension_set.h
+class WeakFieldMap; // weak_field_map.h
// This struct describes the internal layout of the message, hence this is
// used to act on the message reflectively.
@@ -146,7 +146,7 @@
if (field->containing_oneof()) {
size_t offset =
static_cast<size_t>(field->containing_type()->field_count() +
- field->containing_oneof()->index());
+ field->containing_oneof()->index());
return OffsetValue(offsets_[offset], field->type());
} else {
return GetFieldOffsetNonOneof(field);
@@ -166,8 +166,8 @@
uint32 GetOneofCaseOffset(const OneofDescriptor* oneof_descriptor) const {
return static_cast<uint32>(oneof_case_offset_) +
- static_cast<uint32>(
- static_cast<size_t>(oneof_descriptor->index()) * sizeof(uint32));
+ static_cast<uint32>(static_cast<size_t>(oneof_descriptor->index()) *
+ sizeof(uint32));
}
bool HasHasbits() const { return has_bits_offset_ != -1; }
@@ -211,7 +211,7 @@
// Returns a pointer to the default value for this field. The size and type
// of the underlying data depends on the field's type.
- const void *GetFieldDefault(const FieldDescriptor* field) const {
+ const void* GetFieldDefault(const FieldDescriptor* field) const {
return reinterpret_cast<const uint8*>(default_instance_) +
OffsetValue(offsets_[field->index()], field->type());
}
@@ -224,7 +224,7 @@
// them, ie.
//
// ReflectionSchema schema = {a, b, c, d, e, ...};
- // private:
+ // private:
const Message* default_instance_;
const uint32* offsets_;
const uint32* has_bit_indices_;
@@ -552,21 +552,18 @@
template <typename Type>
const Type& GetRaw(const Message& message,
- const FieldDescriptor* field) const;
+ const FieldDescriptor* field) const;
template <typename Type>
- inline Type* MutableRaw(Message* message,
- const FieldDescriptor* field) const;
+ inline Type* MutableRaw(Message* message, const FieldDescriptor* field) const;
template <typename Type>
inline const Type& DefaultRaw(const FieldDescriptor* field) const;
inline const uint32* GetHasBits(const Message& message) const;
inline uint32* MutableHasBits(Message* message) const;
- inline uint32 GetOneofCase(
- const Message& message,
- const OneofDescriptor* oneof_descriptor) const;
+ inline uint32 GetOneofCase(const Message& message,
+ const OneofDescriptor* oneof_descriptor) const;
inline uint32* MutableOneofCase(
- Message* message,
- const OneofDescriptor* oneof_descriptor) const;
+ Message* message, const OneofDescriptor* oneof_descriptor) const;
inline const ExtensionSet& GetExtensionSet(const Message& message) const;
inline ExtensionSet* MutableExtensionSet(Message* message) const;
inline Arena* GetArena(Message* message) const;
@@ -574,29 +571,24 @@
inline const InternalMetadataWithArena& GetInternalMetadataWithArena(
const Message& message) const;
- inline InternalMetadataWithArena*
- MutableInternalMetadataWithArena(Message* message) const;
+ inline InternalMetadataWithArena* MutableInternalMetadataWithArena(
+ Message* message) const;
inline bool IsInlined(const FieldDescriptor* field) const;
inline bool HasBit(const Message& message,
const FieldDescriptor* field) const;
- inline void SetBit(Message* message,
- const FieldDescriptor* field) const;
- inline void ClearBit(Message* message,
- const FieldDescriptor* field) const;
- inline void SwapBit(Message* message1,
- Message* message2,
+ inline void SetBit(Message* message, const FieldDescriptor* field) const;
+ inline void ClearBit(Message* message, const FieldDescriptor* field) const;
+ inline void SwapBit(Message* message1, Message* message2,
const FieldDescriptor* field) const;
// This function only swaps the field. Should swap corresponding has_bit
// before or after using this function.
- void SwapField(Message* message1,
- Message* message2,
+ void SwapField(Message* message1, Message* message2,
const FieldDescriptor* field) const;
- void SwapOneofField(Message* message1,
- Message* message2,
+ void SwapOneofField(Message* message1, Message* message2,
const OneofDescriptor* oneof_descriptor) const;
inline bool HasOneofField(const Message& message,
@@ -610,8 +602,8 @@
inline const Type& GetField(const Message& message,
const FieldDescriptor* field) const;
template <typename Type>
- inline void SetField(Message* message,
- const FieldDescriptor* field, const Type& value) const;
+ inline void SetField(Message* message, const FieldDescriptor* field,
+ const Type& value) const;
template <typename Type>
inline Type* MutableField(Message* message,
const FieldDescriptor* field) const;
@@ -624,42 +616,35 @@
const FieldDescriptor* field,
int index) const;
template <typename Type>
- inline void SetRepeatedField(Message* message,
- const FieldDescriptor* field, int index,
- Type value) const;
+ inline void SetRepeatedField(Message* message, const FieldDescriptor* field,
+ int index, Type value) const;
template <typename Type>
inline Type* MutableRepeatedField(Message* message,
const FieldDescriptor* field,
int index) const;
template <typename Type>
- inline void AddField(Message* message,
- const FieldDescriptor* field, const Type& value) const;
+ inline void AddField(Message* message, const FieldDescriptor* field,
+ const Type& value) const;
template <typename Type>
- inline Type* AddField(Message* message,
- const FieldDescriptor* field) const;
+ inline Type* AddField(Message* message, const FieldDescriptor* field) const;
int GetExtensionNumberOrDie(const Descriptor* type) const;
// Internal versions of EnumValue API perform no checking. Called after checks
// by public methods.
- void SetEnumValueInternal(Message* message,
- const FieldDescriptor* field,
+ void SetEnumValueInternal(Message* message, const FieldDescriptor* field,
int value) const;
void SetRepeatedEnumValueInternal(Message* message,
- const FieldDescriptor* field,
- int index,
+ const FieldDescriptor* field, int index,
int value) const;
- void AddEnumValueInternal(Message* message,
- const FieldDescriptor* field,
+ void AddEnumValueInternal(Message* message, const FieldDescriptor* field,
int value) const;
-
Message* UnsafeArenaReleaseMessage(Message* message,
const FieldDescriptor* field,
MessageFactory* factory = NULL) const;
- void UnsafeArenaSetAllocatedMessage(Message* message,
- Message* sub_message,
+ void UnsafeArenaSetAllocatedMessage(Message* message, Message* sub_message,
const FieldDescriptor* field) const;
internal::MapFieldBase* MutableMapData(
@@ -694,7 +679,6 @@
struct PROTOBUF_EXPORT DescriptorTable {
bool is_initialized;
- InitFunc init_defaults;
const char* descriptor;
const char* filename;
AssignDescriptorsTable* assign_descriptors_table;
diff --git a/src/google/protobuf/generated_message_reflection_unittest.cc b/src/google/protobuf/generated_message_reflection_unittest.cc
index 82f5dc1..eea5da5 100644
--- a/src/google/protobuf/generated_message_reflection_unittest.cc
+++ b/src/google/protobuf/generated_message_reflection_unittest.cc
@@ -63,7 +63,7 @@
// Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes.
const FieldDescriptor* F(const std::string& name) {
const FieldDescriptor* result =
- unittest::TestAllTypes::descriptor()->FindFieldByName(name);
+ unittest::TestAllTypes::descriptor()->FindFieldByName(name);
GOOGLE_CHECK(result != NULL);
return result;
}
@@ -72,7 +72,7 @@
// Check that all default values are set correctly in the initial message.
unittest::TestAllTypes message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllTypes::descriptor());
+ unittest::TestAllTypes::descriptor());
reflection_tester.ExpectClearViaReflection(message);
@@ -96,7 +96,7 @@
// values.
unittest::TestAllTypes message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllTypes::descriptor());
+ unittest::TestAllTypes::descriptor());
reflection_tester.SetAllFieldsViaReflection(&message);
TestUtil::ExpectAllFieldsSet(message);
@@ -135,7 +135,7 @@
// embedded message does NOT return the default instance.
unittest::TestAllTypes message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllTypes::descriptor());
+ unittest::TestAllTypes::descriptor());
TestUtil::SetAllFields(&message);
message.Clear();
@@ -152,7 +152,6 @@
&reflection->GetMessage(message, F("optional_import_message")));
}
-
TEST(GeneratedMessageReflectionTest, Swap) {
unittest::TestAllTypes message1;
unittest::TestAllTypes message2;
@@ -321,7 +320,7 @@
TEST(GeneratedMessageReflectionTest, RemoveLast) {
unittest::TestAllTypes message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllTypes::descriptor());
+ unittest::TestAllTypes::descriptor());
TestUtil::SetAllFields(&message);
@@ -333,7 +332,7 @@
TEST(GeneratedMessageReflectionTest, RemoveLastExtensions) {
unittest::TestAllExtensions message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllExtensions::descriptor());
+ unittest::TestAllExtensions::descriptor());
TestUtil::SetAllExtensions(&message);
@@ -378,21 +377,20 @@
// Now test that we actually release the right message.
message.Clear();
TestUtil::SetAllExtensions(&message);
- ASSERT_EQ(2, message.ExtensionSize(
- unittest::repeated_foreign_message_extension));
- const protobuf_unittest::ForeignMessage* expected = message.MutableExtension(
- unittest::repeated_foreign_message_extension, 1);
+ ASSERT_EQ(
+ 2, message.ExtensionSize(unittest::repeated_foreign_message_extension));
+ const protobuf_unittest::ForeignMessage* expected =
+ message.MutableExtension(unittest::repeated_foreign_message_extension, 1);
std::unique_ptr<Message> released(message.GetReflection()->ReleaseLast(
&message, descriptor->file()->FindExtensionByName(
"repeated_foreign_message_extension")));
EXPECT_EQ(expected, released.get());
-
}
TEST(GeneratedMessageReflectionTest, SwapRepeatedElements) {
unittest::TestAllTypes message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllTypes::descriptor());
+ unittest::TestAllTypes::descriptor());
TestUtil::SetAllFields(&message);
@@ -408,7 +406,7 @@
TEST(GeneratedMessageReflectionTest, SwapRepeatedElementsExtension) {
unittest::TestAllExtensions message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllExtensions::descriptor());
+ unittest::TestAllExtensions::descriptor());
TestUtil::SetAllExtensions(&message);
@@ -426,7 +424,7 @@
// values.
unittest::TestAllExtensions message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllExtensions::descriptor());
+ unittest::TestAllExtensions::descriptor());
reflection_tester.SetAllFieldsViaReflection(&message);
TestUtil::ExpectAllExtensionsSet(message);
@@ -438,14 +436,14 @@
TEST(GeneratedMessageReflectionTest, FindExtensionTypeByNumber) {
const Reflection* reflection =
- unittest::TestAllExtensions::default_instance().GetReflection();
+ unittest::TestAllExtensions::default_instance().GetReflection();
const FieldDescriptor* extension1 =
- unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
- "optional_int32_extension");
+ unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
+ "optional_int32_extension");
const FieldDescriptor* extension2 =
- unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
- "repeated_string_extension");
+ unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
+ "repeated_string_extension");
EXPECT_EQ(extension1,
reflection->FindKnownExtensionByNumber(extension1->number()));
@@ -457,20 +455,21 @@
// Extensions of TestAllExtensions should not show up as extensions of
// other types.
- EXPECT_TRUE(unittest::TestAllTypes::default_instance().GetReflection()->
- FindKnownExtensionByNumber(extension1->number()) == NULL);
+ EXPECT_TRUE(unittest::TestAllTypes::default_instance()
+ .GetReflection()
+ ->FindKnownExtensionByNumber(extension1->number()) == NULL);
}
TEST(GeneratedMessageReflectionTest, FindKnownExtensionByName) {
const Reflection* reflection =
- unittest::TestAllExtensions::default_instance().GetReflection();
+ unittest::TestAllExtensions::default_instance().GetReflection();
const FieldDescriptor* extension1 =
- unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
- "optional_int32_extension");
+ unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
+ "optional_int32_extension");
const FieldDescriptor* extension2 =
- unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
- "repeated_string_extension");
+ unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
+ "repeated_string_extension");
EXPECT_EQ(extension1,
reflection->FindKnownExtensionByName(extension1->full_name()));
@@ -482,8 +481,9 @@
// Extensions of TestAllExtensions should not show up as extensions of
// other types.
- EXPECT_TRUE(unittest::TestAllTypes::default_instance().GetReflection()->
- FindKnownExtensionByName(extension1->full_name()) == NULL);
+ EXPECT_TRUE(unittest::TestAllTypes::default_instance()
+ .GetReflection()
+ ->FindKnownExtensionByName(extension1->full_name()) == NULL);
}
TEST(GeneratedMessageReflectionTest, SetAllocatedMessageTest) {
@@ -491,7 +491,7 @@
unittest::TestAllTypes from_message2;
unittest::TestAllTypes to_message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllTypes::descriptor());
+ unittest::TestAllTypes::descriptor());
reflection_tester.SetAllFieldsViaReflection(&from_message1);
reflection_tester.SetAllFieldsViaReflection(&from_message2);
@@ -526,7 +526,7 @@
unittest::TestAllTypes* to_message =
Arena::CreateMessage<unittest::TestAllTypes>(&arena);
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllTypes::descriptor());
+ unittest::TestAllTypes::descriptor());
reflection_tester.SetAllFieldsViaReflection(&from_message1);
reflection_tester.SetAllFieldsViaReflection(&from_message2);
@@ -559,7 +559,7 @@
unittest::TestAllExtensions from_message2;
unittest::TestAllExtensions to_message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllExtensions::descriptor());
+ unittest::TestAllExtensions::descriptor());
reflection_tester.SetAllFieldsViaReflection(&from_message1);
reflection_tester.SetAllFieldsViaReflection(&from_message2);
@@ -594,7 +594,7 @@
unittest::TestAllExtensions from_message1;
unittest::TestAllExtensions from_message2;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllExtensions::descriptor());
+ unittest::TestAllExtensions::descriptor());
reflection_tester.SetAllFieldsViaReflection(&from_message1);
reflection_tester.SetAllFieldsViaReflection(&from_message2);
@@ -633,8 +633,8 @@
unittest::TestAllTypes::NestedMessage::descriptor()->FindFieldByName(
"bb");
- Message* nested = reflection->AddMessage(
- &message, F("repeated_nested_message"));
+ Message* nested =
+ reflection->AddMessage(&message, F("repeated_nested_message"));
nested_reflection->SetInt32(nested, nested_bb, 11);
EXPECT_EQ(11, message.repeated_nested_message(0).bb());
@@ -668,7 +668,8 @@
unittest::TestAllTypes::NestedMessage* nested =
new unittest::TestAllTypes::NestedMessage();
nested->set_bb(11);
- reflection->AddAllocatedMessage(&message, F("repeated_nested_message"), nested);
+ reflection->AddAllocatedMessage(&message, F("repeated_nested_message"),
+ nested);
EXPECT_EQ(1, message.repeated_nested_message_size());
EXPECT_EQ(11, message.repeated_nested_message(0).bb());
}
@@ -689,62 +690,68 @@
const Reflection* reflection = message.GetReflection();
// Check default values.
- EXPECT_EQ(0, reflection->GetInt32(
- message, descriptor->FindFieldByName("foo_int")));
+ EXPECT_EQ(
+ 0, reflection->GetInt32(message, descriptor->FindFieldByName("foo_int")));
EXPECT_EQ("", reflection->GetString(
- message, descriptor->FindFieldByName("foo_string")));
+ message, descriptor->FindFieldByName("foo_string")));
+ EXPECT_EQ("", reflection->GetString(message,
+ descriptor->FindFieldByName("foo_cord")));
EXPECT_EQ("", reflection->GetString(
- message, descriptor->FindFieldByName("foo_cord")));
+ message, descriptor->FindFieldByName("foo_string_piece")));
EXPECT_EQ("", reflection->GetString(
- message, descriptor->FindFieldByName("foo_string_piece")));
- EXPECT_EQ("", reflection->GetString(
- message, descriptor->FindFieldByName("foo_bytes")));
- EXPECT_EQ(unittest::TestOneof2::FOO, reflection->GetEnum(
- message, descriptor->FindFieldByName("foo_enum"))->number());
+ message, descriptor->FindFieldByName("foo_bytes")));
+ EXPECT_EQ(
+ unittest::TestOneof2::FOO,
+ reflection->GetEnum(message, descriptor->FindFieldByName("foo_enum"))
+ ->number());
EXPECT_EQ(&unittest::TestOneof2::NestedMessage::default_instance(),
&reflection->GetMessage(
message, descriptor->FindFieldByName("foo_message")));
EXPECT_EQ(&unittest::TestOneof2::FooGroup::default_instance(),
- &reflection->GetMessage(
- message, descriptor->FindFieldByName("foogroup")));
+ &reflection->GetMessage(message,
+ descriptor->FindFieldByName("foogroup")));
EXPECT_NE(&unittest::TestOneof2::FooGroup::default_instance(),
&reflection->GetMessage(
message, descriptor->FindFieldByName("foo_lazy_message")));
- EXPECT_EQ(5, reflection->GetInt32(
- message, descriptor->FindFieldByName("bar_int")));
+ EXPECT_EQ(
+ 5, reflection->GetInt32(message, descriptor->FindFieldByName("bar_int")));
EXPECT_EQ("STRING", reflection->GetString(
- message, descriptor->FindFieldByName("bar_string")));
+ message, descriptor->FindFieldByName("bar_string")));
EXPECT_EQ("CORD", reflection->GetString(
- message, descriptor->FindFieldByName("bar_cord")));
- EXPECT_EQ("SPIECE", reflection->GetString(
- message, descriptor->FindFieldByName("bar_string_piece")));
+ message, descriptor->FindFieldByName("bar_cord")));
+ EXPECT_EQ("SPIECE",
+ reflection->GetString(
+ message, descriptor->FindFieldByName("bar_string_piece")));
EXPECT_EQ("BYTES", reflection->GetString(
- message, descriptor->FindFieldByName("bar_bytes")));
- EXPECT_EQ(unittest::TestOneof2::BAR, reflection->GetEnum(
- message, descriptor->FindFieldByName("bar_enum"))->number());
+ message, descriptor->FindFieldByName("bar_bytes")));
+ EXPECT_EQ(
+ unittest::TestOneof2::BAR,
+ reflection->GetEnum(message, descriptor->FindFieldByName("bar_enum"))
+ ->number());
// Check Set functions.
- reflection->SetInt32(
- &message, descriptor->FindFieldByName("foo_int"), 123);
- EXPECT_EQ(123, reflection->GetInt32(
- message, descriptor->FindFieldByName("foo_int")));
- reflection->SetString(
- &message, descriptor->FindFieldByName("foo_string"), "abc");
+ reflection->SetInt32(&message, descriptor->FindFieldByName("foo_int"), 123);
+ EXPECT_EQ(123, reflection->GetInt32(message,
+ descriptor->FindFieldByName("foo_int")));
+ reflection->SetString(&message, descriptor->FindFieldByName("foo_string"),
+ "abc");
EXPECT_EQ("abc", reflection->GetString(
- message, descriptor->FindFieldByName("foo_string")));
- reflection->SetString(
- &message, descriptor->FindFieldByName("foo_bytes"), "bytes");
+ message, descriptor->FindFieldByName("foo_string")));
+ reflection->SetString(&message, descriptor->FindFieldByName("foo_bytes"),
+ "bytes");
EXPECT_EQ("bytes", reflection->GetString(
- message, descriptor->FindFieldByName("foo_bytes")));
- reflection->SetString(
- &message, descriptor->FindFieldByName("bar_cord"), "change_cord");
- EXPECT_EQ("change_cord", reflection->GetString(
- message, descriptor->FindFieldByName("bar_cord")));
- reflection->SetString(
- &message, descriptor->FindFieldByName("bar_string_piece"),
- "change_spiece");
- EXPECT_EQ("change_spiece", reflection->GetString(
- message, descriptor->FindFieldByName("bar_string_piece")));
+ message, descriptor->FindFieldByName("foo_bytes")));
+ reflection->SetString(&message, descriptor->FindFieldByName("bar_cord"),
+ "change_cord");
+ EXPECT_EQ(
+ "change_cord",
+ reflection->GetString(message, descriptor->FindFieldByName("bar_cord")));
+ reflection->SetString(&message,
+ descriptor->FindFieldByName("bar_string_piece"),
+ "change_spiece");
+ EXPECT_EQ("change_spiece",
+ reflection->GetString(
+ message, descriptor->FindFieldByName("bar_string_piece")));
message.clear_foo();
message.clear_bar();
@@ -769,8 +776,8 @@
TestUtil::ReflectionTester::ExpectOneofSetViaReflection(from_message1);
TestUtil::ReflectionTester::
- SetAllocatedOptionalMessageFieldsToMessageViaReflection(
- &from_message1, &to_message);
+ SetAllocatedOptionalMessageFieldsToMessageViaReflection(&from_message1,
+ &to_message);
const Message& sub_message = reflection->GetMessage(
to_message, descriptor->FindFieldByName("foo_lazy_message"));
released = reflection->ReleaseMessage(
@@ -781,12 +788,12 @@
TestUtil::ReflectionTester::SetOneofViaReflection(&from_message2);
- reflection->MutableMessage(
- &from_message2, descriptor->FindFieldByName("foo_message"));
+ reflection->MutableMessage(&from_message2,
+ descriptor->FindFieldByName("foo_message"));
TestUtil::ReflectionTester::
- SetAllocatedOptionalMessageFieldsToMessageViaReflection(
- &from_message2, &to_message);
+ SetAllocatedOptionalMessageFieldsToMessageViaReflection(&from_message2,
+ &to_message);
const Message& sub_message2 = reflection->GetMessage(
to_message, descriptor->FindFieldByName("foo_message"));
@@ -817,8 +824,8 @@
TestUtil::ReflectionTester::ExpectOneofSetViaReflection(from_message1);
TestUtil::ReflectionTester::
- SetAllocatedOptionalMessageFieldsToMessageViaReflection(
- &from_message1, to_message);
+ SetAllocatedOptionalMessageFieldsToMessageViaReflection(&from_message1,
+ to_message);
const Message& sub_message = reflection->GetMessage(
*to_message, descriptor->FindFieldByName("foo_lazy_message"));
released = reflection->ReleaseMessage(
@@ -831,12 +838,12 @@
TestUtil::ReflectionTester::SetOneofViaReflection(&from_message2);
- reflection->MutableMessage(
- &from_message2, descriptor->FindFieldByName("foo_message"));
+ reflection->MutableMessage(&from_message2,
+ descriptor->FindFieldByName("foo_message"));
TestUtil::ReflectionTester::
- SetAllocatedOptionalMessageFieldsToMessageViaReflection(
- &from_message2, to_message);
+ SetAllocatedOptionalMessageFieldsToMessageViaReflection(&from_message2,
+ to_message);
const Message& sub_message2 = reflection->GetMessage(
*to_message, descriptor->FindFieldByName("foo_message"));
@@ -849,11 +856,10 @@
delete released;
}
-
TEST(GeneratedMessageReflectionTest, ReleaseMessageTest) {
unittest::TestAllTypes message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllTypes::descriptor());
+ unittest::TestAllTypes::descriptor());
// When nothing is set, we expect all released messages to be NULL.
reflection_tester.ExpectMessagesReleasedViaReflection(
@@ -879,7 +885,7 @@
TEST(GeneratedMessageReflectionTest, ReleaseExtensionMessageTest) {
unittest::TestAllExtensions message;
TestUtil::ReflectionTester reflection_tester(
- unittest::TestAllExtensions::descriptor());
+ unittest::TestAllExtensions::descriptor());
// When nothing is set, we expect all released messages to be NULL.
reflection_tester.ExpectMessagesReleasedViaReflection(
@@ -1001,39 +1007,41 @@
// Testing every single failure mode would be too much work. Let's just
// check a few.
EXPECT_DEATH(
- reflection->GetInt32(
- message, descriptor->FindFieldByName("optional_int64")),
- "Protocol Buffer reflection usage error:\n"
- " Method : google::protobuf::Reflection::GetInt32\n"
- " Message type: protobuf_unittest\\.TestAllTypes\n"
- " Field : protobuf_unittest\\.TestAllTypes\\.optional_int64\n"
- " Problem : Field is not the right type for this message:\n"
- " Expected : CPPTYPE_INT32\n"
- " Field type: CPPTYPE_INT64");
+ reflection->GetInt32(message,
+ descriptor->FindFieldByName("optional_int64")),
+ "Protocol Buffer reflection usage error:\n"
+ " Method : google::protobuf::Reflection::GetInt32\n"
+ " Message type: protobuf_unittest\\.TestAllTypes\n"
+ " Field : protobuf_unittest\\.TestAllTypes\\.optional_int64\n"
+ " Problem : Field is not the right type for this message:\n"
+ " Expected : CPPTYPE_INT32\n"
+ " Field type: CPPTYPE_INT64");
+ EXPECT_DEATH(reflection->GetInt32(
+ message, descriptor->FindFieldByName("repeated_int32")),
+ "Protocol Buffer reflection usage error:\n"
+ " Method : google::protobuf::Reflection::GetInt32\n"
+ " Message type: protobuf_unittest.TestAllTypes\n"
+ " Field : protobuf_unittest.TestAllTypes.repeated_int32\n"
+ " Problem : Field is repeated; the method requires a "
+ "singular field.");
EXPECT_DEATH(
- reflection->GetInt32(
- message, descriptor->FindFieldByName("repeated_int32")),
- "Protocol Buffer reflection usage error:\n"
- " Method : google::protobuf::Reflection::GetInt32\n"
- " Message type: protobuf_unittest.TestAllTypes\n"
- " Field : protobuf_unittest.TestAllTypes.repeated_int32\n"
- " Problem : Field is repeated; the method requires a singular field.");
+ reflection->GetInt32(
+ message,
+ unittest::ForeignMessage::descriptor()->FindFieldByName("c")),
+ "Protocol Buffer reflection usage error:\n"
+ " Method : google::protobuf::Reflection::GetInt32\n"
+ " Message type: protobuf_unittest.TestAllTypes\n"
+ " Field : protobuf_unittest.ForeignMessage.c\n"
+ " Problem : Field does not match message type.");
EXPECT_DEATH(
- reflection->GetInt32(
- message, unittest::ForeignMessage::descriptor()->FindFieldByName("c")),
- "Protocol Buffer reflection usage error:\n"
- " Method : google::protobuf::Reflection::GetInt32\n"
- " Message type: protobuf_unittest.TestAllTypes\n"
- " Field : protobuf_unittest.ForeignMessage.c\n"
- " Problem : Field does not match message type.");
- EXPECT_DEATH(
- reflection->HasField(
- message, unittest::ForeignMessage::descriptor()->FindFieldByName("c")),
- "Protocol Buffer reflection usage error:\n"
- " Method : google::protobuf::Reflection::HasField\n"
- " Message type: protobuf_unittest.TestAllTypes\n"
- " Field : protobuf_unittest.ForeignMessage.c\n"
- " Problem : Field does not match message type.");
+ reflection->HasField(
+ message,
+ unittest::ForeignMessage::descriptor()->FindFieldByName("c")),
+ "Protocol Buffer reflection usage error:\n"
+ " Method : google::protobuf::Reflection::HasField\n"
+ " Message type: protobuf_unittest.TestAllTypes\n"
+ " Field : protobuf_unittest.ForeignMessage.c\n"
+ " Problem : Field does not match message type.");
#undef f
}
diff --git a/src/google/protobuf/generated_message_table_driven.cc b/src/google/protobuf/generated_message_table_driven.cc
index dc2e693..fb82a8e 100644
--- a/src/google/protobuf/generated_message_table_driven.cc
+++ b/src/google/protobuf/generated_message_table_driven.cc
@@ -57,32 +57,30 @@
static constexpr bool IsLite() { return false; }
static bool Skip(MessageLite* msg, const ParseTable& table,
- io::CodedInputStream* input,
- int tag) {
+ io::CodedInputStream* input, int tag) {
GOOGLE_DCHECK(table.unknown_field_set);
return WireFormat::SkipField(input, tag,
- MutableUnknownFields(msg, table.arena_offset));
+ MutableUnknownFields(msg, table.arena_offset));
}
- static void Varint(MessageLite* msg, const ParseTable& table,
- int tag, int value) {
+ static void Varint(MessageLite* msg, const ParseTable& table, int tag,
+ int value) {
GOOGLE_DCHECK(table.unknown_field_set);
- MutableUnknownFields(msg, table.arena_offset)->AddVarint(
- WireFormatLite::GetTagFieldNumber(tag), value);
+ MutableUnknownFields(msg, table.arena_offset)
+ ->AddVarint(WireFormatLite::GetTagFieldNumber(tag), value);
}
- static bool ParseExtension(
- MessageLite* msg, const ParseTable& table,
- io::CodedInputStream* input, int tag) {
+ static bool ParseExtension(MessageLite* msg, const ParseTable& table,
+ io::CodedInputStream* input, int tag) {
ExtensionSet* extensions = GetExtensionSet(msg, table.extension_offset);
if (extensions == NULL) {
return false;
}
- const Message* prototype = down_cast<const Message*>(
- table.default_instance());
+ const Message* prototype =
+ down_cast<const Message*>(table.default_instance());
GOOGLE_DCHECK(prototype != NULL);
GOOGLE_DCHECK(table.unknown_field_set);
@@ -95,8 +93,8 @@
} // namespace
-bool MergePartialFromCodedStream(
- MessageLite* msg, const ParseTable& table, io::CodedInputStream* input) {
+bool MergePartialFromCodedStream(MessageLite* msg, const ParseTable& table,
+ io::CodedInputStream* input) {
return MergePartialFromCodedStreamImpl<UnknownFieldHandler,
InternalMetadataWithArena>(msg, table,
input);
diff --git a/src/google/protobuf/generated_message_table_driven.h b/src/google/protobuf/generated_message_table_driven.h
index 8564f5e..1394ab1 100644
--- a/src/google/protobuf/generated_message_table_driven.h
+++ b/src/google/protobuf/generated_message_table_driven.h
@@ -114,7 +114,6 @@
static int CalculateType(int fundamental_type, FieldTypeClass type_class);
};
-
// TODO(ckennelly): Add a static assertion to ensure that these masks do not
// conflict with wiretypes.
@@ -219,7 +218,7 @@
bool MergePartialFromCodedStream(MessageLite* msg, const ParseTable& table,
io::CodedInputStream* input);
bool MergePartialFromCodedStreamLite(MessageLite* msg, const ParseTable& table,
- io::CodedInputStream* input);
+ io::CodedInputStream* input);
template <typename Entry>
bool ParseMap(io::CodedInputStream* input, void* map_field) {
diff --git a/src/google/protobuf/generated_message_table_driven_lite.cc b/src/google/protobuf/generated_message_table_driven_lite.cc
index 05d4f29..82de6bc 100644
--- a/src/google/protobuf/generated_message_table_driven_lite.cc
+++ b/src/google/protobuf/generated_message_table_driven_lite.cc
@@ -54,8 +54,7 @@
static constexpr bool IsLite() { return true; }
static bool Skip(MessageLite* msg, const ParseTable& table,
- io::CodedInputStream* input,
- int tag) {
+ io::CodedInputStream* input, int tag) {
GOOGLE_DCHECK(!table.unknown_field_set);
io::StringOutputStream unknown_fields_string(
MutableUnknownFields(msg, table.arena_offset));
@@ -65,8 +64,8 @@
&unknown_fields_stream);
}
- static void Varint(MessageLite* msg, const ParseTable& table,
- int tag, int value) {
+ static void Varint(MessageLite* msg, const ParseTable& table, int tag,
+ int value) {
GOOGLE_DCHECK(!table.unknown_field_set);
io::StringOutputStream unknown_fields_string(
@@ -76,9 +75,8 @@
unknown_fields_stream.WriteVarint32(value);
}
- static bool ParseExtension(
- MessageLite* msg, const ParseTable& table,
- io::CodedInputStream* input, int tag) {
+ static bool ParseExtension(MessageLite* msg, const ParseTable& table,
+ io::CodedInputStream* input, int tag) {
ExtensionSet* extensions = GetExtensionSet(msg, table.extension_offset);
if (extensions == NULL) {
return false;
@@ -90,15 +88,15 @@
io::StringOutputStream unknown_fields_string(
MutableUnknownFields(msg, table.arena_offset));
io::CodedOutputStream unknown_fields_stream(&unknown_fields_string, false);
- return extensions->ParseField(
- tag, input, prototype, &unknown_fields_stream);
+ return extensions->ParseField(tag, input, prototype,
+ &unknown_fields_stream);
}
};
} // namespace
-bool MergePartialFromCodedStreamLite(
- MessageLite* msg, const ParseTable& table, io::CodedInputStream* input) {
+bool MergePartialFromCodedStreamLite(MessageLite* msg, const ParseTable& table,
+ io::CodedInputStream* input) {
return MergePartialFromCodedStreamImpl<UnknownFieldHandlerLite,
InternalMetadataWithArenaLite>(
msg, table, input);
diff --git a/src/google/protobuf/generated_message_table_driven_lite.h b/src/google/protobuf/generated_message_table_driven_lite.h
index c8e24c4..b36e51b 100644
--- a/src/google/protobuf/generated_message_table_driven_lite.h
+++ b/src/google/protobuf/generated_message_table_driven_lite.h
@@ -102,7 +102,7 @@
template <typename Type>
inline Type* AddField(MessageLite* msg, int64 offset) {
static_assert(std::is_pod<Type>::value ||
- std::is_same<Type, InlinedStringField>::value,
+ std::is_same<Type, InlinedStringField>::value,
"Do not assign");
RepeatedField<Type>* repeated = Raw<RepeatedField<Type>>(msg, offset);
@@ -157,7 +157,7 @@
// Clears a oneof field. The field argument should correspond to the particular
// field that is currently set in the oneof.
inline void ClearOneofField(const ParseTableField& field, Arena* arena,
- MessageLite* msg) {
+ MessageLite* msg) {
switch (field.processing_type & kTypeMask) {
case WireFormatLite::TYPE_MESSAGE:
if (arena == NULL) {
@@ -241,8 +241,8 @@
switch (cardinality) {
case Cardinality_SINGULAR:
// TODO(ckennelly): Is this optimal?
- s = MutableField<InlinedStringField>(
- msg, has_bits, has_bit_index, offset);
+ s = MutableField<InlinedStringField>(msg, has_bits, has_bit_index,
+ offset);
break;
case Cardinality_REPEATED:
s = AddField<InlinedStringField>(msg, offset);
@@ -543,8 +543,7 @@
{
Arena* const arena =
GetArena<InternalMetadata>(msg, table.arena_offset);
- const void* default_ptr =
- table.aux[field_number].strings.default_ptr;
+ const void* default_ptr = table.aux[field_number].strings.default_ptr;
if (PROTOBUF_PREDICT_FALSE(
(!HandleString<UnknownFieldHandler, Cardinality_REPEATED,
@@ -782,8 +781,8 @@
// TODO(ckennelly): Use a computed goto on GCC/LLVM.
//
// Mask out kRepeatedMask bit, allowing the jump table to be smaller.
- switch (static_cast<WireFormatLite::FieldType>(
- processing_type ^ kRepeatedMask)) {
+ switch (static_cast<WireFormatLite::FieldType>(processing_type ^
+ kRepeatedMask)) {
#define HANDLE_PACKED_TYPE(TYPE, CPPTYPE, CPPTYPE_METHOD) \
case WireFormatLite::TYPE_##TYPE: { \
RepeatedField<CPPTYPE>* values = Raw<RepeatedField<CPPTYPE>>(msg, offset); \
diff --git a/src/google/protobuf/generated_message_util.cc b/src/google/protobuf/generated_message_util.cc
index 26a422f..363eca4 100644
--- a/src/google/protobuf/generated_message_util.cc
+++ b/src/google/protobuf/generated_message_util.cc
@@ -40,7 +40,7 @@
// We're only using this as a standard way for getting the thread id.
// We're not using any thread functionality.
#include <thread> // NOLINT
-#endif // #ifndef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
+#endif // #ifndef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
#include <vector>
@@ -497,8 +497,8 @@
for (int i = 0; i < AccessorHelper::Size(array); i++) {
WriteTagTo(md.tag, output);
SerializeMessageTo(
- static_cast<const MessageLite*>(AccessorHelper::Get(array, i)), md.ptr,
- output);
+ static_cast<const MessageLite*>(AccessorHelper::Get(array, i)),
+ md.ptr, output);
}
}
};
@@ -663,8 +663,8 @@
case FieldMetadata::kSpecial:
func = reinterpret_cast<SpecialSerializer>(
const_cast<void*>(field_metadata.ptr));
- func (base, field_metadata.offset, field_metadata.tag,
- field_metadata.has_offset, output);
+ func(base, field_metadata.offset, field_metadata.tag,
+ field_metadata.has_offset, output);
break;
default:
// __builtin_unreachable()
@@ -708,10 +708,10 @@
io::ArrayOutputStream array_stream(array_output.ptr, INT_MAX);
io::CodedOutputStream output(&array_stream);
output.SetSerializationDeterministic(is_deterministic);
- func = reinterpret_cast<SpecialSerializer>(
+ func = reinterpret_cast<SpecialSerializer>(
const_cast<void*>(field_metadata.ptr));
- func (base, field_metadata.offset, field_metadata.tag,
- field_metadata.has_offset, &output);
+ func(base, field_metadata.offset, field_metadata.tag,
+ field_metadata.has_offset, &output);
array_output.ptr += output.ByteCount();
} break;
default:
@@ -768,7 +768,8 @@
void InitSCC_DFS(SCCInfoBase* scc) {
if (scc->visit_status.load(std::memory_order_relaxed) !=
- SCCInfoBase::kUninitialized) return;
+ SCCInfoBase::kUninitialized)
+ return;
scc->visit_status.store(SCCInfoBase::kRunning, std::memory_order_relaxed);
// Each base is followed by an array of pointers to deps
auto deps = reinterpret_cast<SCCInfoBase* const*>(scc + 1);
diff --git a/src/google/protobuf/generated_message_util.h b/src/google/protobuf/generated_message_util.h
index d0c0a8a..bf0e5b9 100644
--- a/src/google/protobuf/generated_message_util.h
+++ b/src/google/protobuf/generated_message_util.h
@@ -65,15 +65,17 @@
class Arena;
-namespace io { class CodedInputStream; }
+namespace io {
+class CodedInputStream;
+}
namespace internal {
-template<typename To, typename From>
+template <typename To, typename From>
inline To DownCast(From* f) {
return PROTOBUF_NAMESPACE_ID::internal::down_cast<To>(f);
}
-template<typename To, typename From>
+template <typename To, typename From>
inline To DownCast(From& f) {
return PROTOBUF_NAMESPACE_ID::internal::down_cast<To>(f);
}
@@ -93,8 +95,9 @@
// helper here to keep the protobuf compiler from ever having to emit loops in
// IsInitialized() methods. We want the C++ compiler to inline this or not
// as it sees fit.
-template <class Type> bool AllAreInitialized(const Type& t) {
- for (int i = t.size(); --i >= 0; ) {
+template <class Type>
+bool AllAreInitialized(const Type& t) {
+ for (int i = t.size(); --i >= 0;) {
if (!t.Get(i).IsInitialized()) return false;
}
return true;
@@ -167,6 +170,7 @@
public:
int Get() const { return size_.load(std::memory_order_relaxed); }
void Set(int size) { size_.store(size, std::memory_order_relaxed); }
+
private:
std::atomic<int> size_{0};
};
diff --git a/src/google/protobuf/has_bits.h b/src/google/protobuf/has_bits.h
index ff0e176..11afde7 100644
--- a/src/google/protobuf/has_bits.h
+++ b/src/google/protobuf/has_bits.h
@@ -44,7 +44,7 @@
namespace protobuf {
namespace internal {
-template<size_t doublewords>
+template <size_t doublewords>
class HasBits {
public:
HasBits() PROTOBUF_ALWAYS_INLINE { Clear(); }
@@ -69,6 +69,10 @@
return !(*this == rhs);
}
+ void Or(const HasBits<doublewords>& rhs) {
+ for (int i = 0; i < doublewords; i++) has_bits_[i] |= rhs[i];
+ }
+
bool empty() const;
private:
diff --git a/src/google/protobuf/io/coded_stream.cc b/src/google/protobuf/io/coded_stream.cc
index ff08709..6aaaa0b 100644
--- a/src/google/protobuf/io/coded_stream.cc
+++ b/src/google/protobuf/io/coded_stream.cc
@@ -38,14 +38,14 @@
// will not cross the end of the buffer, since we can avoid a lot
// of branching in this case.
-#include <google/protobuf/io/coded_stream_inl.h>
+#include <limits.h>
#include <algorithm>
#include <utility>
-#include <limits.h>
-#include <google/protobuf/io/zero_copy_stream.h>
-#include <google/protobuf/arena.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/coded_stream_inl.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/arena.h>
#include <google/protobuf/stubs/stl_util.h>
@@ -61,8 +61,8 @@
static const int kMaxVarint32Bytes = 5;
-inline bool NextNonEmpty(ZeroCopyInputStream* input,
- const void** data, int* size) {
+inline bool NextNonEmpty(ZeroCopyInputStream* input, const void** data,
+ int* size) {
bool success;
do {
success = input->Next(data, size);
@@ -124,8 +124,8 @@
// and overflow. Also check that the new requested limit is before the
// previous limit; otherwise we continue to enforce the previous limit.
if (PROTOBUF_PREDICT_TRUE(byte_limit >= 0 &&
- byte_limit <= INT_MAX - current_position &&
- byte_limit < current_limit_ - current_position)) {
+ byte_limit <= INT_MAX - current_position &&
+ byte_limit < current_limit_ - current_position)) {
current_limit_ = current_position + byte_limit;
RecomputeBufferLimits();
}
@@ -190,7 +190,8 @@
void CodedInputStream::PrintTotalBytesLimitError() {
GOOGLE_LOG(ERROR) << "A protocol message was rejected because it was too "
- "big (more than " << total_bytes_limit_
+ "big (more than "
+ << total_bytes_limit_
<< " bytes). To increase the limit (or to disable these "
"warnings), see CodedInputStream::SetTotalBytesLimit() "
"in net/proto2/io/public/coded_stream.h.";
@@ -333,9 +334,9 @@
// part is buffer + (number of bytes read). This function is always inlined,
// so returning a pair is costless.
PROTOBUF_ALWAYS_INLINE
-::std::pair<bool, const uint8*> ReadVarint32FromArray(
- uint32 first_byte, const uint8* buffer,
- uint32* value);
+::std::pair<bool, const uint8*> ReadVarint32FromArray(uint32 first_byte,
+ const uint8* buffer,
+ uint32* value);
inline ::std::pair<bool, const uint8*> ReadVarint32FromArray(
uint32 first_byte, const uint8* buffer, uint32* value) {
// Fast path: We have enough bytes left in the buffer to guarantee that
@@ -346,26 +347,35 @@
uint32 b;
uint32 result = first_byte - 0x80;
++ptr; // We just processed the first byte. Move on to the second.
- b = *(ptr++); result += b << 7; if (!(b & 0x80)) goto done;
+ b = *(ptr++);
+ result += b << 7;
+ if (!(b & 0x80)) goto done;
result -= 0x80 << 7;
- b = *(ptr++); result += b << 14; if (!(b & 0x80)) goto done;
+ b = *(ptr++);
+ result += b << 14;
+ if (!(b & 0x80)) goto done;
result -= 0x80 << 14;
- b = *(ptr++); result += b << 21; if (!(b & 0x80)) goto done;
+ b = *(ptr++);
+ result += b << 21;
+ if (!(b & 0x80)) goto done;
result -= 0x80 << 21;
- b = *(ptr++); result += b << 28; if (!(b & 0x80)) goto done;
+ b = *(ptr++);
+ result += b << 28;
+ if (!(b & 0x80)) goto done;
// "result -= 0x80 << 28" is irrevelant.
// If the input is larger than 32 bits, we still need to read it all
// and discard the high-order bits.
for (int i = 0; i < kMaxVarintBytes - kMaxVarint32Bytes; i++) {
- b = *(ptr++); if (!(b & 0x80)) goto done;
+ b = *(ptr++);
+ if (!(b & 0x80)) goto done;
}
// We have overrun the maximum size of a varint (10 bytes). Assume
// the data is corrupt.
return std::make_pair(false, ptr);
- done:
+done:
*value = result;
return std::make_pair(true, ptr);
}
@@ -424,7 +434,7 @@
<< "Caller should provide us with *buffer_ when buffer is non-empty";
uint32 temp;
::std::pair<bool, const uint8*> p =
- ReadVarint32FromArray(first_byte_or_zero, buffer_, &temp);
+ ReadVarint32FromArray(first_byte_or_zero, buffer_, &temp);
if (!p.first) return -1;
buffer_ = p.second;
return temp;
@@ -635,13 +645,13 @@
CodedOutputStream::CodedOutputStream(ZeroCopyOutputStream* output,
bool do_eager_refresh)
- : output_(output),
- buffer_(NULL),
- buffer_size_(0),
- total_bytes_(0),
- had_error_(false),
- aliasing_enabled_(false),
- is_serialization_deterministic_(IsDefaultSerializationDeterministic()) {
+ : output_(output),
+ buffer_(NULL),
+ buffer_size_(0),
+ total_bytes_(0),
+ had_error_(false),
+ aliasing_enabled_(false),
+ is_serialization_deterministic_(IsDefaultSerializationDeterministic()) {
if (do_eager_refresh) {
// Eagerly Refresh() so buffer space is immediately available.
Refresh();
@@ -652,9 +662,7 @@
}
}
-CodedOutputStream::~CodedOutputStream() {
- Trim();
-}
+CodedOutputStream::~CodedOutputStream() { Trim(); }
void CodedOutputStream::Trim() {
if (buffer_size_ > 0) {
@@ -697,8 +705,8 @@
Advance(size);
}
-uint8* CodedOutputStream::WriteRawToArray(
- const void* data, int size, uint8* target) {
+uint8* CodedOutputStream::WriteRawToArray(const void* data, int size,
+ uint8* target) {
memcpy(target, data, size);
return target + size;
}
@@ -706,7 +714,7 @@
void CodedOutputStream::WriteAliasedRaw(const void* data, int size) {
if (size < buffer_size_
- ) {
+ ) {
WriteRaw(data, size);
} else {
Trim();
diff --git a/src/google/protobuf/io/coded_stream.h b/src/google/protobuf/io/coded_stream.h
index 2f1f270..5d065fc 100644
--- a/src/google/protobuf/io/coded_stream.h
+++ b/src/google/protobuf/io/coded_stream.h
@@ -115,22 +115,22 @@
#include <string>
#include <utility>
#ifdef _MSC_VER
- // Assuming windows is always little-endian.
- #if !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
- #define PROTOBUF_LITTLE_ENDIAN 1
- #endif
- #if _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
- // If MSVC has "/RTCc" set, it will complain about truncating casts at
- // runtime. This file contains some intentional truncating casts.
- #pragma runtime_checks("c", off)
- #endif
+// Assuming windows is always little-endian.
+#if !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+#define PROTOBUF_LITTLE_ENDIAN 1
+#endif
+#if _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
+// If MSVC has "/RTCc" set, it will complain about truncating casts at
+// runtime. This file contains some intentional truncating casts.
+#pragma runtime_checks("c", off)
+#endif
#else
- #include <sys/param.h> // __BYTE_ORDER
- #if ((defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || \
- (defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN)) && \
- !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
- #define PROTOBUF_LITTLE_ENDIAN 1
- #endif
+#include <sys/param.h> // __BYTE_ORDER
+#if ((defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || \
+ (defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN)) && \
+ !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+#define PROTOBUF_LITTLE_ENDIAN 1
+#endif
#endif
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/port.h>
@@ -158,8 +158,8 @@
class CodedOutputStream;
// Defined in other files.
-class ZeroCopyInputStream; // zero_copy_stream.h
-class ZeroCopyOutputStream; // zero_copy_stream.h
+class ZeroCopyInputStream; // zero_copy_stream.h
+class ZeroCopyOutputStream; // zero_copy_stream.h
// Class which reads and decodes binary data which is composed of varint-
// encoded integers and fixed-width pieces. Wraps a ZeroCopyInputStream.
@@ -234,10 +234,10 @@
// responsible for ensuring that the buffer has sufficient space.
// Read a 32-bit little-endian integer.
static const uint8* ReadLittleEndian32FromArray(const uint8* buffer,
- uint32* value);
+ uint32* value);
// Read a 64-bit little-endian integer.
static const uint8* ReadLittleEndian64FromArray(const uint8* buffer,
- uint64* value);
+ uint64* value);
// Read an unsigned integer with Varint encoding, truncating to 32 bits.
// Reading a 32-bit value is equivalent to reading a 64-bit one and casting
@@ -537,7 +537,7 @@
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedInputStream);
const uint8* buffer_;
- const uint8* buffer_end_; // pointer to the end of the buffer.
+ const uint8* buffer_end_; // pointer to the end of the buffer.
ZeroCopyInputStream* input_;
int total_bytes_read_; // total bytes read from input_, including
// the current buffer
@@ -547,7 +547,7 @@
int overflow_bytes_;
// LastTagWas() stuff.
- uint32 last_tag_; // result of last ReadTag() or ReadTagWithCutoff().
+ uint32 last_tag_; // result of last ReadTag() or ReadTagWithCutoff().
// This is set true by ReadTag{Fallback/Slow}() if it is called when exactly
// at EOF, or by ExpectAtEnd() when it returns true. This happens when we
@@ -558,7 +558,7 @@
bool aliasing_enabled_;
// Limits
- Limit current_limit_; // if position = -1, no limit is applied
+ Limit current_limit_; // if position = -1, no limit is applied
// For simplicity, if the current buffer crosses a limit (either a normal
// limit created by PushLimit() or the total bytes limit), buffer_size_
@@ -817,12 +817,8 @@
(Value < (1 << 7))
? 1
: (Value < (1 << 14))
- ? 2
- : (Value < (1 << 21))
- ? 3
- : (Value < (1 << 28))
- ? 4
- : 5;
+ ? 2
+ : (Value < (1 << 21)) ? 3 : (Value < (1 << 28)) ? 4 : 5;
};
// Returns the total number of bytes written since this object was created.
@@ -878,8 +874,8 @@
ZeroCopyOutputStream* output_;
uint8* buffer_;
int buffer_size_;
- int total_bytes_; // Sum of sizes of all buffers seen so far.
- bool had_error_; // Whether an error occurred during output.
+ int total_bytes_; // Sum of sizes of all buffers seen so far.
+ bool had_error_; // Whether an error occurred during output.
bool aliasing_enabled_; // See EnableAliasing().
bool is_serialization_deterministic_;
static std::atomic<bool> default_serialization_deterministic_;
@@ -958,14 +954,13 @@
// static
inline const uint8* CodedInputStream::ReadLittleEndian32FromArray(
- const uint8* buffer,
- uint32* value) {
+ const uint8* buffer, uint32* value) {
#if defined(PROTOBUF_LITTLE_ENDIAN)
memcpy(value, buffer, sizeof(*value));
return buffer + sizeof(*value);
#else
- *value = (static_cast<uint32>(buffer[0]) ) |
- (static_cast<uint32>(buffer[1]) << 8) |
+ *value = (static_cast<uint32>(buffer[0])) |
+ (static_cast<uint32>(buffer[1]) << 8) |
(static_cast<uint32>(buffer[2]) << 16) |
(static_cast<uint32>(buffer[3]) << 24);
return buffer + sizeof(*value);
@@ -973,22 +968,20 @@
}
// static
inline const uint8* CodedInputStream::ReadLittleEndian64FromArray(
- const uint8* buffer,
- uint64* value) {
+ const uint8* buffer, uint64* value) {
#if defined(PROTOBUF_LITTLE_ENDIAN)
memcpy(value, buffer, sizeof(*value));
return buffer + sizeof(*value);
#else
- uint32 part0 = (static_cast<uint32>(buffer[0]) ) |
- (static_cast<uint32>(buffer[1]) << 8) |
+ uint32 part0 = (static_cast<uint32>(buffer[0])) |
+ (static_cast<uint32>(buffer[1]) << 8) |
(static_cast<uint32>(buffer[2]) << 16) |
(static_cast<uint32>(buffer[3]) << 24);
- uint32 part1 = (static_cast<uint32>(buffer[4]) ) |
- (static_cast<uint32>(buffer[5]) << 8) |
+ uint32 part1 = (static_cast<uint32>(buffer[4])) |
+ (static_cast<uint32>(buffer[5]) << 8) |
(static_cast<uint32>(buffer[6]) << 16) |
(static_cast<uint32>(buffer[7]) << 24);
- *value = static_cast<uint64>(part0) |
- (static_cast<uint64>(part1) << 32);
+ *value = static_cast<uint64>(part0) | (static_cast<uint64>(part1) << 32);
return buffer + sizeof(*value);
#endif
}
@@ -1082,7 +1075,8 @@
inline bool CodedInputStream::ExpectTag(uint32 expected) {
if (expected < (1 << 7)) {
- if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) && buffer_[0] == expected) {
+ if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) &&
+ buffer_[0] == expected) {
Advance(1);
return true;
} else {
@@ -1103,8 +1097,8 @@
}
}
-inline const uint8* CodedInputStream::ExpectTagFromArray(
- const uint8* buffer, uint32 expected) {
+inline const uint8* CodedInputStream::ExpectTagFromArray(const uint8* buffer,
+ uint32 expected) {
if (expected < (1 << 7)) {
if (buffer[0] == expected) {
return buffer + 1;
@@ -1128,9 +1122,8 @@
// If we are at a limit we know no more bytes can be read. Otherwise, it's
// hard to say without calling Refresh(), and we'd rather not do that.
- if (buffer_ == buffer_end_ &&
- ((buffer_size_after_limit_ != 0) ||
- (total_bytes_read_ == current_limit_))) {
+ if (buffer_ == buffer_end_ && ((buffer_size_after_limit_ != 0) ||
+ (total_bytes_read_ == current_limit_))) {
last_tag_ = 0; // Pretend we called ReadTag()...
legitimate_message_end_ = true; // ... and it hit EOF.
return true;
@@ -1190,7 +1183,7 @@
memcpy(target, &value, sizeof(value));
#else
target[0] = static_cast<uint8>(value);
- target[1] = static_cast<uint8>(value >> 8);
+ target[1] = static_cast<uint8>(value >> 8);
target[2] = static_cast<uint8>(value >> 16);
target[3] = static_cast<uint8>(value >> 24);
#endif
@@ -1206,11 +1199,11 @@
uint32 part1 = static_cast<uint32>(value >> 32);
target[0] = static_cast<uint8>(part0);
- target[1] = static_cast<uint8>(part0 >> 8);
+ target[1] = static_cast<uint8>(part0 >> 8);
target[2] = static_cast<uint8>(part0 >> 16);
target[3] = static_cast<uint8>(part0 >> 24);
target[4] = static_cast<uint8>(part1);
- target[5] = static_cast<uint8>(part1 >> 8);
+ target[5] = static_cast<uint8>(part1 >> 8);
target[6] = static_cast<uint8>(part1 >> 16);
target[7] = static_cast<uint8>(part1 >> 24);
#endif
@@ -1243,12 +1236,9 @@
}
}
-inline void CodedOutputStream::WriteTag(uint32 value) {
- WriteVarint32(value);
-}
+inline void CodedOutputStream::WriteTag(uint32 value) { WriteVarint32(value); }
-inline uint8* CodedOutputStream::WriteTagToArray(
- uint32 value, uint8* target) {
+inline uint8* CodedOutputStream::WriteTagToArray(uint32 value, uint8* target) {
return WriteVarint32ToArray(value, target);
}
@@ -1274,7 +1264,7 @@
inline size_t CodedOutputStream::VarintSize32SignExtended(int32 value) {
if (value < 0) {
- return 10; // TODO(kenton): Make this a symbolic constant.
+ return 10; // TODO(kenton): Make this a symbolic constant.
} else {
return VarintSize32(static_cast<uint32>(value));
}
@@ -1284,8 +1274,8 @@
WriteRaw(str.data(), static_cast<int>(str.size()));
}
-inline void CodedOutputStream::WriteRawMaybeAliased(
- const void* data, int size) {
+inline void CodedOutputStream::WriteRawMaybeAliased(const void* data,
+ int size) {
if (aliasing_enabled_) {
WriteAliasedRaw(data, size);
} else {
@@ -1302,9 +1292,7 @@
return total_bytes_ - buffer_size_;
}
-inline void CodedInputStream::Advance(int amount) {
- buffer_ += amount;
-}
+inline void CodedInputStream::Advance(int amount) { buffer_ += amount; }
inline void CodedOutputStream::Advance(int amount) {
buffer_ += amount;
@@ -1349,48 +1337,46 @@
}
inline CodedInputStream::CodedInputStream(ZeroCopyInputStream* input)
- : buffer_(NULL),
- buffer_end_(NULL),
- input_(input),
- total_bytes_read_(0),
- overflow_bytes_(0),
- last_tag_(0),
- legitimate_message_end_(false),
- aliasing_enabled_(false),
- current_limit_(kint32max),
- buffer_size_after_limit_(0),
- total_bytes_limit_(kDefaultTotalBytesLimit),
- recursion_budget_(default_recursion_limit_),
- recursion_limit_(default_recursion_limit_),
- extension_pool_(NULL),
- extension_factory_(NULL) {
+ : buffer_(NULL),
+ buffer_end_(NULL),
+ input_(input),
+ total_bytes_read_(0),
+ overflow_bytes_(0),
+ last_tag_(0),
+ legitimate_message_end_(false),
+ aliasing_enabled_(false),
+ current_limit_(kint32max),
+ buffer_size_after_limit_(0),
+ total_bytes_limit_(kDefaultTotalBytesLimit),
+ recursion_budget_(default_recursion_limit_),
+ recursion_limit_(default_recursion_limit_),
+ extension_pool_(NULL),
+ extension_factory_(NULL) {
// Eagerly Refresh() so buffer space is immediately available.
Refresh();
}
inline CodedInputStream::CodedInputStream(const uint8* buffer, int size)
- : buffer_(buffer),
- buffer_end_(buffer + size),
- input_(NULL),
- total_bytes_read_(size),
- overflow_bytes_(0),
- last_tag_(0),
- legitimate_message_end_(false),
- aliasing_enabled_(false),
- current_limit_(size),
- buffer_size_after_limit_(0),
- total_bytes_limit_(kDefaultTotalBytesLimit),
- recursion_budget_(default_recursion_limit_),
- recursion_limit_(default_recursion_limit_),
- extension_pool_(NULL),
- extension_factory_(NULL) {
+ : buffer_(buffer),
+ buffer_end_(buffer + size),
+ input_(NULL),
+ total_bytes_read_(size),
+ overflow_bytes_(0),
+ last_tag_(0),
+ legitimate_message_end_(false),
+ aliasing_enabled_(false),
+ current_limit_(size),
+ buffer_size_after_limit_(0),
+ total_bytes_limit_(kDefaultTotalBytesLimit),
+ recursion_budget_(default_recursion_limit_),
+ recursion_limit_(default_recursion_limit_),
+ extension_pool_(NULL),
+ extension_factory_(NULL) {
// Note that setting current_limit_ == size is important to prevent some
// code paths from trying to access input_ and segfaulting.
}
-inline bool CodedInputStream::IsFlat() const {
- return input_ == NULL;
-}
+inline bool CodedInputStream::IsFlat() const { return input_ == NULL; }
inline bool CodedInputStream::Skip(int count) {
if (count < 0) return false; // security: count is often user-supplied
@@ -1410,9 +1396,8 @@
} // namespace protobuf
} // namespace google
-
#if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
- #pragma runtime_checks("c", restore)
+#pragma runtime_checks("c", restore)
#endif // _MSC_VER && !defined(__INTEL_COMPILER)
#include <google/protobuf/port_undef.inc>
diff --git a/src/google/protobuf/io/coded_stream_inl.h b/src/google/protobuf/io/coded_stream_inl.h
index df66282..0c10e65 100644
--- a/src/google/protobuf/io/coded_stream_inl.h
+++ b/src/google/protobuf/io/coded_stream_inl.h
@@ -36,11 +36,11 @@
#ifndef GOOGLE_PROTOBUF_IO_CODED_STREAM_INL_H__
#define GOOGLE_PROTOBUF_IO_CODED_STREAM_INL_H__
+#include <string>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
-#include <string>
#include <google/protobuf/stubs/stl_util.h>
namespace google {
diff --git a/src/google/protobuf/io/coded_stream_unittest.cc b/src/google/protobuf/io/coded_stream_unittest.cc
index 787b25c..6e3c4c4 100644
--- a/src/google/protobuf/io/coded_stream_unittest.cc
+++ b/src/google/protobuf/io/coded_stream_unittest.cc
@@ -86,45 +86,45 @@
// TODO(kenton): gTest now supports "parameterized tests" which would be
// a better way to accomplish this. Rewrite when time permits.
-#define TEST_1D(FIXTURE, NAME, CASES) \
- class FIXTURE##_##NAME##_DD : public FIXTURE { \
- protected: \
- template <typename CaseType> \
- void DoSingleCase(const CaseType& CASES##_case); \
- }; \
- \
- TEST_F(FIXTURE##_##NAME##_DD, NAME) { \
- for (int i = 0; i < GOOGLE_ARRAYSIZE(CASES); i++) { \
- SCOPED_TRACE(testing::Message() \
- << #CASES " case #" << i << ": " << CASES[i]); \
- DoSingleCase(CASES[i]); \
- } \
- } \
- \
- template <typename CaseType> \
+#define TEST_1D(FIXTURE, NAME, CASES) \
+ class FIXTURE##_##NAME##_DD : public FIXTURE { \
+ protected: \
+ template <typename CaseType> \
+ void DoSingleCase(const CaseType& CASES##_case); \
+ }; \
+ \
+ TEST_F(FIXTURE##_##NAME##_DD, NAME) { \
+ for (int i = 0; i < GOOGLE_ARRAYSIZE(CASES); i++) { \
+ SCOPED_TRACE(testing::Message() \
+ << #CASES " case #" << i << ": " << CASES[i]); \
+ DoSingleCase(CASES[i]); \
+ } \
+ } \
+ \
+ template <typename CaseType> \
void FIXTURE##_##NAME##_DD::DoSingleCase(const CaseType& CASES##_case)
-#define TEST_2D(FIXTURE, NAME, CASES1, CASES2) \
- class FIXTURE##_##NAME##_DD : public FIXTURE { \
- protected: \
- template <typename CaseType1, typename CaseType2> \
- void DoSingleCase(const CaseType1& CASES1##_case, \
- const CaseType2& CASES2##_case); \
- }; \
- \
- TEST_F(FIXTURE##_##NAME##_DD, NAME) { \
- for (int i = 0; i < GOOGLE_ARRAYSIZE(CASES1); i++) { \
- for (int j = 0; j < GOOGLE_ARRAYSIZE(CASES2); j++) { \
- SCOPED_TRACE(testing::Message() \
- << #CASES1 " case #" << i << ": " << CASES1[i] << ", " \
- << #CASES2 " case #" << j << ": " << CASES2[j]); \
- DoSingleCase(CASES1[i], CASES2[j]); \
- } \
- } \
- } \
- \
- template <typename CaseType1, typename CaseType2> \
- void FIXTURE##_##NAME##_DD::DoSingleCase(const CaseType1& CASES1##_case, \
+#define TEST_2D(FIXTURE, NAME, CASES1, CASES2) \
+ class FIXTURE##_##NAME##_DD : public FIXTURE { \
+ protected: \
+ template <typename CaseType1, typename CaseType2> \
+ void DoSingleCase(const CaseType1& CASES1##_case, \
+ const CaseType2& CASES2##_case); \
+ }; \
+ \
+ TEST_F(FIXTURE##_##NAME##_DD, NAME) { \
+ for (int i = 0; i < GOOGLE_ARRAYSIZE(CASES1); i++) { \
+ for (int j = 0; j < GOOGLE_ARRAYSIZE(CASES2); j++) { \
+ SCOPED_TRACE(testing::Message() \
+ << #CASES1 " case #" << i << ": " << CASES1[i] << ", " \
+ << #CASES2 " case #" << j << ": " << CASES2[j]); \
+ DoSingleCase(CASES1[i], CASES2[j]); \
+ } \
+ } \
+ } \
+ \
+ template <typename CaseType1, typename CaseType2> \
+ void FIXTURE##_##NAME##_DD::DoSingleCase(const CaseType1& CASES1##_case, \
const CaseType2& CASES2##_case)
// ===================================================================
@@ -157,9 +157,9 @@
// Varint tests.
struct VarintCase {
- uint8 bytes[10]; // Encoded bytes.
- int size; // Encoded size, in bytes.
- uint64 value; // Parsed value.
+ uint8 bytes[10]; // Encoded bytes.
+ int size; // Encoded size, in bytes.
+ uint64 value; // Parsed value.
};
inline std::ostream& operator<<(std::ostream& os, const VarintCase& c) {
@@ -167,28 +167,32 @@
}
VarintCase kVarintCases[] = {
- // 32-bit values
- {{0x00} , 1, 0},
- {{0x01} , 1, 1},
- {{0x7f} , 1, 127},
- {{0xa2, 0x74}, 2, (0x22 << 0) | (0x74 << 7)}, // 14882
- {{0xbe, 0xf7, 0x92, 0x84, 0x0b}, 5, // 2961488830
- (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
- (ULL(0x0b) << 28)},
+ // 32-bit values
+ {{0x00}, 1, 0},
+ {{0x01}, 1, 1},
+ {{0x7f}, 1, 127},
+ {{0xa2, 0x74}, 2, (0x22 << 0) | (0x74 << 7)}, // 14882
+ {{0xbe, 0xf7, 0x92, 0x84, 0x0b},
+ 5, // 2961488830
+ (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
+ (ULL(0x0b) << 28)},
- // 64-bit
- {{0xbe, 0xf7, 0x92, 0x84, 0x1b}, 5, // 7256456126
- (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
- (ULL(0x1b) << 28)},
- {{0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49}, 8, // 41256202580718336
- (0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) |
- (ULL(0x43) << 28) | (ULL(0x49) << 35) | (ULL(0x24) << 42) |
- (ULL(0x49) << 49)},
- // 11964378330978735131
- {{0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01}, 10,
- (0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) |
- (ULL(0x3b) << 28) | (ULL(0x56) << 35) | (ULL(0x00) << 42) |
- (ULL(0x05) << 49) | (ULL(0x26) << 56) | (ULL(0x01) << 63)},
+ // 64-bit
+ {{0xbe, 0xf7, 0x92, 0x84, 0x1b},
+ 5, // 7256456126
+ (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
+ (ULL(0x1b) << 28)},
+ {{0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49},
+ 8, // 41256202580718336
+ (0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) |
+ (ULL(0x43) << 28) | (ULL(0x49) << 35) | (ULL(0x24) << 42) |
+ (ULL(0x49) << 49)},
+ // 11964378330978735131
+ {{0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01},
+ 10,
+ (0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) |
+ (ULL(0x3b) << 28) | (ULL(0x56) << 35) | (ULL(0x00) << 42) |
+ (ULL(0x05) << 49) | (ULL(0x26) << 56) | (ULL(0x01) << 63)},
};
TEST_2D(CodedStreamTest, ReadVarint32, kVarintCases, kBlockSizes) {
@@ -229,15 +233,14 @@
class In : public ZeroCopyInputStream {
public:
In() : count_(0) {}
+
private:
virtual bool Next(const void** data, int* size) {
*data = NULL;
*size = 0;
return count_++ < 2;
}
- virtual void BackUp(int count) {
- GOOGLE_LOG(FATAL) << "Tests never call this.";
- }
+ virtual void BackUp(int count) { GOOGLE_LOG(FATAL) << "Tests never call this."; }
virtual bool Skip(int count) {
GOOGLE_LOG(FATAL) << "Tests never call this.";
return false;
@@ -291,9 +294,8 @@
// If the expectation succeeds, it should return a pointer past the tag.
if (kVarintCases_case.size <= 2) {
- EXPECT_TRUE(NULL ==
- CodedInputStream::ExpectTagFromArray(buffer_,
- expected_value + 1));
+ EXPECT_TRUE(NULL == CodedInputStream::ExpectTagFromArray(
+ buffer_, expected_value + 1));
EXPECT_TRUE(buffer_ + kVarintCases_case.size ==
CodedInputStream::ExpectTagFromArray(buffer_, expected_value));
} else {
@@ -336,7 +338,7 @@
EXPECT_EQ(kVarintCases_case.size, output.ByteCount());
EXPECT_EQ(0,
- memcmp(buffer_, kVarintCases_case.bytes, kVarintCases_case.size));
+ memcmp(buffer_, kVarintCases_case.bytes, kVarintCases_case.size));
}
TEST_2D(CodedStreamTest, WriteVarint64, kVarintCases, kBlockSizes) {
@@ -353,19 +355,17 @@
EXPECT_EQ(kVarintCases_case.size, output.ByteCount());
EXPECT_EQ(0,
- memcmp(buffer_, kVarintCases_case.bytes, kVarintCases_case.size));
+ memcmp(buffer_, kVarintCases_case.bytes, kVarintCases_case.size));
}
// This test causes gcc 3.3.5 (and earlier?) to give the cryptic error:
// "sorry, unimplemented: `method_call_expr' not supported by dump_expr"
#if !defined(__GNUC__) || __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)
-int32 kSignExtendedVarintCases[] = {
- 0, 1, -1, 1237894, -37895138
-};
+int32 kSignExtendedVarintCases[] = {0, 1, -1, 1237894, -37895138};
-TEST_2D(CodedStreamTest, WriteVarint32SignExtended,
- kSignExtendedVarintCases, kBlockSizes) {
+TEST_2D(CodedStreamTest, WriteVarint32SignExtended, kSignExtendedVarintCases,
+ kBlockSizes) {
ArrayOutputStream output(buffer_, sizeof(buffer_), kBlockSizes_case);
{
@@ -419,22 +419,23 @@
}
const VarintErrorCase kVarintErrorCases[] = {
- // Control case. (Insures that there isn't something else wrong that
- // makes parsing always fail.)
- {{0x00}, 1, true},
+ // Control case. (Insures that there isn't something else wrong that
+ // makes parsing always fail.)
+ {{0x00}, 1, true},
- // No input data.
- {{}, 0, false},
+ // No input data.
+ {{}, 0, false},
- // Input ends unexpectedly.
- {{0xf0, 0xab}, 2, false},
+ // Input ends unexpectedly.
+ {{0xf0, 0xab}, 2, false},
- // Input ends unexpectedly after 32 bits.
- {{0xf0, 0xab, 0xc9, 0x9a, 0xf8, 0xb2}, 6, false},
+ // Input ends unexpectedly after 32 bits.
+ {{0xf0, 0xab, 0xc9, 0x9a, 0xf8, 0xb2}, 6, false},
- // Longer than 10 bytes.
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01},
- 11, false},
+ // Longer than 10 bytes.
+ {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01},
+ 11,
+ false},
};
TEST_2D(CodedStreamTest, ReadVarint32Error, kVarintErrorCases, kBlockSizes) {
@@ -500,14 +501,14 @@
}
VarintSizeCase kVarintSizeCases[] = {
- {0u, 1},
- {1u, 1},
- {127u, 1},
- {128u, 2},
- {758923u, 3},
- {4000000000u, 5},
- {ULL(41256202580718336), 8},
- {ULL(11964378330978735131), 10},
+ {0u, 1},
+ {1u, 1},
+ {127u, 1},
+ {128u, 2},
+ {758923u, 3},
+ {4000000000u, 5},
+ {ULL(41256202580718336), 8},
+ {ULL(11964378330978735131), 10},
};
TEST_1D(CodedStreamTest, VarintSize32, kVarintSizeCases) {
@@ -517,13 +518,13 @@
}
EXPECT_EQ(kVarintSizeCases_case.size,
- CodedOutputStream::VarintSize32(
- static_cast<uint32>(kVarintSizeCases_case.value)));
+ CodedOutputStream::VarintSize32(
+ static_cast<uint32>(kVarintSizeCases_case.value)));
}
TEST_1D(CodedStreamTest, VarintSize64, kVarintSizeCases) {
EXPECT_EQ(kVarintSizeCases_case.size,
- CodedOutputStream::VarintSize64(kVarintSizeCases_case.value));
+ CodedOutputStream::VarintSize64(kVarintSizeCases_case.value));
}
TEST_F(CodedStreamTest, VarintSize32PowersOfTwo) {
@@ -552,13 +553,13 @@
// Fixed-size int tests
struct Fixed32Case {
- uint8 bytes[sizeof(uint32)]; // Encoded bytes.
- uint32 value; // Parsed value.
+ uint8 bytes[sizeof(uint32)]; // Encoded bytes.
+ uint32 value; // Parsed value.
};
struct Fixed64Case {
- uint8 bytes[sizeof(uint64)]; // Encoded bytes.
- uint64 value; // Parsed value.
+ uint8 bytes[sizeof(uint64)]; // Encoded bytes.
+ uint64 value; // Parsed value.
};
inline std::ostream& operator<<(std::ostream& os, const Fixed32Case& c) {
@@ -570,13 +571,13 @@
}
Fixed32Case kFixed32Cases[] = {
- {{0xef, 0xcd, 0xab, 0x90}, 0x90abcdefu},
- {{0x12, 0x34, 0x56, 0x78}, 0x78563412u},
+ {{0xef, 0xcd, 0xab, 0x90}, 0x90abcdefu},
+ {{0x12, 0x34, 0x56, 0x78}, 0x78563412u},
};
Fixed64Case kFixed64Cases[] = {
- {{0xef, 0xcd, 0xab, 0x90, 0x12, 0x34, 0x56, 0x78}, ULL(0x7856341290abcdef)},
- {{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}, ULL(0x8877665544332211)},
+ {{0xef, 0xcd, 0xab, 0x90, 0x12, 0x34, 0x56, 0x78}, ULL(0x7856341290abcdef)},
+ {{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}, ULL(0x8877665544332211)},
};
TEST_2D(CodedStreamTest, ReadLittleEndian32, kFixed32Cases, kBlockSizes) {
@@ -647,8 +648,8 @@
memcpy(buffer_, kFixed32Cases_case.bytes, sizeof(kFixed32Cases_case.bytes));
uint32 value;
- const uint8* end = CodedInputStream::ReadLittleEndian32FromArray(
- buffer_, &value);
+ const uint8* end =
+ CodedInputStream::ReadLittleEndian32FromArray(buffer_, &value);
EXPECT_EQ(kFixed32Cases_case.value, value);
EXPECT_TRUE(end == buffer_ + sizeof(value));
}
@@ -657,8 +658,8 @@
memcpy(buffer_, kFixed64Cases_case.bytes, sizeof(kFixed64Cases_case.bytes));
uint64 value;
- const uint8* end = CodedInputStream::ReadLittleEndian64FromArray(
- buffer_, &value);
+ const uint8* end =
+ CodedInputStream::ReadLittleEndian64FromArray(buffer_, &value);
EXPECT_EQ(kFixed64Cases_case.value, value);
EXPECT_TRUE(end == buffer_ + sizeof(value));
}
@@ -933,7 +934,7 @@
// Skip
const char kSkipTestBytes[] =
- "<Before skipping><To be skipped><After skipping>";
+ "<Before skipping><To be skipped><After skipping>";
TEST_1D(CodedStreamTest, SkipInput, kBlockSizes) {
memcpy(buffer_, kSkipTestBytes, sizeof(kSkipTestBytes));
@@ -1240,7 +1241,8 @@
ASSERT_EQ(1, errors.size());
EXPECT_PRED_FORMAT2(testing::IsSubstring,
- "A protocol message was rejected because it was too big", errors[0]);
+ "A protocol message was rejected because it was too big",
+ errors[0]);
coded_input.SetTotalBytesLimit(32, -1);
EXPECT_EQ(16, coded_input.BytesUntilTotalBytesLimit());
@@ -1304,35 +1306,35 @@
coded_input.SetRecursionLimit(4);
// This is way too much testing for a counter.
- EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 1
- EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 2
- EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 3
- EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 4
- EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 5
- EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 6
- coded_input.DecrementRecursionDepth(); // 5
- EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 6
- coded_input.DecrementRecursionDepth(); // 5
- coded_input.DecrementRecursionDepth(); // 4
- coded_input.DecrementRecursionDepth(); // 3
- EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 4
- EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 5
- coded_input.DecrementRecursionDepth(); // 4
- coded_input.DecrementRecursionDepth(); // 3
- coded_input.DecrementRecursionDepth(); // 2
- coded_input.DecrementRecursionDepth(); // 1
- coded_input.DecrementRecursionDepth(); // 0
- coded_input.DecrementRecursionDepth(); // 0
- coded_input.DecrementRecursionDepth(); // 0
- EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 1
- EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 2
- EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 3
- EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 4
- EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 5
+ EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 1
+ EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 2
+ EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 3
+ EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 4
+ EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 5
+ EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 6
+ coded_input.DecrementRecursionDepth(); // 5
+ EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 6
+ coded_input.DecrementRecursionDepth(); // 5
+ coded_input.DecrementRecursionDepth(); // 4
+ coded_input.DecrementRecursionDepth(); // 3
+ EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 4
+ EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 5
+ coded_input.DecrementRecursionDepth(); // 4
+ coded_input.DecrementRecursionDepth(); // 3
+ coded_input.DecrementRecursionDepth(); // 2
+ coded_input.DecrementRecursionDepth(); // 1
+ coded_input.DecrementRecursionDepth(); // 0
+ coded_input.DecrementRecursionDepth(); // 0
+ coded_input.DecrementRecursionDepth(); // 0
+ EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 1
+ EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 2
+ EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 3
+ EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 4
+ EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 5
coded_input.SetRecursionLimit(6);
- EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 6
- EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 7
+ EXPECT_TRUE(coded_input.IncrementRecursionDepth()); // 6
+ EXPECT_FALSE(coded_input.IncrementRecursionDepth()); // 7
}
@@ -1364,12 +1366,16 @@
}
}
- void BackUp(int count) {
- backup_amount_ = count;
- }
+ void BackUp(int count) { backup_amount_ = count; }
- bool Skip(int count) { GOOGLE_LOG(FATAL) << "Not implemented."; return false; }
- int64 ByteCount() const { GOOGLE_LOG(FATAL) << "Not implemented."; return 0; }
+ bool Skip(int count) {
+ GOOGLE_LOG(FATAL) << "Not implemented.";
+ return false;
+ }
+ int64 ByteCount() const {
+ GOOGLE_LOG(FATAL) << "Not implemented.";
+ return 0;
+ }
int backup_amount_;
diff --git a/src/google/protobuf/io/gzip_stream.cc b/src/google/protobuf/io/gzip_stream.cc
index a569eff..a3e0438 100644
--- a/src/google/protobuf/io/gzip_stream.cc
+++ b/src/google/protobuf/io/gzip_stream.cc
@@ -46,8 +46,8 @@
static const int kDefaultBufferSize = 65536;
-GzipInputStream::GzipInputStream(
- ZeroCopyInputStream* sub_stream, Format format, int buffer_size)
+GzipInputStream::GzipInputStream(ZeroCopyInputStream* sub_stream, Format format,
+ int buffer_size)
: format_(format), sub_stream_(sub_stream), zerror_(Z_OK), byte_count_(0) {
zcontext_.state = Z_NULL;
zcontext_.zalloc = Z_NULL;
@@ -74,15 +74,21 @@
zerror_ = inflateEnd(&zcontext_);
}
-static inline int internalInflateInit2(
- z_stream* zcontext, GzipInputStream::Format format) {
+static inline int internalInflateInit2(z_stream* zcontext,
+ GzipInputStream::Format format) {
int windowBitsFormat = 0;
switch (format) {
- case GzipInputStream::GZIP: windowBitsFormat = 16; break;
- case GzipInputStream::AUTO: windowBitsFormat = 32; break;
- case GzipInputStream::ZLIB: windowBitsFormat = 0; break;
+ case GzipInputStream::GZIP:
+ windowBitsFormat = 16;
+ break;
+ case GzipInputStream::AUTO:
+ windowBitsFormat = 32;
+ break;
+ case GzipInputStream::ZLIB:
+ windowBitsFormat = 0;
+ break;
}
- return inflateInit2(zcontext, /* windowBits */15 | windowBitsFormat);
+ return inflateInit2(zcontext, /* windowBits */ 15 | windowBitsFormat);
}
int GzipInputStream::Inflate(int flush) {
@@ -122,8 +128,8 @@
// implements ZeroCopyInputStream ----------------------------------
bool GzipInputStream::Next(const void** data, int* size) {
- bool ok = (zerror_ == Z_OK) || (zerror_ == Z_STREAM_END)
- || (zerror_ == Z_BUF_ERROR);
+ bool ok = (zerror_ == Z_OK) || (zerror_ == Z_STREAM_END) ||
+ (zerror_ == Z_BUF_ERROR);
if ((!ok) || (zcontext_.next_out == NULL)) {
return false;
}
@@ -154,8 +160,8 @@
// The underlying stream's Next returned false inside Inflate.
return false;
}
- ok = (zerror_ == Z_OK) || (zerror_ == Z_STREAM_END)
- || (zerror_ == Z_BUF_ERROR);
+ ok = (zerror_ == Z_OK) || (zerror_ == Z_STREAM_END) ||
+ (zerror_ == Z_BUF_ERROR);
if (!ok) {
return false;
}
@@ -230,13 +236,10 @@
if (options.format == ZLIB) {
windowBitsFormat = 0;
}
- zerror_ = deflateInit2(
- &zcontext_,
- options.compression_level,
- Z_DEFLATED,
- /* windowBits */15 | windowBitsFormat,
- /* memLevel (default) */8,
- options.compression_strategy);
+ zerror_ =
+ deflateInit2(&zcontext_, options.compression_level, Z_DEFLATED,
+ /* windowBits */ 15 | windowBitsFormat,
+ /* memLevel (default) */ 8, options.compression_strategy);
}
GzipOutputStream::~GzipOutputStream() {
@@ -305,9 +308,9 @@
bool GzipOutputStream::Flush() {
zerror_ = Deflate(Z_FULL_FLUSH);
// Return true if the flush succeeded or if it was a no-op.
- return (zerror_ == Z_OK) ||
- (zerror_ == Z_BUF_ERROR && zcontext_.avail_in == 0 &&
- zcontext_.avail_out != 0);
+ return (zerror_ == Z_OK) ||
+ (zerror_ == Z_BUF_ERROR && zcontext_.avail_in == 0 &&
+ zcontext_.avail_out != 0);
}
bool GzipOutputStream::Close() {
diff --git a/src/google/protobuf/io/gzip_stream.h b/src/google/protobuf/io/gzip_stream.h
index b8eadfa..9980e5b 100644
--- a/src/google/protobuf/io/gzip_stream.h
+++ b/src/google/protobuf/io/gzip_stream.h
@@ -70,19 +70,13 @@
};
// buffer_size and format may be -1 for default of 64kB and GZIP format
- explicit GzipInputStream(
- ZeroCopyInputStream* sub_stream,
- Format format = AUTO,
- int buffer_size = -1);
+ explicit GzipInputStream(ZeroCopyInputStream* sub_stream,
+ Format format = AUTO, int buffer_size = -1);
virtual ~GzipInputStream();
// Return last error message or NULL if no error.
- inline const char* ZlibErrorMessage() const {
- return zcontext_.msg;
- }
- inline int ZlibErrorCode() const {
- return zerror_;
- }
+ inline const char* ZlibErrorMessage() const { return zcontext_.msg; }
+ inline int ZlibErrorCode() const { return zerror_; }
// implements ZeroCopyInputStream ----------------------------------
bool Next(const void** data, int* size);
@@ -143,19 +137,13 @@
explicit GzipOutputStream(ZeroCopyOutputStream* sub_stream);
// Create a GzipOutputStream with the given options.
- GzipOutputStream(
- ZeroCopyOutputStream* sub_stream,
- const Options& options);
+ GzipOutputStream(ZeroCopyOutputStream* sub_stream, const Options& options);
virtual ~GzipOutputStream();
// Return last error message or NULL if no error.
- inline const char* ZlibErrorMessage() const {
- return zcontext_.msg;
- }
- inline int ZlibErrorCode() const {
- return zerror_;
- }
+ inline const char* ZlibErrorMessage() const { return zcontext_.msg; }
+ inline int ZlibErrorCode() const { return zerror_; }
// Flushes data written so far to zipped data in the underlying stream.
// It is the caller's responsibility to flush the underlying stream if
diff --git a/src/google/protobuf/stubs/io_win32.cc b/src/google/protobuf/io/io_win32.cc
old mode 100644
new mode 100755
similarity index 98%
rename from src/google/protobuf/stubs/io_win32.cc
rename to src/google/protobuf/io/io_win32.cc
index d0f57df..b8f9bf8
--- a/src/google/protobuf/stubs/io_win32.cc
+++ b/src/google/protobuf/io/io_win32.cc
@@ -29,7 +29,9 @@
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Author: laszlocsomor@google.com (Laszlo Csomor)
-//
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
// Implementation for long-path-aware open/mkdir/access/etc. on Windows, as well
// as for the supporting utility functions.
//
@@ -58,7 +60,7 @@
#include <wctype.h>
#include <windows.h>
-#include <google/protobuf/stubs/io_win32.h>
+#include <google/protobuf/io/io_win32.h>
#include <memory>
#include <sstream>
@@ -67,7 +69,7 @@
namespace google {
namespace protobuf {
-namespace internal {
+namespace io {
namespace win32 {
namespace {
@@ -407,7 +409,7 @@
} // namespace strings
} // namespace win32
-} // namespace internal
+} // namespace io
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/stubs/io_win32.h b/src/google/protobuf/io/io_win32.h
old mode 100644
new mode 100755
similarity index 92%
rename from src/google/protobuf/stubs/io_win32.h
rename to src/google/protobuf/io/io_win32.h
index 69924dc..cf5cb32
--- a/src/google/protobuf/stubs/io_win32.h
+++ b/src/google/protobuf/io/io_win32.h
@@ -29,26 +29,28 @@
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Author: laszlocsomor@google.com (Laszlo Csomor)
-//
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
// This file contains the declarations for Windows implementations of
// commonly used POSIX functions such as open(2) and access(2), as well
// as macro definitions for flags of these functions.
//
// By including this file you'll redefine open/access/etc. to
-// ::google::protobuf::internal::win32::{open/access/etc.}.
+// ::google::protobuf::io::win32::{open/access/etc.}.
// Make sure you don't include a header that attempts to redeclare or
// redefine these functions, that'll lead to confusing compilation
// errors. It's best to #include this file as the last one to ensure that.
//
// This file is only used on Windows, it's empty on other platforms.
-#ifndef GOOGLE_PROTOBUF_STUBS_IO_WIN32_H__
-#define GOOGLE_PROTOBUF_STUBS_IO_WIN32_H__
+#ifndef GOOGLE_PROTOBUF_IO_IO_WIN32_H__
+#define GOOGLE_PROTOBUF_IO_IO_WIN32_H__
#if defined(_WIN32)
#include <string>
-#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/port.h>
#include <google/protobuf/port_def.inc>
@@ -56,7 +58,7 @@
// following functions already, except for mkdir.
namespace google {
namespace protobuf {
-namespace internal {
+namespace io {
namespace win32 {
PROTOBUF_EXPORT FILE* fopen(const char* path, const char* mode);
@@ -91,7 +93,7 @@
} // namespace strings
} // namespace win32
-} // namespace internal
+} // namespace io
} // namespace protobuf
} // namespace google
@@ -115,4 +117,4 @@
#endif // defined(_WIN32)
-#endif // GOOGLE_PROTOBUF_STUBS_IO_WIN32_H__
+#endif // GOOGLE_PROTOBUF_IO_IO_WIN32_H__
diff --git a/src/google/protobuf/stubs/io_win32_unittest.cc b/src/google/protobuf/io/io_win32_unittest.cc
old mode 100644
new mode 100755
similarity index 98%
rename from src/google/protobuf/stubs/io_win32_unittest.cc
rename to src/google/protobuf/io/io_win32_unittest.cc
index 6c70d46..53aa333
--- a/src/google/protobuf/stubs/io_win32_unittest.cc
+++ b/src/google/protobuf/io/io_win32_unittest.cc
@@ -29,7 +29,9 @@
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Author: laszlocsomor@google.com (Laszlo Csomor)
-//
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
// Unit tests for long-path-aware open/mkdir/access/etc. on Windows, as well as
// for the supporting utility functions.
//
@@ -47,7 +49,7 @@
#include <wchar.h>
#include <windows.h>
-#include <google/protobuf/stubs/io_win32.h>
+#include <google/protobuf/io/io_win32.h>
#include <gtest/gtest.h>
#include <memory>
@@ -56,7 +58,7 @@
namespace google {
namespace protobuf {
-namespace internal {
+namespace io {
namespace win32 {
namespace {
@@ -444,7 +446,7 @@
} // namespace
} // namespace win32
-} // namespace internal
+} // namespace io
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/io/printer.cc b/src/google/protobuf/io/printer.cc
index 736f063..6a86c58 100644
--- a/src/google/protobuf/io/printer.cc
+++ b/src/google/protobuf/io/printer.cc
@@ -34,10 +34,10 @@
#include <cctype>
-#include <google/protobuf/io/printer.h>
-#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/io/zero_copy_stream.h>
namespace google {
namespace protobuf {
@@ -182,9 +182,7 @@
WriteRaw(text + pos, size - pos);
}
-void Printer::Indent() {
- indent_ += " ";
-}
+void Printer::Indent() { indent_ += " "; }
void Printer::Outdent() {
if (indent_.empty()) {
diff --git a/src/google/protobuf/io/printer.h b/src/google/protobuf/io/printer.h
index a08ca65..a55946e 100644
--- a/src/google/protobuf/io/printer.h
+++ b/src/google/protobuf/io/printer.h
@@ -37,8 +37,8 @@
#ifndef GOOGLE_PROTOBUF_IO_PRINTER_H__
#define GOOGLE_PROTOBUF_IO_PRINTER_H__
-#include <string>
#include <map>
+#include <string>
#include <vector>
#include <google/protobuf/stubs/common.h>
@@ -48,7 +48,7 @@
namespace protobuf {
namespace io {
-class ZeroCopyOutputStream; // zero_copy_stream.h
+class ZeroCopyOutputStream; // zero_copy_stream.h
// Records annotations about a Printer's output.
class PROTOBUF_EXPORT AnnotationCollector {
diff --git a/src/google/protobuf/io/printer_unittest.cc b/src/google/protobuf/io/printer_unittest.cc
index 50a683e..b847fa7 100644
--- a/src/google/protobuf/io/printer_unittest.cc
+++ b/src/google/protobuf/io/printer_unittest.cc
@@ -77,10 +77,11 @@
buffer[output.ByteCount()] = '\0';
- EXPECT_STREQ("Hello World! This is the same line.\n"
- "But this is a new one.\n"
- "And this is another one.",
- buffer);
+ EXPECT_STREQ(
+ "Hello World! This is the same line.\n"
+ "But this is a new one.\n"
+ "And this is another one.",
+ buffer);
}
}
@@ -103,12 +104,13 @@
buffer[output.ByteCount()] = '\0';
- EXPECT_STREQ("Hello World! This is the same line.\n"
- "But this is a new one.\n"
- "And this is another one."
- "\n"
- "From an object\n",
- buffer);
+ EXPECT_STREQ(
+ "Hello World! This is the same line.\n"
+ "But this is a new one.\n"
+ "And this is another one."
+ "\n"
+ "From an object\n",
+ buffer);
}
}
@@ -138,13 +140,14 @@
buffer[output.ByteCount()] = '\0';
- EXPECT_STREQ("Hello World!\n"
- "bar = $foo$\n"
- "RawBit\n"
- "1234\n"
- "A literal dollar sign: $\n"
- "Now foo = blah.",
- buffer);
+ EXPECT_STREQ(
+ "Hello World!\n"
+ "bar = $foo$\n"
+ "RawBit\n"
+ "1234\n"
+ "A literal dollar sign: $\n"
+ "Now foo = blah.",
+ buffer);
}
}
@@ -163,10 +166,11 @@
buffer[output.ByteCount()] = '\0';
- EXPECT_STREQ("Hello World!\n"
- "RawBit\n"
- "one two\n",
- buffer);
+ EXPECT_STREQ(
+ "Hello World!\n"
+ "RawBit\n"
+ "one two\n",
+ buffer);
}
// MockDescriptorFile defines only those members that Printer uses to write out
@@ -435,7 +439,6 @@
EXPECT_EQ(4, ab->end());
}
-
TEST(Printer, Indenting) {
char buffer[8192];
@@ -454,11 +457,13 @@
printer.Outdent();
printer.Print("But this is not.");
printer.Indent();
- printer.Print(" And this is still the same line.\n"
- "But this is indented.\n");
+ printer.Print(
+ " And this is still the same line.\n"
+ "But this is indented.\n");
printer.PrintRaw("RawBit has indent at start\n");
printer.PrintRaw("but not after a raw newline\n");
- printer.Print(vars, "Note that a newline in a variable will break "
+ printer.Print(vars,
+ "Note that a newline in a variable will break "
"indenting, as we see$newline$here.\n");
printer.Indent();
printer.Print("And this");
@@ -472,18 +477,18 @@
buffer[output.ByteCount()] = '\0';
EXPECT_STREQ(
- "This is not indented.\n"
- " This is indented\n"
- " And so is this\n"
- "But this is not. And this is still the same line.\n"
- " But this is indented.\n"
- " RawBit has indent at start\n"
- "but not after a raw newline\n"
- "Note that a newline in a variable will break indenting, as we see\n"
- "here.\n"
- " And this is double-indented\n"
- "Back to normal.",
- buffer);
+ "This is not indented.\n"
+ " This is indented\n"
+ " And so is this\n"
+ "But this is not. And this is still the same line.\n"
+ " But this is indented.\n"
+ " RawBit has indent at start\n"
+ "but not after a raw newline\n"
+ "Note that a newline in a variable will break indenting, as we see\n"
+ "here.\n"
+ " And this is double-indented\n"
+ "Back to normal.",
+ buffer);
}
}
diff --git a/src/google/protobuf/io/strtod.cc b/src/google/protobuf/io/strtod.cc
index 7b17b57..42de296 100644
--- a/src/google/protobuf/io/strtod.cc
+++ b/src/google/protobuf/io/strtod.cc
@@ -49,6 +49,8 @@
namespace {
+const double MAX_FLOAT_AS_DOUBLE_ROUNDED = 3.4028235e+38;
+
// Returns a string identical to *input except that the character pointed to
// by radix_pos (which should be '.') is replaced with the locale-specific
// radix character.
@@ -61,7 +63,7 @@
char temp[16];
int size = sprintf(temp, "%.1f", 1.5);
GOOGLE_CHECK_EQ(temp[0], '1');
- GOOGLE_CHECK_EQ(temp[size-1], '5');
+ GOOGLE_CHECK_EQ(temp[size - 1], '5');
GOOGLE_CHECK_LE(size, 6);
// Now replace the '.' in the input with it.
@@ -94,8 +96,7 @@
const char* localized_cstr = localized.c_str();
char* localized_endptr;
result = strtod(localized_cstr, &localized_endptr);
- if ((localized_endptr - localized_cstr) >
- (temp_endptr - text)) {
+ if ((localized_endptr - localized_cstr) > (temp_endptr - text)) {
// This attempt got further, so replacing the decimal must have helped.
// Update original_endptr to point at the right location.
if (original_endptr != NULL) {
@@ -103,7 +104,7 @@
int size_diff = localized.size() - strlen(text);
// const_cast is necessary to match the strtod() interface.
*original_endptr = const_cast<char*>(
- text + (localized_endptr - localized_cstr - size_diff));
+ text + (localized_endptr - localized_cstr - size_diff));
}
}
@@ -111,9 +112,24 @@
}
float SafeDoubleToFloat(double value) {
+ // static_cast<float> on a number larger than float can result in illegal
+ // instruction error, so we need to manually convert it to infinity or max.
if (value > std::numeric_limits<float>::max()) {
+ // Max float value is about 3.4028234664E38 when represented as a double.
+ // However, when printing float as text, it will be rounded as
+ // 3.4028235e+38. If we parse the value of 3.4028235e+38 from text and
+ // compare it to 3.4028234664E38, we may think that it is larger, but
+ // actually, any number between these two numbers could only be represented
+ // as the same max float number in float, so we should treat them the same
+ // as max float.
+ if (value <= MAX_FLOAT_AS_DOUBLE_ROUNDED) {
+ return std::numeric_limits<float>::max();
+ }
return std::numeric_limits<float>::infinity();
} else if (value < -std::numeric_limits<float>::max()) {
+ if (value >= -MAX_FLOAT_AS_DOUBLE_ROUNDED) {
+ return -std::numeric_limits<float>::max();
+ }
return -std::numeric_limits<float>::infinity();
} else {
return static_cast<float>(value);
diff --git a/src/google/protobuf/io/tokenizer.cc b/src/google/protobuf/io/tokenizer.cc
index 8abcbd0..f8cf2eb 100644
--- a/src/google/protobuf/io/tokenizer.cc
+++ b/src/google/protobuf/io/tokenizer.cc
@@ -113,39 +113,34 @@
// Note: No class is allowed to contain '\0', since this is used to mark end-
// of-input and is handled specially.
-#define CHARACTER_CLASS(NAME, EXPRESSION) \
- class NAME { \
- public: \
- static inline bool InClass(char c) { \
- return EXPRESSION; \
- } \
+#define CHARACTER_CLASS(NAME, EXPRESSION) \
+ class NAME { \
+ public: \
+ static inline bool InClass(char c) { return EXPRESSION; } \
}
-CHARACTER_CLASS(Whitespace, c == ' ' || c == '\n' || c == '\t' ||
- c == '\r' || c == '\v' || c == '\f');
-CHARACTER_CLASS(WhitespaceNoNewline, c == ' ' || c == '\t' ||
- c == '\r' || c == '\v' || c == '\f');
+CHARACTER_CLASS(Whitespace, c == ' ' || c == '\n' || c == '\t' || c == '\r' ||
+ c == '\v' || c == '\f');
+CHARACTER_CLASS(WhitespaceNoNewline,
+ c == ' ' || c == '\t' || c == '\r' || c == '\v' || c == '\f');
-CHARACTER_CLASS(Unprintable, c < ' ' && c > '\0');
+CHARACTER_CLASS(Unprintable, c<' ' && c> '\0');
CHARACTER_CLASS(Digit, '0' <= c && c <= '9');
CHARACTER_CLASS(OctalDigit, '0' <= c && c <= '7');
-CHARACTER_CLASS(HexDigit, ('0' <= c && c <= '9') ||
- ('a' <= c && c <= 'f') ||
- ('A' <= c && c <= 'F'));
+CHARACTER_CLASS(HexDigit, ('0' <= c && c <= '9') || ('a' <= c && c <= 'f') ||
+ ('A' <= c && c <= 'F'));
-CHARACTER_CLASS(Letter, ('a' <= c && c <= 'z') ||
- ('A' <= c && c <= 'Z') ||
- (c == '_'));
+CHARACTER_CLASS(Letter,
+ ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || (c == '_'));
CHARACTER_CLASS(Alphanumeric, ('a' <= c && c <= 'z') ||
- ('A' <= c && c <= 'Z') ||
- ('0' <= c && c <= '9') ||
- (c == '_'));
+ ('A' <= c && c <= 'Z') ||
+ ('0' <= c && c <= '9') || (c == '_'));
CHARACTER_CLASS(Escape, c == 'a' || c == 'b' || c == 'f' || c == 'n' ||
- c == 'r' || c == 't' || c == 'v' || c == '\\' ||
- c == '?' || c == '\'' || c == '\"');
+ c == 'r' || c == 't' || c == 'v' || c == '\\' ||
+ c == '?' || c == '\'' || c == '\"');
#undef CHARACTER_CLASS
@@ -161,20 +156,32 @@
// Inline because it's only used in one place.
inline char TranslateEscape(char c) {
switch (c) {
- case 'a': return '\a';
- case 'b': return '\b';
- case 'f': return '\f';
- case 'n': return '\n';
- case 'r': return '\r';
- case 't': return '\t';
- case 'v': return '\v';
- case '\\': return '\\';
- case '?': return '\?'; // Trigraphs = :(
- case '\'': return '\'';
- case '"': return '\"';
+ case 'a':
+ return '\a';
+ case 'b':
+ return '\b';
+ case 'f':
+ return '\f';
+ case 'n':
+ return '\n';
+ case 'r':
+ return '\r';
+ case 't':
+ return '\t';
+ case 'v':
+ return '\v';
+ case '\\':
+ return '\\';
+ case '?':
+ return '\?'; // Trigraphs = :(
+ case '\'':
+ return '\'';
+ case '"':
+ return '\"';
// We expect escape sequences to have been validated separately.
- default: return '?';
+ default:
+ return '?';
}
}
@@ -186,21 +193,20 @@
Tokenizer::Tokenizer(ZeroCopyInputStream* input,
ErrorCollector* error_collector)
- : input_(input),
- error_collector_(error_collector),
- buffer_(NULL),
- buffer_size_(0),
- buffer_pos_(0),
- read_error_(false),
- line_(0),
- column_(0),
- record_target_(NULL),
- record_start_(-1),
- allow_f_after_float_(false),
- comment_style_(CPP_COMMENT_STYLE),
- require_space_after_number_(true),
- allow_multiline_strings_(false) {
-
+ : input_(input),
+ error_collector_(error_collector),
+ buffer_(NULL),
+ buffer_size_(0),
+ buffer_pos_(0),
+ read_error_(false),
+ line_(0),
+ column_(0),
+ record_target_(NULL),
+ record_start_(-1),
+ allow_f_after_float_(false),
+ comment_style_(CPP_COMMENT_STYLE),
+ require_space_after_number_(true),
+ allow_multiline_strings_(false) {
current_.line = 0;
current_.column = 0;
current_.end_column = 0;
@@ -249,7 +255,8 @@
// If we're in a token, append the rest of the buffer to it.
if (record_target_ != NULL && record_start_ < buffer_size_) {
- record_target_->append(buffer_ + record_start_, buffer_size_ - record_start_);
+ record_target_->append(buffer_ + record_start_,
+ buffer_size_ - record_start_);
record_start_ = 0;
}
@@ -282,14 +289,15 @@
// be helpful by detecting the NULL pointer, even though there's nothing
// wrong with reading zero bytes from NULL.
if (buffer_pos_ != record_start_) {
- record_target_->append(buffer_ + record_start_, buffer_pos_ - record_start_);
+ record_target_->append(buffer_ + record_start_,
+ buffer_pos_ - record_start_);
}
record_target_ = NULL;
record_start_ = -1;
}
inline void Tokenizer::StartToken() {
- current_.type = TYPE_START; // Just for the sake of initializing it.
+ current_.type = TYPE_START; // Just for the sake of initializing it.
current_.text.clear();
current_.line = line_;
current_.column = column_;
@@ -304,12 +312,12 @@
// -------------------------------------------------------------------
// Helper methods that consume characters.
-template<typename CharacterClass>
+template <typename CharacterClass>
inline bool Tokenizer::LookingAt() {
return CharacterClass::InClass(current_char_);
}
-template<typename CharacterClass>
+template <typename CharacterClass>
inline bool Tokenizer::TryConsumeOne() {
if (CharacterClass::InClass(current_char_)) {
NextChar();
@@ -328,14 +336,14 @@
}
}
-template<typename CharacterClass>
+template <typename CharacterClass>
inline void Tokenizer::ConsumeZeroOrMore() {
while (CharacterClass::InClass(current_char_)) {
NextChar();
}
}
-template<typename CharacterClass>
+template <typename CharacterClass>
inline void Tokenizer::ConsumeOneOrMore(const char* error) {
if (!CharacterClass::InClass(current_char_)) {
AddError(error);
@@ -381,25 +389,21 @@
}
// Possibly followed by another hex digit, but again we don't care.
} else if (TryConsume('u')) {
- if (!TryConsumeOne<HexDigit>() ||
- !TryConsumeOne<HexDigit>() ||
- !TryConsumeOne<HexDigit>() ||
- !TryConsumeOne<HexDigit>()) {
+ if (!TryConsumeOne<HexDigit>() || !TryConsumeOne<HexDigit>() ||
+ !TryConsumeOne<HexDigit>() || !TryConsumeOne<HexDigit>()) {
AddError("Expected four hex digits for \\u escape sequence.");
}
} else if (TryConsume('U')) {
// We expect 8 hex digits; but only the range up to 0x10ffff is
// legal.
- if (!TryConsume('0') ||
- !TryConsume('0') ||
+ if (!TryConsume('0') || !TryConsume('0') ||
!(TryConsume('0') || TryConsume('1')) ||
- !TryConsumeOne<HexDigit>() ||
- !TryConsumeOne<HexDigit>() ||
- !TryConsumeOne<HexDigit>() ||
- !TryConsumeOne<HexDigit>() ||
+ !TryConsumeOne<HexDigit>() || !TryConsumeOne<HexDigit>() ||
+ !TryConsumeOne<HexDigit>() || !TryConsumeOne<HexDigit>() ||
!TryConsumeOne<HexDigit>()) {
- AddError("Expected eight hex digits up to 10ffff for \\U escape "
- "sequence");
+ AddError(
+ "Expected eight hex digits up to 10ffff for \\U escape "
+ "sequence");
}
} else {
AddError("Invalid escape sequence in string literal.");
@@ -465,7 +469,7 @@
} else if (current_char_ == '.') {
if (is_float) {
AddError(
- "Already saw decimal point or exponent; can't have another one.");
+ "Already saw decimal point or exponent; can't have another one.");
} else {
AddError("Hex and octal numbers must be integers.");
}
@@ -492,10 +496,8 @@
if (content != NULL) RecordTo(content);
while (true) {
- while (current_char_ != '\0' &&
- current_char_ != '*' &&
- current_char_ != '/' &&
- current_char_ != '\n') {
+ while (current_char_ != '\0' && current_char_ != '*' &&
+ current_char_ != '/' && current_char_ != '\n') {
NextChar();
}
@@ -524,11 +526,11 @@
// Note: We didn't consume the '*' because if there is a '/' after it
// we want to interpret that as the end of the comment.
AddError(
- "\"/*\" inside block comment. Block comments cannot be nested.");
+ "\"/*\" inside block comment. Block comments cannot be nested.");
} else if (current_char_ == '\0') {
AddError("End-of-file inside block comment.");
- error_collector_->AddError(
- start_line, start_column, " Comment started here.");
+ error_collector_->AddError(start_line, start_column,
+ " Comment started here.");
if (content != NULL) StopRecording();
break;
}
@@ -613,8 +615,9 @@
current_.line == previous_.line &&
current_.column == previous_.end_column) {
// We don't accept syntax like "blah.123".
- error_collector_->AddError(line_, column_ - 2,
- "Need space between identifier and decimal point.");
+ error_collector_->AddError(
+ line_, column_ - 2,
+ "Need space between identifier and decimal point.");
}
current_.type = ConsumeNumber(false, true);
} else {
@@ -631,7 +634,8 @@
} else {
// Check if the high order bit is set.
if (current_char_ & 0x80) {
- error_collector_->AddError(line_, column_,
+ error_collector_->AddError(
+ line_, column_,
StringPrintf("Interpreting non ascii codepoint %d.",
static_cast<unsigned char>(current_char_)));
}
@@ -731,9 +735,7 @@
}
}
- void DetachFromPrev() {
- can_attach_to_prev_ = false;
- }
+ void DetachFromPrev() { can_attach_to_prev_ = false; }
private:
std::string* prev_trailing_comments_;
@@ -754,7 +756,7 @@
bool can_attach_to_prev_;
};
-} // namespace
+} // namespace
bool Tokenizer::NextWithComments(std::string* prev_trailing_comments,
std::vector<std::string>* detached_comments,
@@ -767,8 +769,9 @@
// beginning. Only UTF-8 BOM (0xEF 0xBB 0xBF) is accepted.
if (TryConsume((char)0xEF)) {
if (!TryConsume((char)0xBB) || !TryConsume((char)0xBF)) {
- AddError("Proto file starts with 0xEF but not UTF-8 BOM. "
- "Only UTF-8 is accepted for proto file.");
+ AddError(
+ "Proto file starts with 0xEF but not UTF-8 BOM. "
+ "Only UTF-8 is accepted for proto file.");
return false;
}
}
@@ -836,9 +839,7 @@
collector.DetachFromPrev();
} else {
bool result = Next();
- if (!result ||
- current_.text == "}" ||
- current_.text == "]" ||
+ if (!result || current_.text == "}" || current_.text == "]" ||
current_.text == ")") {
// It looks like we're at the end of a scope. In this case it
// makes no sense to attach a comment to the following token.
@@ -863,7 +864,7 @@
// Sadly, we can't just use strtoul() since it is only 32-bit and strtoull()
// is non-standard. I hate the C standard library. :(
-// return strtoull(text.c_str(), NULL, 0);
+ // return strtoull(text.c_str(), NULL, 0);
const char* ptr = text.c_str();
int base = 10;
@@ -917,8 +918,9 @@
}
GOOGLE_LOG_IF(DFATAL, end - start != text.size() || *start == '-')
- << " Tokenizer::ParseFloat() passed text that could not have been"
- " tokenized as a float: " << CEscape(text);
+ << " Tokenizer::ParseFloat() passed text that could not have been"
+ " tokenized as a float: "
+ << CEscape(text);
return result;
}
@@ -931,22 +933,16 @@
tmp = code_point;
len = 1;
} else if (code_point <= 0x07ff) {
- tmp = 0x0000c080 |
- ((code_point & 0x07c0) << 2) |
- (code_point & 0x003f);
+ tmp = 0x0000c080 | ((code_point & 0x07c0) << 2) | (code_point & 0x003f);
len = 2;
} else if (code_point <= 0xffff) {
- tmp = 0x00e08080 |
- ((code_point & 0xf000) << 4) |
- ((code_point & 0x0fc0) << 2) |
- (code_point & 0x003f);
+ tmp = 0x00e08080 | ((code_point & 0xf000) << 4) |
+ ((code_point & 0x0fc0) << 2) | (code_point & 0x003f);
len = 3;
} else if (code_point <= 0x1fffff) {
- tmp = 0xf0808080 |
- ((code_point & 0x1c0000) << 6) |
- ((code_point & 0x03f000) << 4) |
- ((code_point & 0x000fc0) << 2) |
- (code_point & 0x003f);
+ tmp = 0xf0808080 | ((code_point & 0x1c0000) << 6) |
+ ((code_point & 0x03f000) << 4) | ((code_point & 0x000fc0) << 2) |
+ (code_point & 0x003f);
len = 4;
} else {
// UTF-16 is only defined for code points up to 0x10FFFF, and UTF-8 is
@@ -986,7 +982,7 @@
static inline bool IsTrailSurrogate(uint32 code_point) {
return (code_point >= kMinTrailSurrogate) &&
- (code_point < kMaxTrailSurrogate);
+ (code_point < kMaxTrailSurrogate);
}
// Combine a head and trail surrogate into a single Unicode code point.
@@ -994,7 +990,7 @@
GOOGLE_DCHECK(IsHeadSurrogate(head_surrogate));
GOOGLE_DCHECK(IsTrailSurrogate(trail_surrogate));
return 0x10000 + (((head_surrogate - kMinHeadSurrogate) << 10) |
- (trail_surrogate - kMinTrailSurrogate));
+ (trail_surrogate - kMinTrailSurrogate));
}
// Convert the escape sequence parameter to a number of expected hex digits.
@@ -1012,8 +1008,7 @@
const char* p = ptr;
// Fetch the code point.
const int len = UnicodeLength(*p++);
- if (!ReadHexDigits(p, len, code_point))
- return ptr;
+ if (!ReadHexDigits(p, len, code_point)) return ptr;
p += len;
// Check if the code point we read is a "head surrogate." If so, then we
@@ -1042,9 +1037,9 @@
// empty, it's invalid, so we'll just return).
const size_t text_size = text.size();
if (text_size == 0) {
- GOOGLE_LOG(DFATAL)
- << " Tokenizer::ParseStringAppend() passed text that could not"
- " have been tokenized as a string: " << CEscape(text);
+ GOOGLE_LOG(DFATAL) << " Tokenizer::ParseStringAppend() passed text that could not"
+ " have been tokenized as a string: "
+ << CEscape(text);
return;
}
@@ -1118,20 +1113,16 @@
template <typename CharacterClass>
static bool AllInClass(const std::string& s) {
for (int i = 0; i < s.size(); ++i) {
- if (!CharacterClass::InClass(s[i]))
- return false;
+ if (!CharacterClass::InClass(s[i])) return false;
}
return true;
}
bool Tokenizer::IsIdentifier(const std::string& text) {
// Mirrors IDENTIFIER definition in Tokenizer::Next() above.
- if (text.size() == 0)
- return false;
- if (!Letter::InClass(text.at(0)))
- return false;
- if (!AllInClass<Alphanumeric>(text.substr(1)))
- return false;
+ if (text.size() == 0) return false;
+ if (!Letter::InClass(text.at(0))) return false;
+ if (!AllInClass<Alphanumeric>(text.substr(1))) return false;
return true;
}
diff --git a/src/google/protobuf/io/tokenizer.h b/src/google/protobuf/io/tokenizer.h
index 4816814..cb33b93 100644
--- a/src/google/protobuf/io/tokenizer.h
+++ b/src/google/protobuf/io/tokenizer.h
@@ -48,7 +48,7 @@
namespace protobuf {
namespace io {
-class ZeroCopyInputStream; // zero_copy_stream.h
+class ZeroCopyInputStream; // zero_copy_stream.h
// Defined in this file.
class ErrorCollector;
@@ -99,8 +99,8 @@
~Tokenizer();
enum TokenType {
- TYPE_START, // Next() has not yet been called.
- TYPE_END, // End of input reached. "text" is empty.
+ TYPE_START, // Next() has not yet been called.
+ TYPE_END, // End of input reached. "text" is empty.
TYPE_IDENTIFIER, // A sequence of letters, digits, and underscores, not
// starting with a digit. It is an error for a number
@@ -258,17 +258,17 @@
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Tokenizer);
- Token current_; // Returned by current().
- Token previous_; // Returned by previous().
+ Token current_; // Returned by current().
+ Token previous_; // Returned by previous().
ZeroCopyInputStream* input_;
ErrorCollector* error_collector_;
- char current_char_; // == buffer_[buffer_pos_], updated by NextChar().
- const char* buffer_; // Current buffer returned from input_.
- int buffer_size_; // Size of buffer_.
- int buffer_pos_; // Current position within the buffer.
- bool read_error_; // Did we previously encounter a read error?
+ char current_char_; // == buffer_[buffer_pos_], updated by NextChar().
+ const char* buffer_; // Current buffer returned from input_.
+ int buffer_size_; // Size of buffer_.
+ int buffer_pos_; // Current position within the buffer.
+ bool read_error_; // Did we previously encounter a read error?
// Line and column number of current_char_ within the whole input stream.
int line_;
@@ -369,37 +369,33 @@
// Returns true if the current character is of the given character
// class, but does not consume anything.
- template<typename CharacterClass>
+ template <typename CharacterClass>
inline bool LookingAt();
// If the current character is in the given class, consume it and return
// true. Otherwise return false.
// e.g. TryConsumeOne<Letter>()
- template<typename CharacterClass>
+ template <typename CharacterClass>
inline bool TryConsumeOne();
// Like above, but try to consume the specific character indicated.
inline bool TryConsume(char c);
// Consume zero or more of the given character class.
- template<typename CharacterClass>
+ template <typename CharacterClass>
inline void ConsumeZeroOrMore();
// Consume one or more of the given character class or log the given
// error message.
// e.g. ConsumeOneOrMore<Digit>("Expected digits.");
- template<typename CharacterClass>
+ template <typename CharacterClass>
inline void ConsumeOneOrMore(const char* error);
};
// inline methods ====================================================
-inline const Tokenizer::Token& Tokenizer::current() {
- return current_;
-}
+inline const Tokenizer::Token& Tokenizer::current() { return current_; }
-inline const Tokenizer::Token& Tokenizer::previous() {
- return previous_;
-}
+inline const Tokenizer::Token& Tokenizer::previous() { return previous_; }
inline void Tokenizer::ParseString(const std::string& text,
std::string* output) {
diff --git a/src/google/protobuf/io/tokenizer_unittest.cc b/src/google/protobuf/io/tokenizer_unittest.cc
index 3dbee86..37628ab 100644
--- a/src/google/protobuf/io/tokenizer_unittest.cc
+++ b/src/google/protobuf/io/tokenizer_unittest.cc
@@ -75,45 +75,45 @@
// which failed will be printed. The case type must be printable using
// ostream::operator<<.
-#define TEST_1D(FIXTURE, NAME, CASES) \
- class FIXTURE##_##NAME##_DD : public FIXTURE { \
- protected: \
- template <typename CaseType> \
- void DoSingleCase(const CaseType& CASES##_case); \
- }; \
- \
- TEST_F(FIXTURE##_##NAME##_DD, NAME) { \
- for (int i = 0; i < GOOGLE_ARRAYSIZE(CASES); i++) { \
- SCOPED_TRACE(testing::Message() \
- << #CASES " case #" << i << ": " << CASES[i]); \
- DoSingleCase(CASES[i]); \
- } \
- } \
- \
- template <typename CaseType> \
+#define TEST_1D(FIXTURE, NAME, CASES) \
+ class FIXTURE##_##NAME##_DD : public FIXTURE { \
+ protected: \
+ template <typename CaseType> \
+ void DoSingleCase(const CaseType& CASES##_case); \
+ }; \
+ \
+ TEST_F(FIXTURE##_##NAME##_DD, NAME) { \
+ for (int i = 0; i < GOOGLE_ARRAYSIZE(CASES); i++) { \
+ SCOPED_TRACE(testing::Message() \
+ << #CASES " case #" << i << ": " << CASES[i]); \
+ DoSingleCase(CASES[i]); \
+ } \
+ } \
+ \
+ template <typename CaseType> \
void FIXTURE##_##NAME##_DD::DoSingleCase(const CaseType& CASES##_case)
-#define TEST_2D(FIXTURE, NAME, CASES1, CASES2) \
- class FIXTURE##_##NAME##_DD : public FIXTURE { \
- protected: \
- template <typename CaseType1, typename CaseType2> \
- void DoSingleCase(const CaseType1& CASES1##_case, \
- const CaseType2& CASES2##_case); \
- }; \
- \
- TEST_F(FIXTURE##_##NAME##_DD, NAME) { \
- for (int i = 0; i < GOOGLE_ARRAYSIZE(CASES1); i++) { \
- for (int j = 0; j < GOOGLE_ARRAYSIZE(CASES2); j++) { \
- SCOPED_TRACE(testing::Message() \
- << #CASES1 " case #" << i << ": " << CASES1[i] << ", " \
- << #CASES2 " case #" << j << ": " << CASES2[j]); \
- DoSingleCase(CASES1[i], CASES2[j]); \
- } \
- } \
- } \
- \
- template <typename CaseType1, typename CaseType2> \
- void FIXTURE##_##NAME##_DD::DoSingleCase(const CaseType1& CASES1##_case, \
+#define TEST_2D(FIXTURE, NAME, CASES1, CASES2) \
+ class FIXTURE##_##NAME##_DD : public FIXTURE { \
+ protected: \
+ template <typename CaseType1, typename CaseType2> \
+ void DoSingleCase(const CaseType1& CASES1##_case, \
+ const CaseType2& CASES2##_case); \
+ }; \
+ \
+ TEST_F(FIXTURE##_##NAME##_DD, NAME) { \
+ for (int i = 0; i < GOOGLE_ARRAYSIZE(CASES1); i++) { \
+ for (int j = 0; j < GOOGLE_ARRAYSIZE(CASES2); j++) { \
+ SCOPED_TRACE(testing::Message() \
+ << #CASES1 " case #" << i << ": " << CASES1[i] << ", " \
+ << #CASES2 " case #" << j << ": " << CASES2[j]); \
+ DoSingleCase(CASES1[i], CASES2[j]); \
+ } \
+ } \
+ } \
+ \
+ template <typename CaseType1, typename CaseType2> \
+ void FIXTURE##_##NAME##_DD::DoSingleCase(const CaseType1& CASES1##_case, \
const CaseType2& CASES2##_case)
// -------------------------------------------------------------------
@@ -123,7 +123,7 @@
class TestInputStream : public ZeroCopyInputStream {
public:
TestInputStream(const void* data, int size, int block_size)
- : array_stream_(data, size, block_size), counter_(0) {}
+ : array_stream_(data, size, block_size), counter_(0) {}
~TestInputStream() {}
// implements ZeroCopyInputStream ----------------------------------
@@ -141,9 +141,9 @@
}
}
- void BackUp(int count) { return array_stream_.BackUp(count); }
- bool Skip(int count) { return array_stream_.Skip(count); }
- int64 ByteCount() const { return array_stream_.ByteCount(); }
+ void BackUp(int count) { return array_stream_.BackUp(count); }
+ bool Skip(int count) { return array_stream_.Skip(count); }
+ int64 ByteCount() const { return array_stream_.ByteCount(); }
private:
ArrayInputStream array_stream_;
@@ -163,8 +163,7 @@
// implements ErrorCollector ---------------------------------------
void AddError(int line, int column, const std::string& message) {
- strings::SubstituteAndAppend(&text_, "$0:$1: $2\n",
- line, column, message);
+ strings::SubstituteAndAppend(&text_, "$0:$1: $2\n", line, column, message);
}
};
@@ -205,52 +204,51 @@
}
SimpleTokenCase kSimpleTokenCases[] = {
- // Test identifiers.
- { "hello", Tokenizer::TYPE_IDENTIFIER },
+ // Test identifiers.
+ {"hello", Tokenizer::TYPE_IDENTIFIER},
- // Test integers.
- { "123", Tokenizer::TYPE_INTEGER },
- { "0xab6", Tokenizer::TYPE_INTEGER },
- { "0XAB6", Tokenizer::TYPE_INTEGER },
- { "0X1234567", Tokenizer::TYPE_INTEGER },
- { "0x89abcdef", Tokenizer::TYPE_INTEGER },
- { "0x89ABCDEF", Tokenizer::TYPE_INTEGER },
- { "01234567", Tokenizer::TYPE_INTEGER },
+ // Test integers.
+ {"123", Tokenizer::TYPE_INTEGER},
+ {"0xab6", Tokenizer::TYPE_INTEGER},
+ {"0XAB6", Tokenizer::TYPE_INTEGER},
+ {"0X1234567", Tokenizer::TYPE_INTEGER},
+ {"0x89abcdef", Tokenizer::TYPE_INTEGER},
+ {"0x89ABCDEF", Tokenizer::TYPE_INTEGER},
+ {"01234567", Tokenizer::TYPE_INTEGER},
- // Test floats.
- { "123.45", Tokenizer::TYPE_FLOAT },
- { "1.", Tokenizer::TYPE_FLOAT },
- { "1e3", Tokenizer::TYPE_FLOAT },
- { "1E3", Tokenizer::TYPE_FLOAT },
- { "1e-3", Tokenizer::TYPE_FLOAT },
- { "1e+3", Tokenizer::TYPE_FLOAT },
- { "1.e3", Tokenizer::TYPE_FLOAT },
- { "1.2e3", Tokenizer::TYPE_FLOAT },
- { ".1", Tokenizer::TYPE_FLOAT },
- { ".1e3", Tokenizer::TYPE_FLOAT },
- { ".1e-3", Tokenizer::TYPE_FLOAT },
- { ".1e+3", Tokenizer::TYPE_FLOAT },
+ // Test floats.
+ {"123.45", Tokenizer::TYPE_FLOAT},
+ {"1.", Tokenizer::TYPE_FLOAT},
+ {"1e3", Tokenizer::TYPE_FLOAT},
+ {"1E3", Tokenizer::TYPE_FLOAT},
+ {"1e-3", Tokenizer::TYPE_FLOAT},
+ {"1e+3", Tokenizer::TYPE_FLOAT},
+ {"1.e3", Tokenizer::TYPE_FLOAT},
+ {"1.2e3", Tokenizer::TYPE_FLOAT},
+ {".1", Tokenizer::TYPE_FLOAT},
+ {".1e3", Tokenizer::TYPE_FLOAT},
+ {".1e-3", Tokenizer::TYPE_FLOAT},
+ {".1e+3", Tokenizer::TYPE_FLOAT},
- // Test strings.
- { "'hello'", Tokenizer::TYPE_STRING },
- { "\"foo\"", Tokenizer::TYPE_STRING },
- { "'a\"b'", Tokenizer::TYPE_STRING },
- { "\"a'b\"", Tokenizer::TYPE_STRING },
- { "'a\\'b'", Tokenizer::TYPE_STRING },
- { "\"a\\\"b\"", Tokenizer::TYPE_STRING },
- { "'\\xf'", Tokenizer::TYPE_STRING },
- { "'\\0'", Tokenizer::TYPE_STRING },
+ // Test strings.
+ {"'hello'", Tokenizer::TYPE_STRING},
+ {"\"foo\"", Tokenizer::TYPE_STRING},
+ {"'a\"b'", Tokenizer::TYPE_STRING},
+ {"\"a'b\"", Tokenizer::TYPE_STRING},
+ {"'a\\'b'", Tokenizer::TYPE_STRING},
+ {"\"a\\\"b\"", Tokenizer::TYPE_STRING},
+ {"'\\xf'", Tokenizer::TYPE_STRING},
+ {"'\\0'", Tokenizer::TYPE_STRING},
- // Test symbols.
- { "+", Tokenizer::TYPE_SYMBOL },
- { ".", Tokenizer::TYPE_SYMBOL },
+ // Test symbols.
+ {"+", Tokenizer::TYPE_SYMBOL},
+ {".", Tokenizer::TYPE_SYMBOL},
};
TEST_2D(TokenizerTest, SimpleTokens, kSimpleTokenCases, kBlockSizes) {
// Set up the tokenizer.
TestInputStream input(kSimpleTokenCases_case.input.data(),
- kSimpleTokenCases_case.input.size(),
- kBlockSizes_case);
+ kSimpleTokenCases_case.input.size(), kBlockSizes_case);
TestErrorCollector error_collector;
Tokenizer tokenizer(&input, &error_collector);
@@ -339,92 +337,101 @@
}
MultiTokenCase kMultiTokenCases[] = {
- // Test empty input.
- { "", {
- { Tokenizer::TYPE_END , "" , 0, 0, 0 },
- }},
+ // Test empty input.
+ {"",
+ {
+ {Tokenizer::TYPE_END, "", 0, 0, 0},
+ }},
- // Test all token types at the same time.
- { "foo 1 1.2 + 'bar'", {
- { Tokenizer::TYPE_IDENTIFIER, "foo" , 0, 0, 3 },
- { Tokenizer::TYPE_INTEGER , "1" , 0, 4, 5 },
- { Tokenizer::TYPE_FLOAT , "1.2" , 0, 6, 9 },
- { Tokenizer::TYPE_SYMBOL , "+" , 0, 10, 11 },
- { Tokenizer::TYPE_STRING , "'bar'", 0, 12, 17 },
- { Tokenizer::TYPE_END , "" , 0, 17, 17 },
- }},
+ // Test all token types at the same time.
+ {"foo 1 1.2 + 'bar'",
+ {
+ {Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3},
+ {Tokenizer::TYPE_INTEGER, "1", 0, 4, 5},
+ {Tokenizer::TYPE_FLOAT, "1.2", 0, 6, 9},
+ {Tokenizer::TYPE_SYMBOL, "+", 0, 10, 11},
+ {Tokenizer::TYPE_STRING, "'bar'", 0, 12, 17},
+ {Tokenizer::TYPE_END, "", 0, 17, 17},
+ }},
- // Test that consecutive symbols are parsed as separate tokens.
- { "!@+%", {
- { Tokenizer::TYPE_SYMBOL , "!" , 0, 0, 1 },
- { Tokenizer::TYPE_SYMBOL , "@" , 0, 1, 2 },
- { Tokenizer::TYPE_SYMBOL , "+" , 0, 2, 3 },
- { Tokenizer::TYPE_SYMBOL , "%" , 0, 3, 4 },
- { Tokenizer::TYPE_END , "" , 0, 4, 4 },
- }},
+ // Test that consecutive symbols are parsed as separate tokens.
+ {"!@+%",
+ {
+ {Tokenizer::TYPE_SYMBOL, "!", 0, 0, 1},
+ {Tokenizer::TYPE_SYMBOL, "@", 0, 1, 2},
+ {Tokenizer::TYPE_SYMBOL, "+", 0, 2, 3},
+ {Tokenizer::TYPE_SYMBOL, "%", 0, 3, 4},
+ {Tokenizer::TYPE_END, "", 0, 4, 4},
+ }},
- // Test that newlines affect line numbers correctly.
- { "foo bar\nrab oof", {
- { Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3 },
- { Tokenizer::TYPE_IDENTIFIER, "bar", 0, 4, 7 },
- { Tokenizer::TYPE_IDENTIFIER, "rab", 1, 0, 3 },
- { Tokenizer::TYPE_IDENTIFIER, "oof", 1, 4, 7 },
- { Tokenizer::TYPE_END , "" , 1, 7, 7 },
- }},
+ // Test that newlines affect line numbers correctly.
+ {"foo bar\nrab oof",
+ {
+ {Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3},
+ {Tokenizer::TYPE_IDENTIFIER, "bar", 0, 4, 7},
+ {Tokenizer::TYPE_IDENTIFIER, "rab", 1, 0, 3},
+ {Tokenizer::TYPE_IDENTIFIER, "oof", 1, 4, 7},
+ {Tokenizer::TYPE_END, "", 1, 7, 7},
+ }},
- // Test that tabs affect column numbers correctly.
- { "foo\tbar \tbaz", {
- { Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3 },
- { Tokenizer::TYPE_IDENTIFIER, "bar", 0, 8, 11 },
- { Tokenizer::TYPE_IDENTIFIER, "baz", 0, 16, 19 },
- { Tokenizer::TYPE_END , "" , 0, 19, 19 },
- }},
+ // Test that tabs affect column numbers correctly.
+ {"foo\tbar \tbaz",
+ {
+ {Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3},
+ {Tokenizer::TYPE_IDENTIFIER, "bar", 0, 8, 11},
+ {Tokenizer::TYPE_IDENTIFIER, "baz", 0, 16, 19},
+ {Tokenizer::TYPE_END, "", 0, 19, 19},
+ }},
- // Test that tabs in string literals affect column numbers correctly.
- { "\"foo\tbar\" baz", {
- { Tokenizer::TYPE_STRING , "\"foo\tbar\"", 0, 0, 12 },
- { Tokenizer::TYPE_IDENTIFIER, "baz" , 0, 13, 16 },
- { Tokenizer::TYPE_END , "" , 0, 16, 16 },
- }},
+ // Test that tabs in string literals affect column numbers correctly.
+ {"\"foo\tbar\" baz",
+ {
+ {Tokenizer::TYPE_STRING, "\"foo\tbar\"", 0, 0, 12},
+ {Tokenizer::TYPE_IDENTIFIER, "baz", 0, 13, 16},
+ {Tokenizer::TYPE_END, "", 0, 16, 16},
+ }},
- // Test that line comments are ignored.
- { "foo // This is a comment\n"
- "bar // This is another comment", {
- { Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3 },
- { Tokenizer::TYPE_IDENTIFIER, "bar", 1, 0, 3 },
- { Tokenizer::TYPE_END , "" , 1, 30, 30 },
- }},
+ // Test that line comments are ignored.
+ {"foo // This is a comment\n"
+ "bar // This is another comment",
+ {
+ {Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3},
+ {Tokenizer::TYPE_IDENTIFIER, "bar", 1, 0, 3},
+ {Tokenizer::TYPE_END, "", 1, 30, 30},
+ }},
- // Test that block comments are ignored.
- { "foo /* This is a block comment */ bar", {
- { Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3 },
- { Tokenizer::TYPE_IDENTIFIER, "bar", 0, 34, 37 },
- { Tokenizer::TYPE_END , "" , 0, 37, 37 },
- }},
+ // Test that block comments are ignored.
+ {"foo /* This is a block comment */ bar",
+ {
+ {Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3},
+ {Tokenizer::TYPE_IDENTIFIER, "bar", 0, 34, 37},
+ {Tokenizer::TYPE_END, "", 0, 37, 37},
+ }},
- // Test that sh-style comments are not ignored by default.
- { "foo # bar\n"
- "baz", {
- { Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3 },
- { Tokenizer::TYPE_SYMBOL , "#" , 0, 4, 5 },
- { Tokenizer::TYPE_IDENTIFIER, "bar", 0, 6, 9 },
- { Tokenizer::TYPE_IDENTIFIER, "baz", 1, 0, 3 },
- { Tokenizer::TYPE_END , "" , 1, 3, 3 },
- }},
+ // Test that sh-style comments are not ignored by default.
+ {"foo # bar\n"
+ "baz",
+ {
+ {Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3},
+ {Tokenizer::TYPE_SYMBOL, "#", 0, 4, 5},
+ {Tokenizer::TYPE_IDENTIFIER, "bar", 0, 6, 9},
+ {Tokenizer::TYPE_IDENTIFIER, "baz", 1, 0, 3},
+ {Tokenizer::TYPE_END, "", 1, 3, 3},
+ }},
- // Test all whitespace chars
- { "foo\n\t\r\v\fbar", {
- { Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3 },
- { Tokenizer::TYPE_IDENTIFIER, "bar", 1, 11, 14 },
- { Tokenizer::TYPE_END , "" , 1, 14, 14 },
- }},
+ // Test all whitespace chars
+ {"foo\n\t\r\v\fbar",
+ {
+ {Tokenizer::TYPE_IDENTIFIER, "foo", 0, 0, 3},
+ {Tokenizer::TYPE_IDENTIFIER, "bar", 1, 11, 14},
+ {Tokenizer::TYPE_END, "", 1, 14, 14},
+ }},
};
TEST_2D(TokenizerTest, MultipleTokens, kMultiTokenCases, kBlockSizes) {
// Set up the tokenizer.
TestInputStream input(kMultiTokenCases_case.input.data(),
- kMultiTokenCases_case.input.size(),
- kBlockSizes_case);
+ kMultiTokenCases_case.input.size(), kBlockSizes_case);
TestErrorCollector error_collector;
Tokenizer tokenizer(&input, &error_collector);
@@ -479,14 +486,14 @@
TEST_1D(TokenizerTest, ShCommentStyle, kBlockSizes) {
// Test the "comment_style" option.
- const char* text = "foo # bar\n"
- "baz // qux\n"
- "corge /* grault */\n"
- "garply";
+ const char* text =
+ "foo # bar\n"
+ "baz // qux\n"
+ "corge /* grault */\n"
+ "garply";
const char* const kTokens[] = {"foo", // "# bar" is ignored
- "baz", "/", "/", "qux",
- "corge", "/", "*", "grault", "*", "/",
- "garply"};
+ "baz", "/", "/", "qux", "corge", "/",
+ "*", "grault", "*", "/", "garply"};
// Set up the tokenizer.
TestInputStream input(text, strlen(text), kBlockSizes_case);
@@ -526,164 +533,136 @@
}
DocCommentCase kDocCommentCases[] = {
- {
- "prev next",
+ {"prev next",
- "",
- {},
- ""
- },
+ "",
+ {},
+ ""},
- {
- "prev /* ignored */ next",
+ {"prev /* ignored */ next",
- "",
- {},
- ""
- },
+ "",
+ {},
+ ""},
- {
- "prev // trailing comment\n"
- "next",
+ {"prev // trailing comment\n"
+ "next",
- " trailing comment\n",
- {},
- ""
- },
+ " trailing comment\n",
+ {},
+ ""},
- {
- "prev\n"
- "// leading comment\n"
- "// line 2\n"
- "next",
+ {"prev\n"
+ "// leading comment\n"
+ "// line 2\n"
+ "next",
- "",
- {},
- " leading comment\n"
- " line 2\n"
- },
+ "",
+ {},
+ " leading comment\n"
+ " line 2\n"},
- {
- "prev\n"
- "// trailing comment\n"
- "// line 2\n"
- "\n"
- "next",
+ {"prev\n"
+ "// trailing comment\n"
+ "// line 2\n"
+ "\n"
+ "next",
- " trailing comment\n"
- " line 2\n",
- {},
- ""
- },
+ " trailing comment\n"
+ " line 2\n",
+ {},
+ ""},
- {
- "prev // trailing comment\n"
- "// leading comment\n"
- "// line 2\n"
- "next",
+ {"prev // trailing comment\n"
+ "// leading comment\n"
+ "// line 2\n"
+ "next",
- " trailing comment\n",
- {},
- " leading comment\n"
- " line 2\n"
- },
+ " trailing comment\n",
+ {},
+ " leading comment\n"
+ " line 2\n"},
- {
- "prev /* trailing block comment */\n"
- "/* leading block comment\n"
- " * line 2\n"
- " * line 3 */"
- "next",
+ {"prev /* trailing block comment */\n"
+ "/* leading block comment\n"
+ " * line 2\n"
+ " * line 3 */"
+ "next",
- " trailing block comment ",
- {},
- " leading block comment\n"
- " line 2\n"
- " line 3 "
- },
+ " trailing block comment ",
+ {},
+ " leading block comment\n"
+ " line 2\n"
+ " line 3 "},
- {
- "prev\n"
- "/* trailing block comment\n"
- " * line 2\n"
- " * line 3\n"
- " */\n"
- "/* leading block comment\n"
- " * line 2\n"
- " * line 3 */"
- "next",
+ {"prev\n"
+ "/* trailing block comment\n"
+ " * line 2\n"
+ " * line 3\n"
+ " */\n"
+ "/* leading block comment\n"
+ " * line 2\n"
+ " * line 3 */"
+ "next",
- " trailing block comment\n"
- " line 2\n"
- " line 3\n",
- {},
- " leading block comment\n"
- " line 2\n"
- " line 3 "
- },
+ " trailing block comment\n"
+ " line 2\n"
+ " line 3\n",
+ {},
+ " leading block comment\n"
+ " line 2\n"
+ " line 3 "},
- {
- "prev\n"
- "// trailing comment\n"
- "\n"
- "// detached comment\n"
- "// line 2\n"
- "\n"
- "// second detached comment\n"
- "/* third detached comment\n"
- " * line 2 */\n"
- "// leading comment\n"
- "next",
+ {"prev\n"
+ "// trailing comment\n"
+ "\n"
+ "// detached comment\n"
+ "// line 2\n"
+ "\n"
+ "// second detached comment\n"
+ "/* third detached comment\n"
+ " * line 2 */\n"
+ "// leading comment\n"
+ "next",
- " trailing comment\n",
- {
- " detached comment\n"
- " line 2\n",
- " second detached comment\n",
- " third detached comment\n"
- " line 2 "
- },
- " leading comment\n"
- },
+ " trailing comment\n",
+ {" detached comment\n"
+ " line 2\n",
+ " second detached comment\n",
+ " third detached comment\n"
+ " line 2 "},
+ " leading comment\n"},
- {
- "prev /**/\n"
- "\n"
- "// detached comment\n"
- "\n"
- "// leading comment\n"
- "next",
+ {"prev /**/\n"
+ "\n"
+ "// detached comment\n"
+ "\n"
+ "// leading comment\n"
+ "next",
- "",
- {
- " detached comment\n"
- },
- " leading comment\n"
- },
+ "",
+ {" detached comment\n"},
+ " leading comment\n"},
- {
- "prev /**/\n"
- "// leading comment\n"
- "next",
+ {"prev /**/\n"
+ "// leading comment\n"
+ "next",
- "",
- {},
- " leading comment\n"
- },
- };
+ "",
+ {},
+ " leading comment\n"},
+};
TEST_2D(TokenizerTest, DocComments, kDocCommentCases, kBlockSizes) {
// Set up the tokenizer.
TestInputStream input(kDocCommentCases_case.input.data(),
- kDocCommentCases_case.input.size(),
- kBlockSizes_case);
+ kDocCommentCases_case.input.size(), kBlockSizes_case);
TestErrorCollector error_collector;
Tokenizer tokenizer(&input, &error_collector);
// Set up a second tokenizer where we'll pass all NULLs to NextWithComments().
TestInputStream input2(kDocCommentCases_case.input.data(),
- kDocCommentCases_case.input.size(),
- kBlockSizes_case);
+ kDocCommentCases_case.input.size(), kBlockSizes_case);
Tokenizer tokenizer2(&input2, &error_collector);
tokenizer.Next();
@@ -707,16 +686,14 @@
for (int i = 0; i < detached_comments.size(); i++) {
ASSERT_LT(i, GOOGLE_ARRAYSIZE(kDocCommentCases));
ASSERT_TRUE(kDocCommentCases_case.detached_comments[i] != NULL);
- EXPECT_EQ(kDocCommentCases_case.detached_comments[i],
- detached_comments[i]);
+ EXPECT_EQ(kDocCommentCases_case.detached_comments[i], detached_comments[i]);
}
// Verify that we matched all the detached comments.
EXPECT_EQ(NULL,
- kDocCommentCases_case.detached_comments[detached_comments.size()]);
+ kDocCommentCases_case.detached_comments[detached_comments.size()]);
- EXPECT_EQ(kDocCommentCases_case.next_leading_comments,
- next_leading_comments);
+ EXPECT_EQ(kDocCommentCases_case.next_leading_comments, next_leading_comments);
}
// -------------------------------------------------------------------
@@ -745,30 +722,30 @@
EXPECT_FALSE(Tokenizer::ParseInteger("-1", kuint64max, &i));
// Test overflows.
- EXPECT_TRUE (Tokenizer::ParseInteger("0", 0, &i));
+ EXPECT_TRUE(Tokenizer::ParseInteger("0", 0, &i));
EXPECT_FALSE(Tokenizer::ParseInteger("1", 0, &i));
- EXPECT_TRUE (Tokenizer::ParseInteger("1", 1, &i));
- EXPECT_TRUE (Tokenizer::ParseInteger("12345", 12345, &i));
+ EXPECT_TRUE(Tokenizer::ParseInteger("1", 1, &i));
+ EXPECT_TRUE(Tokenizer::ParseInteger("12345", 12345, &i));
EXPECT_FALSE(Tokenizer::ParseInteger("12346", 12345, &i));
- EXPECT_TRUE (Tokenizer::ParseInteger("0xFFFFFFFFFFFFFFFF" , kuint64max, &i));
+ EXPECT_TRUE(Tokenizer::ParseInteger("0xFFFFFFFFFFFFFFFF", kuint64max, &i));
EXPECT_FALSE(Tokenizer::ParseInteger("0x10000000000000000", kuint64max, &i));
}
TEST_F(TokenizerTest, ParseFloat) {
- EXPECT_DOUBLE_EQ(1 , Tokenizer::ParseFloat("1."));
- EXPECT_DOUBLE_EQ(1e3 , Tokenizer::ParseFloat("1e3"));
- EXPECT_DOUBLE_EQ(1e3 , Tokenizer::ParseFloat("1E3"));
+ EXPECT_DOUBLE_EQ(1, Tokenizer::ParseFloat("1."));
+ EXPECT_DOUBLE_EQ(1e3, Tokenizer::ParseFloat("1e3"));
+ EXPECT_DOUBLE_EQ(1e3, Tokenizer::ParseFloat("1E3"));
EXPECT_DOUBLE_EQ(1.5e3, Tokenizer::ParseFloat("1.5e3"));
- EXPECT_DOUBLE_EQ(.1 , Tokenizer::ParseFloat(".1"));
- EXPECT_DOUBLE_EQ(.25 , Tokenizer::ParseFloat(".25"));
- EXPECT_DOUBLE_EQ(.1e3 , Tokenizer::ParseFloat(".1e3"));
+ EXPECT_DOUBLE_EQ(.1, Tokenizer::ParseFloat(".1"));
+ EXPECT_DOUBLE_EQ(.25, Tokenizer::ParseFloat(".25"));
+ EXPECT_DOUBLE_EQ(.1e3, Tokenizer::ParseFloat(".1e3"));
EXPECT_DOUBLE_EQ(.25e3, Tokenizer::ParseFloat(".25e3"));
EXPECT_DOUBLE_EQ(.1e+3, Tokenizer::ParseFloat(".1e+3"));
EXPECT_DOUBLE_EQ(.1e-3, Tokenizer::ParseFloat(".1e-3"));
- EXPECT_DOUBLE_EQ(5 , Tokenizer::ParseFloat("5"));
+ EXPECT_DOUBLE_EQ(5, Tokenizer::ParseFloat("5"));
EXPECT_DOUBLE_EQ(6e-12, Tokenizer::ParseFloat("6e-12"));
- EXPECT_DOUBLE_EQ(1.2 , Tokenizer::ParseFloat("1.2"));
- EXPECT_DOUBLE_EQ(1.e2 , Tokenizer::ParseFloat("1.e2"));
+ EXPECT_DOUBLE_EQ(1.2, Tokenizer::ParseFloat("1.2"));
+ EXPECT_DOUBLE_EQ(1.e2, Tokenizer::ParseFloat("1.e2"));
// Test invalid integers that may still be tokenized as integers.
EXPECT_DOUBLE_EQ(1, Tokenizer::ParseFloat("1e"));
@@ -782,17 +759,20 @@
// These should parse successfully even though they are out of range.
// Overflows become infinity and underflows become zero.
- EXPECT_EQ( 0.0, Tokenizer::ParseFloat("1e-9999999999999999999999999999"));
+ EXPECT_EQ(0.0, Tokenizer::ParseFloat("1e-9999999999999999999999999999"));
EXPECT_EQ(HUGE_VAL, Tokenizer::ParseFloat("1e+9999999999999999999999999999"));
#ifdef PROTOBUF_HAS_DEATH_TEST // death tests do not work on Windows yet
// Test invalid integers that will never be tokenized as integers.
- EXPECT_DEBUG_DEATH(Tokenizer::ParseFloat("zxy"),
- "passed text that could not have been tokenized as a float");
- EXPECT_DEBUG_DEATH(Tokenizer::ParseFloat("1-e0"),
- "passed text that could not have been tokenized as a float");
- EXPECT_DEBUG_DEATH(Tokenizer::ParseFloat("-1.0"),
- "passed text that could not have been tokenized as a float");
+ EXPECT_DEBUG_DEATH(
+ Tokenizer::ParseFloat("zxy"),
+ "passed text that could not have been tokenized as a float");
+ EXPECT_DEBUG_DEATH(
+ Tokenizer::ParseFloat("1-e0"),
+ "passed text that could not have been tokenized as a float");
+ EXPECT_DEBUG_DEATH(
+ Tokenizer::ParseFloat("-1.0"),
+ "passed text that could not have been tokenized as a float");
#endif // PROTOBUF_HAS_DEATH_TEST
}
@@ -833,8 +813,9 @@
// Test invalid strings that will never be tokenized as strings.
#ifdef PROTOBUF_HAS_DEATH_TEST // death tests do not work on Windows yet
- EXPECT_DEBUG_DEATH(Tokenizer::ParseString("", &output),
- "passed text that could not have been tokenized as a string");
+ EXPECT_DEBUG_DEATH(
+ Tokenizer::ParseString("", &output),
+ "passed text that could not have been tokenized as a string");
#endif // PROTOBUF_HAS_DEATH_TEST
}
@@ -934,8 +915,7 @@
TEST_2D(TokenizerTest, Errors, kErrorCases, kBlockSizes) {
// Set up the tokenizer.
TestInputStream input(kErrorCases_case.input.data(),
- kErrorCases_case.input.size(),
- kBlockSizes_case);
+ kErrorCases_case.input.size(), kBlockSizes_case);
TestErrorCollector error_collector;
Tokenizer tokenizer(&input, &error_collector);
diff --git a/src/google/protobuf/io/zero_copy_stream_impl.cc b/src/google/protobuf/io/zero_copy_stream_impl.cc
index 72328da..4af76b7 100644
--- a/src/google/protobuf/io/zero_copy_stream_impl.cc
+++ b/src/google/protobuf/io/zero_copy_stream_impl.cc
@@ -33,19 +33,19 @@
// Sanjay Ghemawat, Jeff Dean, and others.
#ifndef _MSC_VER
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
#endif
#include <errno.h>
-#include <iostream>
#include <algorithm>
-#include <google/protobuf/io/zero_copy_stream_impl.h>
+#include <iostream>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/io/io_win32.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/stubs/stl_util.h>
-#include <google/protobuf/stubs/io_win32.h>
namespace google {
@@ -58,11 +58,11 @@
#define lseek(fd, offset, origin) ((off_t)-1)
// DO NOT include <io.h>, instead create functions in io_win32.{h,cc} and import
// them like we do below.
-using google::protobuf::internal::win32::access;
-using google::protobuf::internal::win32::close;
-using google::protobuf::internal::win32::open;
-using google::protobuf::internal::win32::read;
-using google::protobuf::internal::win32::write;
+using google::protobuf::io::win32::access;
+using google::protobuf::io::win32::close;
+using google::protobuf::io::win32::open;
+using google::protobuf::io::win32::read;
+using google::protobuf::io::win32::write;
#endif
namespace {
@@ -81,38 +81,27 @@
// ===================================================================
FileInputStream::FileInputStream(int file_descriptor, int block_size)
- : copying_input_(file_descriptor),
- impl_(©ing_input_, block_size) {
-}
+ : copying_input_(file_descriptor), impl_(©ing_input_, block_size) {}
-bool FileInputStream::Close() {
- return copying_input_.Close();
-}
+bool FileInputStream::Close() { return copying_input_.Close(); }
bool FileInputStream::Next(const void** data, int* size) {
return impl_.Next(data, size);
}
-void FileInputStream::BackUp(int count) {
- impl_.BackUp(count);
-}
+void FileInputStream::BackUp(int count) { impl_.BackUp(count); }
-bool FileInputStream::Skip(int count) {
- return impl_.Skip(count);
-}
+bool FileInputStream::Skip(int count) { return impl_.Skip(count); }
-int64 FileInputStream::ByteCount() const {
- return impl_.ByteCount();
-}
+int64 FileInputStream::ByteCount() const { return impl_.ByteCount(); }
FileInputStream::CopyingFileInputStream::CopyingFileInputStream(
int file_descriptor)
- : file_(file_descriptor),
- close_on_delete_(false),
- is_closed_(false),
- errno_(0),
- previous_seek_failed_(false) {
-}
+ : file_(file_descriptor),
+ close_on_delete_(false),
+ is_closed_(false),
+ errno_(0),
+ previous_seek_failed_(false) {}
FileInputStream::CopyingFileInputStream::~CopyingFileInputStream() {
if (close_on_delete_) {
@@ -156,8 +145,7 @@
int FileInputStream::CopyingFileInputStream::Skip(int count) {
GOOGLE_CHECK(!is_closed_);
- if (!previous_seek_failed_ &&
- lseek(file_, count, SEEK_CUR) != (off_t)-1) {
+ if (!previous_seek_failed_ && lseek(file_, count, SEEK_CUR) != (off_t)-1) {
// Seek succeeded.
return count;
} else {
@@ -175,42 +163,31 @@
// ===================================================================
FileOutputStream::FileOutputStream(int file_descriptor, int block_size)
- : copying_output_(file_descriptor),
- impl_(©ing_output_, block_size) {
-}
+ : copying_output_(file_descriptor), impl_(©ing_output_, block_size) {}
-FileOutputStream::~FileOutputStream() {
- impl_.Flush();
-}
+FileOutputStream::~FileOutputStream() { impl_.Flush(); }
bool FileOutputStream::Close() {
bool flush_succeeded = impl_.Flush();
return copying_output_.Close() && flush_succeeded;
}
-bool FileOutputStream::Flush() {
- return impl_.Flush();
-}
+bool FileOutputStream::Flush() { return impl_.Flush(); }
bool FileOutputStream::Next(void** data, int* size) {
return impl_.Next(data, size);
}
-void FileOutputStream::BackUp(int count) {
- impl_.BackUp(count);
-}
+void FileOutputStream::BackUp(int count) { impl_.BackUp(count); }
-int64 FileOutputStream::ByteCount() const {
- return impl_.ByteCount();
-}
+int64 FileOutputStream::ByteCount() const { return impl_.ByteCount(); }
FileOutputStream::CopyingFileOutputStream::CopyingFileOutputStream(
int file_descriptor)
- : file_(file_descriptor),
- close_on_delete_(false),
- is_closed_(false),
- errno_(0) {
-}
+ : file_(file_descriptor),
+ close_on_delete_(false),
+ is_closed_(false),
+ errno_(0) {}
FileOutputStream::CopyingFileOutputStream::~CopyingFileOutputStream() {
if (close_on_delete_) {
@@ -235,8 +212,8 @@
return true;
}
-bool FileOutputStream::CopyingFileOutputStream::Write(
- const void* buffer, int size) {
+bool FileOutputStream::CopyingFileOutputStream::Write(const void* buffer,
+ int size) {
GOOGLE_CHECK(!is_closed_);
int total_written = 0;
@@ -279,17 +256,11 @@
return impl_.Next(data, size);
}
-void IstreamInputStream::BackUp(int count) {
- impl_.BackUp(count);
-}
+void IstreamInputStream::BackUp(int count) { impl_.BackUp(count); }
-bool IstreamInputStream::Skip(int count) {
- return impl_.Skip(count);
-}
+bool IstreamInputStream::Skip(int count) { return impl_.Skip(count); }
-int64 IstreamInputStream::ByteCount() const {
- return impl_.ByteCount();
-}
+int64 IstreamInputStream::ByteCount() const { return impl_.ByteCount(); }
IstreamInputStream::CopyingIstreamInputStream::CopyingIstreamInputStream(
std::istream* input)
@@ -297,8 +268,8 @@
IstreamInputStream::CopyingIstreamInputStream::~CopyingIstreamInputStream() {}
-int IstreamInputStream::CopyingIstreamInputStream::Read(
- void* buffer, int size) {
+int IstreamInputStream::CopyingIstreamInputStream::Read(void* buffer,
+ int size) {
input_->read(reinterpret_cast<char*>(buffer), size);
int result = input_->gcount();
if (result == 0 && input_->fail() && !input_->eof()) {
@@ -312,21 +283,15 @@
OstreamOutputStream::OstreamOutputStream(std::ostream* output, int block_size)
: copying_output_(output), impl_(©ing_output_, block_size) {}
-OstreamOutputStream::~OstreamOutputStream() {
- impl_.Flush();
-}
+OstreamOutputStream::~OstreamOutputStream() { impl_.Flush(); }
bool OstreamOutputStream::Next(void** data, int* size) {
return impl_.Next(data, size);
}
-void OstreamOutputStream::BackUp(int count) {
- impl_.BackUp(count);
-}
+void OstreamOutputStream::BackUp(int count) { impl_.BackUp(count); }
-int64 OstreamOutputStream::ByteCount() const {
- return impl_.ByteCount();
-}
+int64 OstreamOutputStream::ByteCount() const { return impl_.ByteCount(); }
OstreamOutputStream::CopyingOstreamOutputStream::CopyingOstreamOutputStream(
std::ostream* output)
@@ -335,8 +300,8 @@
OstreamOutputStream::CopyingOstreamOutputStream::~CopyingOstreamOutputStream() {
}
-bool OstreamOutputStream::CopyingOstreamOutputStream::Write(
- const void* buffer, int size) {
+bool OstreamOutputStream::CopyingOstreamOutputStream::Write(const void* buffer,
+ int size) {
output_->write(reinterpret_cast<const char*>(buffer), size);
return output_->good();
}
@@ -345,7 +310,7 @@
ConcatenatingInputStream::ConcatenatingInputStream(
ZeroCopyInputStream* const streams[], int count)
- : streams_(streams), stream_count_(count), bytes_retired_(0) {
+ : streams_(streams), stream_count_(count), bytes_retired_(0) {
}
bool ConcatenatingInputStream::Next(const void** data, int* size) {
diff --git a/src/google/protobuf/io/zero_copy_stream_impl.h b/src/google/protobuf/io/zero_copy_stream_impl.h
index f2d2688..fd06c06 100644
--- a/src/google/protobuf/io/zero_copy_stream_impl.h
+++ b/src/google/protobuf/io/zero_copy_stream_impl.h
@@ -40,11 +40,11 @@
#ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_H__
#define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_H__
-#include <string>
#include <iosfwd>
+#include <string>
+#include <google/protobuf/stubs/common.h>
#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
-#include <google/protobuf/stubs/common.h>
#include <google/protobuf/port_def.inc>
diff --git a/src/google/protobuf/io/zero_copy_stream_impl_lite.cc b/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
index f5f340f..69ceaab 100644
--- a/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
+++ b/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
@@ -55,14 +55,12 @@
// ===================================================================
-ArrayInputStream::ArrayInputStream(const void* data, int size,
- int block_size)
- : data_(reinterpret_cast<const uint8*>(data)),
- size_(size),
- block_size_(block_size > 0 ? block_size : size),
- position_(0),
- last_returned_size_(0) {
-}
+ArrayInputStream::ArrayInputStream(const void* data, int size, int block_size)
+ : data_(reinterpret_cast<const uint8*>(data)),
+ size_(size),
+ block_size_(block_size > 0 ? block_size : size),
+ position_(0),
+ last_returned_size_(0) {}
bool ArrayInputStream::Next(const void** data, int* size) {
if (position_ < size_) {
@@ -73,7 +71,7 @@
return true;
} else {
// We're at the end of the array.
- last_returned_size_ = 0; // Don't let caller back up.
+ last_returned_size_ = 0; // Don't let caller back up.
return false;
}
}
@@ -89,7 +87,7 @@
bool ArrayInputStream::Skip(int count) {
GOOGLE_CHECK_GE(count, 0);
- last_returned_size_ = 0; // Don't let caller back up.
+ last_returned_size_ = 0; // Don't let caller back up.
if (count > size_ - position_) {
position_ = size_;
return false;
@@ -99,20 +97,17 @@
}
}
-int64 ArrayInputStream::ByteCount() const {
- return position_;
-}
+int64 ArrayInputStream::ByteCount() const { return position_; }
// ===================================================================
ArrayOutputStream::ArrayOutputStream(void* data, int size, int block_size)
- : data_(reinterpret_cast<uint8*>(data)),
- size_(size),
- block_size_(block_size > 0 ? block_size : size),
- position_(0),
- last_returned_size_(0) {
-}
+ : data_(reinterpret_cast<uint8*>(data)),
+ size_(size),
+ block_size_(block_size > 0 ? block_size : size),
+ position_(0),
+ last_returned_size_(0) {}
bool ArrayOutputStream::Next(void** data, int* size) {
if (position_ < size_) {
@@ -123,7 +118,7 @@
return true;
} else {
// We're at the end of the array.
- last_returned_size_ = 0; // Don't let caller back up.
+ last_returned_size_ = 0; // Don't let caller back up.
return false;
}
}
@@ -137,9 +132,7 @@
last_returned_size_ = 0; // Don't let caller back up further.
}
-int64 ArrayOutputStream::ByteCount() const {
- return position_;
-}
+int64 ArrayOutputStream::ByteCount() const { return position_; }
// ===================================================================
@@ -209,14 +202,13 @@
CopyingInputStreamAdaptor::CopyingInputStreamAdaptor(
CopyingInputStream* copying_stream, int block_size)
- : copying_stream_(copying_stream),
- owns_copying_stream_(false),
- failed_(false),
- position_(0),
- buffer_size_(block_size > 0 ? block_size : kDefaultBlockSize),
- buffer_used_(0),
- backup_bytes_(0) {
-}
+ : copying_stream_(copying_stream),
+ owns_copying_stream_(false),
+ failed_(false),
+ position_(0),
+ buffer_size_(block_size > 0 ? block_size : kDefaultBlockSize),
+ buffer_used_(0),
+ backup_bytes_(0) {}
CopyingInputStreamAdaptor::~CopyingInputStreamAdaptor() {
if (owns_copying_stream_) {
@@ -260,12 +252,11 @@
void CopyingInputStreamAdaptor::BackUp(int count) {
GOOGLE_CHECK(backup_bytes_ == 0 && buffer_.get() != NULL)
- << " BackUp() can only be called after Next().";
+ << " BackUp() can only be called after Next().";
GOOGLE_CHECK_LE(count, buffer_used_)
- << " Can't back up over more bytes than were returned by the last call"
- " to Next().";
- GOOGLE_CHECK_GE(count, 0)
- << " Parameter to BackUp() can't be negative.";
+ << " Can't back up over more bytes than were returned by the last call"
+ " to Next().";
+ GOOGLE_CHECK_GE(count, 0) << " Parameter to BackUp() can't be negative.";
backup_bytes_ = count;
}
@@ -313,13 +304,12 @@
CopyingOutputStreamAdaptor::CopyingOutputStreamAdaptor(
CopyingOutputStream* copying_stream, int block_size)
- : copying_stream_(copying_stream),
- owns_copying_stream_(false),
- failed_(false),
- position_(0),
- buffer_size_(block_size > 0 ? block_size : kDefaultBlockSize),
- buffer_used_(0) {
-}
+ : copying_stream_(copying_stream),
+ owns_copying_stream_(false),
+ failed_(false),
+ position_(0),
+ buffer_size_(block_size > 0 ? block_size : kDefaultBlockSize),
+ buffer_used_(0) {}
CopyingOutputStreamAdaptor::~CopyingOutputStreamAdaptor() {
WriteBuffer();
@@ -328,9 +318,7 @@
}
}
-bool CopyingOutputStreamAdaptor::Flush() {
- return WriteBuffer();
-}
+bool CopyingOutputStreamAdaptor::Flush() { return WriteBuffer(); }
bool CopyingOutputStreamAdaptor::Next(void** data, int* size) {
if (buffer_used_ == buffer_size_) {
@@ -348,10 +336,10 @@
void CopyingOutputStreamAdaptor::BackUp(int count) {
GOOGLE_CHECK_GE(count, 0);
GOOGLE_CHECK_EQ(buffer_used_, buffer_size_)
- << " BackUp() can only be called after Next().";
+ << " BackUp() can only be called after Next().";
GOOGLE_CHECK_LE(count, buffer_used_)
- << " Can't back up over more bytes than were returned by the last call"
- " to Next().";
+ << " Can't back up over more bytes than were returned by the last call"
+ " to Next().";
buffer_used_ -= count;
}
diff --git a/src/google/protobuf/io/zero_copy_stream_impl_lite.h b/src/google/protobuf/io/zero_copy_stream_impl_lite.h
index 6c14abc..14144b5 100644
--- a/src/google/protobuf/io/zero_copy_stream_impl_lite.h
+++ b/src/google/protobuf/io/zero_copy_stream_impl_lite.h
@@ -44,12 +44,12 @@
#ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
#define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
+#include <iosfwd>
#include <memory>
#include <string>
-#include <iosfwd>
-#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/stubs/callback.h>
#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/stubs/stl_util.h>
@@ -87,8 +87,8 @@
const int block_size_; // How many bytes to return at a time.
int position_;
- int last_returned_size_; // How many bytes we returned last time Next()
- // was called (used for error checking only).
+ int last_returned_size_; // How many bytes we returned last time Next()
+ // was called (used for error checking only).
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayInputStream);
};
@@ -114,13 +114,13 @@
int64 ByteCount() const override;
private:
- uint8* const data_; // The byte array.
- const int size_; // Total size of the array.
- const int block_size_; // How many bytes to return at a time.
+ uint8* const data_; // The byte array.
+ const int size_; // Total size of the array.
+ const int block_size_; // How many bytes to return at a time.
int position_;
- int last_returned_size_; // How many bytes we returned last time Next()
- // was called (used for error checking only).
+ int last_returned_size_; // How many bytes we returned last time Next()
+ // was called (used for error checking only).
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayOutputStream);
};
@@ -394,7 +394,7 @@
// Sometimes it's faster: in some scenarios p cannot be NULL, and then the
// code can avoid that check.
inline std::pair<char*, bool> as_string_data(std::string* s) {
- char *p = mutable_string_data(s);
+ char* p = mutable_string_data(s);
return std::make_pair(p, true);
}
diff --git a/src/google/protobuf/io/zero_copy_stream_unittest.cc b/src/google/protobuf/io/zero_copy_stream_unittest.cc
index 8530d73..5f7b610 100644
--- a/src/google/protobuf/io/zero_copy_stream_unittest.cc
+++ b/src/google/protobuf/io/zero_copy_stream_unittest.cc
@@ -50,16 +50,17 @@
#ifndef _MSC_VER
#include <unistd.h>
#endif
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
#include <memory>
#include <sstream>
#include <google/protobuf/testing/file.h>
#include <google/protobuf/test_util2.h>
+#include <google/protobuf/io/io_win32.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
@@ -69,10 +70,9 @@
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/logging.h>
-#include <google/protobuf/testing/googletest.h>
#include <google/protobuf/testing/file.h>
+#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
-#include <google/protobuf/stubs/io_win32.h>
namespace google {
namespace protobuf {
@@ -83,17 +83,17 @@
#define pipe(fds) _pipe(fds, 4096, O_BINARY)
// DO NOT include <io.h>, instead create functions in io_win32.{h,cc} and import
// them like we do below.
-using google::protobuf::internal::win32::access;
-using google::protobuf::internal::win32::mkdir;
-using google::protobuf::internal::win32::open;
-using google::protobuf::internal::win32::close;
+using google::protobuf::io::win32::access;
+using google::protobuf::io::win32::close;
+using google::protobuf::io::win32::mkdir;
+using google::protobuf::io::win32::open;
#endif
#ifndef O_BINARY
#ifdef _O_BINARY
#define O_BINARY _O_BINARY
#else
-#define O_BINARY 0 // If this isn't defined, the platform doesn't need it.
+#define O_BINARY 0 // If this isn't defined, the platform doesn't need it.
#endif
#endif
@@ -137,8 +137,8 @@
const int IoTest::kBlockSizes[] = {-1, 1, 2, 5, 7, 10, 23, 64};
const int IoTest::kBlockSizeCount = GOOGLE_ARRAYSIZE(IoTest::kBlockSizes);
-bool IoTest::WriteToOutput(ZeroCopyOutputStream* output,
- const void* data, int size) {
+bool IoTest::WriteToOutput(ZeroCopyOutputStream* output, const void* data,
+ int size) {
const uint8* in = reinterpret_cast<const uint8*>(data);
int in_size = size;
@@ -300,7 +300,7 @@
static const char* strA = "0123456789";
static const char* strB = "WhirledPeas";
- const int kBufferSize = 2*1024;
+ const int kBufferSize = 2 * 1024;
uint8* buffer = new uint8[kBufferSize];
char* temp_buffer = new char[40];
@@ -314,8 +314,8 @@
delete coded_output; // flush
int64 pos = output->ByteCount();
delete output;
- output = new ArrayOutputStream(
- buffer + pos, kBufferSize - pos, kBlockSizes[i]);
+ output = new ArrayOutputStream(buffer + pos, kBufferSize - pos,
+ kBlockSizes[i]);
coded_output = new CodedOutputStream(output);
coded_output->WriteVarint32(strlen(strB));
coded_output->WriteRaw(strB, strlen(strB));
@@ -342,13 +342,13 @@
}
}
- delete [] temp_buffer;
- delete [] buffer;
+ delete[] temp_buffer;
+ delete[] buffer;
}
#if HAVE_ZLIB
TEST_F(IoTest, GzipIo) {
- const int kBufferSize = 2*1024;
+ const int kBufferSize = 2 * 1024;
uint8* buffer = new uint8[kBufferSize];
for (int i = 0; i < kBlockSizeCount; i++) {
for (int j = 0; j < kBlockSizeCount; j++) {
@@ -369,18 +369,17 @@
}
{
ArrayInputStream input(buffer, size, kBlockSizes[j]);
- GzipInputStream gzin(
- &input, GzipInputStream::GZIP, gzip_buffer_size);
+ GzipInputStream gzin(&input, GzipInputStream::GZIP, gzip_buffer_size);
ReadStuff(&gzin);
}
}
}
}
- delete [] buffer;
+ delete[] buffer;
}
TEST_F(IoTest, GzipIoWithFlush) {
- const int kBufferSize = 2*1024;
+ const int kBufferSize = 2 * 1024;
uint8* buffer = new uint8[kBufferSize];
// We start with i = 4 as we want a block size > 6. With block size <= 6
// Flush() fills up the entire 2K buffer with flush markers and the test
@@ -405,18 +404,17 @@
}
{
ArrayInputStream input(buffer, size, kBlockSizes[j]);
- GzipInputStream gzin(
- &input, GzipInputStream::GZIP, gzip_buffer_size);
+ GzipInputStream gzin(&input, GzipInputStream::GZIP, gzip_buffer_size);
ReadStuff(&gzin);
}
}
}
}
- delete [] buffer;
+ delete[] buffer;
}
TEST_F(IoTest, GzipIoContiguousFlushes) {
- const int kBufferSize = 2*1024;
+ const int kBufferSize = 2 * 1024;
uint8* buffer = new uint8[kBufferSize];
int block_size = kBlockSizes[4];
@@ -437,15 +435,14 @@
size = output.ByteCount();
ArrayInputStream input(buffer, size, block_size);
- GzipInputStream gzin(
- &input, GzipInputStream::GZIP, gzip_buffer_size);
+ GzipInputStream gzin(&input, GzipInputStream::GZIP, gzip_buffer_size);
ReadStuff(&gzin);
- delete [] buffer;
+ delete[] buffer;
}
TEST_F(IoTest, GzipIoReadAfterFlush) {
- const int kBufferSize = 2*1024;
+ const int kBufferSize = 2 * 1024;
uint8* buffer = new uint8[kBufferSize];
int block_size = kBlockSizes[4];
@@ -464,17 +461,16 @@
size = output.ByteCount();
ArrayInputStream input(buffer, size, block_size);
- GzipInputStream gzin(
- &input, GzipInputStream::GZIP, gzip_buffer_size);
+ GzipInputStream gzin(&input, GzipInputStream::GZIP, gzip_buffer_size);
ReadStuff(&gzin);
gzout.Close();
- delete [] buffer;
+ delete[] buffer;
}
TEST_F(IoTest, ZlibIo) {
- const int kBufferSize = 2*1024;
+ const int kBufferSize = 2 * 1024;
uint8* buffer = new uint8[kBufferSize];
for (int i = 0; i < kBlockSizeCount; i++) {
for (int j = 0; j < kBlockSizeCount; j++) {
@@ -495,18 +491,17 @@
}
{
ArrayInputStream input(buffer, size, kBlockSizes[j]);
- GzipInputStream gzin(
- &input, GzipInputStream::ZLIB, gzip_buffer_size);
+ GzipInputStream gzin(&input, GzipInputStream::ZLIB, gzip_buffer_size);
ReadStuff(&gzin);
}
}
}
}
- delete [] buffer;
+ delete[] buffer;
}
TEST_F(IoTest, ZlibIoInputAutodetect) {
- const int kBufferSize = 2*1024;
+ const int kBufferSize = 2 * 1024;
uint8* buffer = new uint8[kBufferSize];
int size;
{
@@ -537,7 +532,7 @@
GzipInputStream gzin(&input, GzipInputStream::AUTO);
ReadStuff(&gzin);
}
- delete [] buffer;
+ delete[] buffer;
}
std::string IoTest::Compress(const std::string& data,
@@ -605,7 +600,7 @@
static const char* strA = "0123456789";
static const char* strB = "QuickBrownFox";
- const int kBufferSize = 2*1024;
+ const int kBufferSize = 2 * 1024;
uint8* buffer = new uint8[kBufferSize];
char* temp_buffer = new char[40];
@@ -619,18 +614,18 @@
coded_output->WriteVarint32(outlen);
coded_output->WriteRaw(strA, outlen);
delete coded_output; // flush
- delete gzout; // flush
+ delete gzout; // flush
int64 pos = output->ByteCount();
delete output;
- output = new ArrayOutputStream(
- buffer + pos, kBufferSize - pos, kBlockSizes[i]);
+ output = new ArrayOutputStream(buffer + pos, kBufferSize - pos,
+ kBlockSizes[i]);
gzout = new GzipOutputStream(output);
coded_output = new CodedOutputStream(gzout);
outlen = strlen(strB) + 1;
coded_output->WriteVarint32(outlen);
coded_output->WriteRaw(strB, outlen);
delete coded_output; // flush
- delete gzout; // flush
+ delete gzout; // flush
int64 size = pos + output->ByteCount();
delete output;
@@ -650,10 +645,8 @@
EXPECT_TRUE(coded_input->ReadRaw(temp_buffer, insize));
EXPECT_EQ(0, memcmp(temp_buffer, strB, insize))
<< " out_block_size=" << kBlockSizes[i]
- << " in_block_size=" << kBlockSizes[j]
- << " pos=" << pos
- << " size=" << size
- << " strB=" << strB << " in=" << temp_buffer;
+ << " in_block_size=" << kBlockSizes[j] << " pos=" << pos
+ << " size=" << size << " strB=" << strB << " in=" << temp_buffer;
delete coded_input;
delete gzin;
@@ -661,8 +654,8 @@
}
}
- delete [] temp_buffer;
- delete [] buffer;
+ delete[] temp_buffer;
+ delete[] buffer;
}
TEST_F(IoTest, GzipInputByteCountAfterClosed) {
@@ -727,7 +720,7 @@
for (int j = 0; j < kBlockSizeCount; j++) {
// Make a temporary file.
int file =
- open(filename.c_str(), O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0777);
+ open(filename.c_str(), O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0777);
ASSERT_GE(file, 0);
{
@@ -758,7 +751,7 @@
for (int j = 0; j < kBlockSizeCount; j++) {
// Make a temporary file.
int file =
- open(filename.c_str(), O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0777);
+ open(filename.c_str(), O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0777);
ASSERT_GE(file, 0);
{
FileOutputStream output(file, kBlockSizes[i]);
@@ -800,10 +793,8 @@
old_mode_ = _CrtSetReportMode(_CRT_ASSERT, old_mode_);
}
- static void MyHandler(const wchar_t *expr,
- const wchar_t *func,
- const wchar_t *file,
- unsigned int line,
+ static void MyHandler(const wchar_t* expr, const wchar_t* func,
+ const wchar_t* file, unsigned int line,
uintptr_t pReserved) {
// do nothing
}
@@ -931,19 +922,19 @@
// Now split it up into multiple streams of varying sizes.
ASSERT_EQ(68, output.ByteCount()); // Test depends on this.
- ArrayInputStream input1(buffer , 12);
- ArrayInputStream input2(buffer + 12, 7);
- ArrayInputStream input3(buffer + 19, 6);
+ ArrayInputStream input1(buffer, 12);
+ ArrayInputStream input2(buffer + 12, 7);
+ ArrayInputStream input3(buffer + 19, 6);
ArrayInputStream input4(buffer + 25, 15);
- ArrayInputStream input5(buffer + 40, 0);
+ ArrayInputStream input5(buffer + 40, 0);
// Note: We want to make sure we have a stream boundary somewhere between
// bytes 42 and 62, which is the range that it Skip()ed by ReadStuff(). This
// tests that a bug that existed in the original code for Skip() is fixed.
ArrayInputStream input6(buffer + 40, 10);
ArrayInputStream input7(buffer + 50, 18); // Total = 68 bytes.
- ZeroCopyInputStream* streams[] =
- {&input1, &input2, &input3, &input4, &input5, &input6, &input7};
+ ZeroCopyInputStream* streams[] = {&input1, &input2, &input3, &input4,
+ &input5, &input6, &input7};
// Create the concatenating stream and read.
ConcatenatingInputStream input(streams, GOOGLE_ARRAYSIZE(streams));
@@ -986,7 +977,7 @@
LimitingInputStream input(&array_input, kHalfBufferSize - 1);
EXPECT_EQ(0, input.ByteCount());
EXPECT_TRUE(input.Next(&data, &size));
- EXPECT_EQ(kHalfBufferSize - 1 , input.ByteCount());
+ EXPECT_EQ(kHalfBufferSize - 1, input.ByteCount());
}
// Check that a zero-size array doesn't confuse the code.
diff --git a/src/google/protobuf/lite_unittest.cc b/src/google/protobuf/lite_unittest.cc
index 65b2f52..c16bdf7 100644
--- a/src/google/protobuf/lite_unittest.cc
+++ b/src/google/protobuf/lite_unittest.cc
@@ -56,10 +56,9 @@
EXPECT_EQ(message.optional_string(), "hello");
}
-void AssignParsingMergeMessages(
- unittest::TestAllTypesLite* msg1,
- unittest::TestAllTypesLite* msg2,
- unittest::TestAllTypesLite* msg3) {
+void AssignParsingMergeMessages(unittest::TestAllTypesLite* msg1,
+ unittest::TestAllTypesLite* msg2,
+ unittest::TestAllTypesLite* msg3) {
msg1->set_optional_int32(1);
msg2->set_optional_int64(2);
msg3->set_optional_int32(3);
@@ -174,10 +173,10 @@
unittest::TestAllTypesLite* msg2;
unittest::TestAllTypesLite* msg3;
-#define ASSIGN_REPEATED_FIELD(FIELD) \
- msg1 = generator.add_##FIELD(); \
- msg2 = generator.add_##FIELD(); \
- msg3 = generator.add_##FIELD(); \
+#define ASSIGN_REPEATED_FIELD(FIELD) \
+ msg1 = generator.add_##FIELD(); \
+ msg2 = generator.add_##FIELD(); \
+ msg3 = generator.add_##FIELD(); \
AssignParsingMergeMessages(msg1, msg2, msg3)
ASSIGN_REPEATED_FIELD(field1);
@@ -447,8 +446,7 @@
protobuf_unittest::TestMessageMapLite message;
// Creates a TestAllTypes with default value
- TestUtilLite::ExpectClear(
- (*message.mutable_map_int32_message())[0]);
+ TestUtilLite::ExpectClear((*message.mutable_map_int32_message())[0]);
}
}
@@ -836,30 +834,30 @@
std::string data;
{
- // Check that adding more values to enum does not corrupt message
- // when passed through an old client.
- protobuf_unittest::V2MessageLite v2_message;
- v2_message.set_int_field(800);
- // Set enum field to the value not understood by the old client.
- v2_message.set_enum_field(protobuf_unittest::V2_SECOND);
- std::string v2_bytes = v2_message.SerializeAsString();
+ // Check that adding more values to enum does not corrupt message
+ // when passed through an old client.
+ protobuf_unittest::V2MessageLite v2_message;
+ v2_message.set_int_field(800);
+ // Set enum field to the value not understood by the old client.
+ v2_message.set_enum_field(protobuf_unittest::V2_SECOND);
+ std::string v2_bytes = v2_message.SerializeAsString();
- protobuf_unittest::V1MessageLite v1_message;
- v1_message.ParseFromString(v2_bytes);
- EXPECT_TRUE(v1_message.IsInitialized());
- EXPECT_EQ(v1_message.int_field(), v2_message.int_field());
- // V1 client does not understand V2_SECOND value, so it discards it and
- // uses default value instead.
- EXPECT_EQ(v1_message.enum_field(), protobuf_unittest::V1_FIRST);
+ protobuf_unittest::V1MessageLite v1_message;
+ v1_message.ParseFromString(v2_bytes);
+ EXPECT_TRUE(v1_message.IsInitialized());
+ EXPECT_EQ(v1_message.int_field(), v2_message.int_field());
+ // V1 client does not understand V2_SECOND value, so it discards it and
+ // uses default value instead.
+ EXPECT_EQ(v1_message.enum_field(), protobuf_unittest::V1_FIRST);
- // However, when re-serialized, it should preserve enum value.
- std::string v1_bytes = v1_message.SerializeAsString();
+ // However, when re-serialized, it should preserve enum value.
+ std::string v1_bytes = v1_message.SerializeAsString();
- protobuf_unittest::V2MessageLite same_v2_message;
- same_v2_message.ParseFromString(v1_bytes);
+ protobuf_unittest::V2MessageLite same_v2_message;
+ same_v2_message.ParseFromString(v1_bytes);
- EXPECT_EQ(v2_message.int_field(), same_v2_message.int_field());
- EXPECT_EQ(v2_message.enum_field(), same_v2_message.enum_field());
+ EXPECT_EQ(v2_message.int_field(), same_v2_message.int_field());
+ EXPECT_EQ(v2_message.enum_field(), same_v2_message.enum_field());
}
}
diff --git a/src/google/protobuf/map.h b/src/google/protobuf/map.h
index 40f35e9..2750c02 100644
--- a/src/google/protobuf/map.h
+++ b/src/google/protobuf/map.h
@@ -63,7 +63,8 @@
class MapIterator;
-template <typename Enum> struct is_proto_enum;
+template <typename Enum>
+struct is_proto_enum;
namespace internal {
template <typename Derived, typename Key, typename T,
@@ -96,8 +97,7 @@
MapPair(const Key& other_first, const T& other_second)
: first(other_first), second(other_second) {}
explicit MapPair(const Key& other_first) : first(other_first), second() {}
- MapPair(const MapPair& other)
- : first(other.first), second(other.second) {}
+ MapPair(const MapPair& other) : first(other.first), second(other.second) {}
~MapPair() {}
@@ -183,7 +183,8 @@
private:
void Init() {
- elements_ = Arena::Create<InnerMap>(arena_, 0u, hasher(), Allocator(arena_));
+ elements_ =
+ Arena::Create<InnerMap>(arena_, 0u, hasher(), Allocator(arena_));
}
// re-implement std::allocator to use arena allocator for memory allocation.
@@ -231,7 +232,7 @@
#if __cplusplus >= 201103L && !defined(GOOGLE_PROTOBUF_OS_APPLE) && \
!defined(GOOGLE_PROTOBUF_OS_NACL) && \
!defined(GOOGLE_PROTOBUF_OS_EMSCRIPTEN)
- template<class NodeType, class... Args>
+ template <class NodeType, class... Args>
void construct(NodeType* p, Args&&... args) {
// Clang 3.6 doesn't compile static casting to void* directly. (Issue
// #1266) According C++ standard 5.2.9/1: "The static_cast operator shall
@@ -241,7 +242,7 @@
NodeType(std::forward<Args>(args)...);
}
- template<class NodeType>
+ template <class NodeType>
void destroy(NodeType* p) {
p->~NodeType();
}
@@ -274,9 +275,7 @@
// To support gcc-4.4, which does not properly
// support templated friend classes
- Arena* arena() const {
- return arena_;
- }
+ Arena* arena() const { return arena_; }
private:
typedef void DestructorSkippable_;
@@ -483,8 +482,7 @@
// Force bucket_index_ to be in range.
bucket_index_ &= (m_->num_buckets_ - 1);
// Common case: the bucket we think is relevant points to node_.
- if (m_->table_[bucket_index_] == static_cast<void*>(node_))
- return true;
+ if (m_->table_[bucket_index_] == static_cast<void*>(node_)) return true;
// Less common: the bucket is a linked list with node_ somewhere in it,
// but not at the head.
if (m_->TableEntryIsNonEmptyList(bucket_index_)) {
@@ -720,10 +718,9 @@
GOOGLE_DCHECK_EQ(table_[b], table_[b ^ 1]);
// Maintain the invariant that node->next is NULL for all Nodes in Trees.
node->next = NULL;
- return iterator(static_cast<Tree*>(table_[b])
- ->insert(KeyPtrFromNodePtr(node))
- .first,
- this, b & ~static_cast<size_t>(1));
+ return iterator(
+ static_cast<Tree*>(table_[b])->insert(KeyPtrFromNodePtr(node)).first,
+ this, b & ~static_cast<size_t>(1));
}
// Returns whether it did resize. Currently this is only used when
@@ -834,7 +831,7 @@
}
static bool TableEntryIsTree(void* const* table, size_type b) {
return !TableEntryIsEmpty(table, b) &&
- !TableEntryIsNonEmptyList(table, b);
+ !TableEntryIsNonEmptyList(table, b);
}
static bool TableEntryIsList(void* const* table, size_type b) {
return !TableEntryIsTree(table, b);
@@ -942,7 +939,7 @@
size_type s = static_cast<size_type>(reinterpret_cast<uintptr_t>(this));
#if defined(__x86_64__) && defined(__GNUC__)
uint32 hi, lo;
- asm("rdtsc" : "=a" (lo), "=d" (hi));
+ asm("rdtsc" : "=a"(lo), "=d"(hi));
s += ((static_cast<uint64>(hi) << 32) | lo);
#endif
return s;
@@ -972,9 +969,7 @@
const_iterator() {}
explicit const_iterator(const InnerIt& it) : it_(it) {}
- const_reference operator*() const {
- return *it_->value();
- }
+ const_reference operator*() const { return *it_->value(); }
const_pointer operator->() const { return &(operator*()); }
const_iterator& operator++() {
@@ -1051,7 +1046,7 @@
// Element access
T& operator[](const key_type& key) {
- value_type** value = &(*elements_)[key];
+ value_type** value = &(*elements_)[key];
if (*value == NULL) {
*value = CreateValueTypeInternal(key);
internal::MapValueInitializer<is_proto_enum<T>::value, T>::Initialize(
diff --git a/src/google/protobuf/map_entry_lite.h b/src/google/protobuf/map_entry_lite.h
index 756b9af..c7d7558 100644
--- a/src/google/protobuf/map_entry_lite.h
+++ b/src/google/protobuf/map_entry_lite.h
@@ -122,16 +122,16 @@
// Enum type cannot be used for MapTypeHandler::Read. Define a type
// which will replace Enum with int.
typedef typename KeyTypeHandler::MapEntryAccessorType KeyMapEntryAccessorType;
- typedef typename ValueTypeHandler::MapEntryAccessorType
- ValueMapEntryAccessorType;
+ typedef
+ typename ValueTypeHandler::MapEntryAccessorType ValueMapEntryAccessorType;
// Constants for field number.
static const int kKeyFieldNumber = 1;
static const int kValueFieldNumber = 2;
// Constants for field tag.
- static const uint8 kKeyTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
- kKeyFieldNumber, KeyTypeHandler::kWireType);
+ static const uint8 kKeyTag =
+ GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kKeyFieldNumber, KeyTypeHandler::kWireType);
static const uint8 kValueTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
kValueFieldNumber, ValueTypeHandler::kWireType);
static const size_t kTagSize = 1;
@@ -202,12 +202,14 @@
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
if (tag == kKeyTag) {
set_has_key();
- ptr = KeyTypeHandler::Read(ptr, ctx, mutable_key());
- if (!::down_cast<Derived*>(this)->ValidateKey()) return nullptr;
+ KeyMapEntryAccessorType* key = mutable_key();
+ ptr = KeyTypeHandler::Read(ptr, ctx, key);
+ if (!Derived::ValidateKey(key)) return nullptr;
} else if (tag == kValueTag) {
set_has_value();
- ptr = ValueTypeHandler::Read(ptr, ctx, mutable_value());
- if (!::down_cast<Derived*>(this)->ValidateValue()) return nullptr;
+ ValueMapEntryAccessorType* value = mutable_value();
+ ptr = ValueTypeHandler::Read(ptr, ctx, value);
+ if (!Derived::ValidateValue(value)) return nullptr;
} else {
if (tag == 0 || WireFormatLite::GetTagWireType(tag) ==
WireFormatLite::WIRETYPE_END_GROUP) {
@@ -251,9 +253,8 @@
break;
default:
- if (tag == 0 ||
- WireFormatLite::GetTagWireType(tag) ==
- WireFormatLite::WIRETYPE_END_GROUP) {
+ if (tag == 0 || WireFormatLite::GetTagWireType(tag) ==
+ WireFormatLite::WIRETYPE_END_GROUP) {
return true;
}
if (!WireFormatLite::SkipField(input, tag)) return false;
@@ -265,10 +266,13 @@
size_t ByteSizeLong() const override {
size_t size = 0;
- size += has_key() ?
- kTagSize + static_cast<size_t>(KeyTypeHandler::ByteSize(key())) : 0;
- size += has_value() ?
- kTagSize + static_cast<size_t>(ValueTypeHandler::ByteSize(value())) : 0;
+ size += has_key() ? kTagSize +
+ static_cast<size_t>(KeyTypeHandler::ByteSize(key()))
+ : 0;
+ size += has_value()
+ ? kTagSize +
+ static_cast<size_t>(ValueTypeHandler::ByteSize(value()))
+ : 0;
return size;
}
@@ -288,12 +292,12 @@
int GetCachedSize() const override {
int size = 0;
- size += has_key()
- ? static_cast<int>(kTagSize) + KeyTypeHandler::GetCachedSize(key())
- : 0;
- size += has_value()
- ? static_cast<int>(kTagSize) + ValueTypeHandler::GetCachedSize(value())
- : 0;
+ size += has_key() ? static_cast<int>(kTagSize) +
+ KeyTypeHandler::GetCachedSize(key())
+ : 0;
+ size += has_value() ? static_cast<int>(kTagSize) +
+ ValueTypeHandler::GetCachedSize(value())
+ : 0;
return size;
}
@@ -332,8 +336,8 @@
public:
void Clear() override {
KeyTypeHandler::Clear(&key_, GetArenaNoVirtual());
- ValueTypeHandler::ClearMaybeByDefaultEnum(
- &value_, GetArenaNoVirtual(), default_enum_value);
+ ValueTypeHandler::ClearMaybeByDefaultEnum(&value_, GetArenaNoVirtual(),
+ default_enum_value);
clear_has_key();
clear_has_value();
}
@@ -416,10 +420,43 @@
}
const char* _InternalParse(const char* ptr, ParseContext* ctx) {
- auto entry = NewEntry();
- ptr = entry->_InternalParse(ptr, ctx);
- if (!ptr) return nullptr;
- UseKeyAndValueFromEntry();
+ if (PROTOBUF_PREDICT_TRUE(!ctx->Done(&ptr) && *ptr == kKeyTag)) {
+ ptr = KeyTypeHandler::Read(ptr + 1, ctx, &key_);
+ if (PROTOBUF_PREDICT_FALSE(!ptr || !Derived::ValidateKey(&key_))) {
+ return nullptr;
+ }
+ if (PROTOBUF_PREDICT_TRUE(!ctx->Done(&ptr) && *ptr == kValueTag)) {
+ typename Map::size_type map_size = map_->size();
+ value_ptr_ = &(*map_)[key_];
+ if (PROTOBUF_PREDICT_TRUE(map_size != map_->size())) {
+ using T =
+ typename MapIf<ValueTypeHandler::kIsEnum, int*, Value*>::type;
+ ptr = ValueTypeHandler::Read(ptr + 1, ctx,
+ reinterpret_cast<T>(value_ptr_));
+ if (PROTOBUF_PREDICT_FALSE(!ptr ||
+ !Derived::ValidateValue(value_ptr_))) {
+ map_->erase(key_); // Failure! Undo insertion.
+ return nullptr;
+ }
+ if (PROTOBUF_PREDICT_TRUE(ctx->Done(&ptr))) return ptr;
+ if (!ptr) return nullptr;
+ NewEntry();
+ ValueMover::Move(value_ptr_, entry_->mutable_value());
+ map_->erase(key_);
+ goto move_key;
+ }
+ } else {
+ if (!ptr) return nullptr;
+ }
+ NewEntry();
+ move_key:
+ KeyMover::Move(&key_, entry_->mutable_key());
+ } else {
+ if (!ptr) return nullptr;
+ NewEntry();
+ }
+ ptr = entry_->_InternalParse(ptr, ctx);
+ if (ptr) UseKeyAndValueFromEntry();
return ptr;
}
@@ -455,27 +492,13 @@
// path, so it's not a big deal.
key_ = entry_->key();
value_ptr_ = &(*map_)[key_];
- MoveHelper<ValueTypeHandler::kIsEnum,
- ValueTypeHandler::kIsMessage,
- ValueTypeHandler::kWireType ==
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
- Value>::Move(entry_->mutable_value(), value_ptr_);
+ ValueMover::Move(entry_->mutable_value(), value_ptr_);
}
// After reading a key and value successfully, and inserting that data
// into map_, we are not at the end of the input. This is unusual, but
// allowed by the spec.
bool ReadBeyondKeyValuePair(io::CodedInputStream* input) PROTOBUF_COLD {
- typedef MoveHelper<KeyTypeHandler::kIsEnum,
- KeyTypeHandler::kIsMessage,
- KeyTypeHandler::kWireType ==
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
- Key> KeyMover;
- typedef MoveHelper<ValueTypeHandler::kIsEnum,
- ValueTypeHandler::kIsMessage,
- ValueTypeHandler::kWireType ==
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
- Value> ValueMover;
NewEntry();
ValueMover::Move(value_ptr_, entry_->mutable_value());
map_->erase(key_);
@@ -485,6 +508,17 @@
return result;
}
+ typedef MoveHelper<KeyTypeHandler::kIsEnum, KeyTypeHandler::kIsMessage,
+ KeyTypeHandler::kWireType ==
+ WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+ Key>
+ KeyMover;
+ typedef MoveHelper<ValueTypeHandler::kIsEnum, ValueTypeHandler::kIsMessage,
+ ValueTypeHandler::kWireType ==
+ WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+ Value>
+ ValueMover;
+
MapField* const mf_;
Map* const map_;
Key key_;
@@ -566,9 +600,7 @@
typedef void DestructorSkippable_;
};
- inline Arena* GetArenaNoVirtual() const {
- return arena_;
- }
+ inline Arena* GetArenaNoVirtual() const { return arena_; }
public: // Needed for constructing tables
KeyOnMemory key_;
@@ -629,7 +661,8 @@
// type is relatively small and easy to copy then copying Keys into an
// array of SortItems can be beneficial. Then all the data the sorting
// algorithm needs to touch is in that one array.
-template <typename Key, typename PtrToKeyValuePair> struct SortItem {
+template <typename Key, typename PtrToKeyValuePair>
+struct SortItem {
SortItem() {}
explicit SortItem(PtrToKeyValuePair p) : first(p->first), second(p) {}
@@ -637,16 +670,14 @@
PtrToKeyValuePair second;
};
-template <typename T> struct CompareByFirstField {
- bool operator()(const T& a, const T& b) const {
- return a.first < b.first;
- }
+template <typename T>
+struct CompareByFirstField {
+ bool operator()(const T& a, const T& b) const { return a.first < b.first; }
};
-template <typename T> struct CompareByDerefFirst {
- bool operator()(const T& a, const T& b) const {
- return a->first < b->first;
- }
+template <typename T>
+struct CompareByDerefFirst {
+ bool operator()(const T& a, const T& b) const { return a->first < b->first; }
};
// Helper for table driven serialization
diff --git a/src/google/protobuf/map_field.cc b/src/google/protobuf/map_field.cc
index 5ed84f3..2a71b6b 100644
--- a/src/google/protobuf/map_field.cc
+++ b/src/google/protobuf/map_field.cc
@@ -99,35 +99,35 @@
// acquire here matches with release below to ensure that we can only see a
// value of CLEAN after all previous changes have been synced.
switch (state_.load(std::memory_order_acquire)) {
- case STATE_MODIFIED_MAP:
- mutex_.Lock();
- // Double check state, because another thread may have seen the same
- // state and done the synchronization before the current thread.
- if (state_.load(std::memory_order_relaxed) == STATE_MODIFIED_MAP) {
- SyncRepeatedFieldWithMapNoLock();
- state_.store(CLEAN, std::memory_order_release);
- }
- mutex_.Unlock();
- break;
- case CLEAN:
- mutex_.Lock();
- // Double check state
- if (state_.load(std::memory_order_relaxed) == CLEAN) {
- if (repeated_field_ == nullptr) {
- if (arena_ == nullptr) {
- repeated_field_ = new RepeatedPtrField<Message>();
- } else {
- repeated_field_ =
- Arena::CreateMessage<RepeatedPtrField<Message> >(arena_);
- }
+ case STATE_MODIFIED_MAP:
+ mutex_.Lock();
+ // Double check state, because another thread may have seen the same
+ // state and done the synchronization before the current thread.
+ if (state_.load(std::memory_order_relaxed) == STATE_MODIFIED_MAP) {
+ SyncRepeatedFieldWithMapNoLock();
+ state_.store(CLEAN, std::memory_order_release);
+ }
+ mutex_.Unlock();
+ break;
+ case CLEAN:
+ mutex_.Lock();
+ // Double check state
+ if (state_.load(std::memory_order_relaxed) == CLEAN) {
+ if (repeated_field_ == nullptr) {
+ if (arena_ == nullptr) {
+ repeated_field_ = new RepeatedPtrField<Message>();
+ } else {
+ repeated_field_ =
+ Arena::CreateMessage<RepeatedPtrField<Message> >(arena_);
}
- state_.store(CLEAN, std::memory_order_release);
}
- mutex_.Unlock();
- break;
- default:
- break;
- }
+ state_.store(CLEAN, std::memory_order_release);
+ }
+ mutex_.Unlock();
+ break;
+ default:
+ break;
+ }
}
void MapFieldBase::SyncRepeatedFieldWithMapNoLock() const {
@@ -153,15 +153,12 @@
// ------------------DynamicMapField------------------
DynamicMapField::DynamicMapField(const Message* default_entry)
- : default_entry_(default_entry) {
-}
+ : default_entry_(default_entry) {}
-DynamicMapField::DynamicMapField(const Message* default_entry,
- Arena* arena)
+DynamicMapField::DynamicMapField(const Message* default_entry, Arena* arena)
: TypeDefinedMapFieldBase<MapKey, MapValueRef>(arena),
map_(arena),
- default_entry_(default_entry) {
-}
+ default_entry_(default_entry) {}
DynamicMapField::~DynamicMapField() {
// DynamicMapField owns map values. Need to delete them before clearing
@@ -173,9 +170,7 @@
map_.clear();
}
-int DynamicMapField::size() const {
- return GetMap().size();
-}
+int DynamicMapField::size() const { return GetMap().size(); }
void DynamicMapField::Clear() {
Map<MapKey, MapValueRef>* map = &const_cast<DynamicMapField*>(this)->map_;
@@ -193,8 +188,7 @@
MapFieldBase::SetMapDirty();
}
-bool DynamicMapField::ContainsMapKey(
- const MapKey& map_key) const {
+bool DynamicMapField::ContainsMapKey(const MapKey& map_key) const {
const Map<MapKey, MapValueRef>& map = GetMap();
Map<MapKey, MapValueRef>::const_iterator iter = map.find(map_key);
return iter != map.end();
@@ -207,12 +201,12 @@
// Allocate memory for the MapValueRef, and initialize to
// default value.
switch (val_des->cpp_type()) {
-#define HANDLE_TYPE(CPPTYPE, TYPE) \
- case FieldDescriptor::CPPTYPE_##CPPTYPE: { \
- TYPE* value = new TYPE(); \
- map_val->SetValue(value); \
- break; \
- }
+#define HANDLE_TYPE(CPPTYPE, TYPE) \
+ case FieldDescriptor::CPPTYPE_##CPPTYPE: { \
+ TYPE* value = new TYPE(); \
+ map_val->SetValue(value); \
+ break; \
+ }
HANDLE_TYPE(INT32, int32);
HANDLE_TYPE(INT64, int64);
HANDLE_TYPE(UINT32, uint32);
@@ -224,8 +218,8 @@
HANDLE_TYPE(ENUM, int32);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_MESSAGE: {
- const Message& message = default_entry_->GetReflection()->GetMessage(
- *default_entry_, val_des);
+ const Message& message =
+ default_entry_->GetReflection()->GetMessage(*default_entry_, val_des);
Message* value = message.New();
map_val->SetValue(value);
break;
@@ -233,8 +227,8 @@
}
}
-bool DynamicMapField::InsertOrLookupMapValue(
- const MapKey& map_key, MapValueRef* val) {
+bool DynamicMapField::InsertOrLookupMapValue(const MapKey& map_key,
+ MapValueRef* val) {
// Always use mutable map because users may change the map value by
// MapValueRef.
Map<MapKey, MapValueRef>* map = MutableMap();
@@ -290,8 +284,8 @@
const DynamicMapField& other_field =
reinterpret_cast<const DynamicMapField&>(other);
for (typename Map<MapKey, MapValueRef>::const_iterator other_it =
- other_field.map_.begin(); other_it != other_field.map_.end();
- ++other_it) {
+ other_field.map_.begin();
+ other_it != other_field.map_.end(); ++other_it) {
Map<MapKey, MapValueRef>::iterator iter = map->find(other_it->first);
MapValueRef* map_val;
if (iter == map->end()) {
diff --git a/src/google/protobuf/map_field.h b/src/google/protobuf/map_field.h
index c60510e..d804dee 100644
--- a/src/google/protobuf/map_field.h
+++ b/src/google/protobuf/map_field.h
@@ -69,13 +69,9 @@
class PROTOBUF_EXPORT MapFieldBase {
public:
MapFieldBase()
- : arena_(NULL),
- repeated_field_(NULL),
- state_(STATE_MODIFIED_MAP) {}
+ : arena_(NULL), repeated_field_(NULL), state_(STATE_MODIFIED_MAP) {}
explicit MapFieldBase(Arena* arena)
- : arena_(arena),
- repeated_field_(NULL),
- state_(STATE_MODIFIED_MAP) {
+ : arena_(arena), repeated_field_(NULL), state_(STATE_MODIFIED_MAP) {
// Mutex's destructor needs to be called explicitly to release resources
// acquired in its constructor.
arena->OwnDestructor(&mutex_);
@@ -92,8 +88,8 @@
// Pure virtual map APIs for Map Reflection.
virtual bool ContainsMapKey(const MapKey& map_key) const = 0;
- virtual bool InsertOrLookupMapValue(
- const MapKey& map_key, MapValueRef* val) = 0;
+ virtual bool InsertOrLookupMapValue(const MapKey& map_key,
+ MapValueRef* val) = 0;
// Returns whether changes to the map are reflected in the repeated field.
bool IsRepeatedFieldValid() const;
// Insures operations after won't get executed before calling this.
@@ -145,14 +141,15 @@
// synchronized to repeated field
STATE_MODIFIED_REPEATED = 1, // repeated field has newly added data that
// has not been synchronized to map
- CLEAN = 2, // data in map and repeated field are same
+ CLEAN = 2, // data in map and repeated field are same
};
Arena* arena_;
mutable RepeatedPtrField<Message>* repeated_field_;
- mutable internal::WrappedMutex mutex_; // The thread to synchronize map and repeated field
- // needs to get lock first;
+ mutable internal::WrappedMutex
+ mutex_; // The thread to synchronize map and repeated field
+ // needs to get lock first;
mutable std::atomic<State> state_;
private:
@@ -186,7 +183,7 @@
// This class provides common Map Reflection implementations for generated
// message and dynamic message.
-template<typename Key, typename T>
+template <typename Key, typename T>
class TypeDefinedMapFieldBase : public MapFieldBase {
public:
TypeDefinedMapFieldBase() {}
@@ -321,7 +318,7 @@
WireFormatLite::FieldType kKeyFieldType,
WireFormatLite::FieldType kValueFieldType, int default_enum_value>
struct MapEntryToMapField<MapEntry<T, Key, Value, kKeyFieldType,
- kValueFieldType, default_enum_value> > {
+ kValueFieldType, default_enum_value>> {
typedef MapField<T, Key, Value, kKeyFieldType, kValueFieldType,
default_enum_value>
MapFieldType;
@@ -363,26 +360,21 @@
} // namespace internal
-#define TYPE_CHECK(EXPECTEDTYPE, METHOD) \
- if (type() != EXPECTEDTYPE) { \
- GOOGLE_LOG(FATAL) \
- << "Protocol Buffer map usage error:\n" \
- << METHOD << " type does not match\n" \
- << " Expected : " \
- << FieldDescriptor::CppTypeName(EXPECTEDTYPE) << "\n" \
- << " Actual : " \
- << FieldDescriptor::CppTypeName(type()); \
+#define TYPE_CHECK(EXPECTEDTYPE, METHOD) \
+ if (type() != EXPECTEDTYPE) { \
+ GOOGLE_LOG(FATAL) << "Protocol Buffer map usage error:\n" \
+ << METHOD << " type does not match\n" \
+ << " Expected : " \
+ << FieldDescriptor::CppTypeName(EXPECTEDTYPE) << "\n" \
+ << " Actual : " << FieldDescriptor::CppTypeName(type()); \
}
// MapKey is an union type for representing any possible
// map key.
class PROTOBUF_EXPORT MapKey {
public:
- MapKey() : type_(0) {
- }
- MapKey(const MapKey& other) : type_(0) {
- CopyFrom(other);
- }
+ MapKey() : type_(0) {}
+ MapKey(const MapKey& other) : type_(0) { CopyFrom(other); }
MapKey& operator=(const MapKey& other) {
CopyFrom(other);
return *this;
@@ -396,10 +388,9 @@
FieldDescriptor::CppType type() const {
if (type_ == 0) {
- GOOGLE_LOG(FATAL)
- << "Protocol Buffer map usage error:\n"
- << "MapKey::type MapKey is not initialized. "
- << "Call set methods to initialize MapKey.";
+ GOOGLE_LOG(FATAL) << "Protocol Buffer map usage error:\n"
+ << "MapKey::type MapKey is not initialized. "
+ << "Call set methods to initialize MapKey.";
}
return (FieldDescriptor::CppType)type_;
}
@@ -430,33 +421,27 @@
}
int64 GetInt64Value() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
- "MapKey::GetInt64Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapKey::GetInt64Value");
return val_.int64_value_;
}
uint64 GetUInt64Value() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
- "MapKey::GetUInt64Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapKey::GetUInt64Value");
return val_.uint64_value_;
}
int32 GetInt32Value() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
- "MapKey::GetInt32Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapKey::GetInt32Value");
return val_.int32_value_;
}
uint32 GetUInt32Value() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
- "MapKey::GetUInt32Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapKey::GetUInt32Value");
return val_.uint32_value_;
}
bool GetBoolValue() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL,
- "MapKey::GetBoolValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapKey::GetBoolValue");
return val_.bool_value_;
}
const std::string& GetStringValue() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING,
- "MapKey::GetStringValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING, "MapKey::GetStringValue");
return *val_.string_value_;
}
@@ -585,95 +570,77 @@
MapValueRef() : data_(NULL), type_(0) {}
void SetInt64Value(int64 value) {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
- "MapValueRef::SetInt64Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapValueRef::SetInt64Value");
*reinterpret_cast<int64*>(data_) = value;
}
void SetUInt64Value(uint64 value) {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
- "MapValueRef::SetUInt64Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapValueRef::SetUInt64Value");
*reinterpret_cast<uint64*>(data_) = value;
}
void SetInt32Value(int32 value) {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
- "MapValueRef::SetInt32Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapValueRef::SetInt32Value");
*reinterpret_cast<int32*>(data_) = value;
}
void SetUInt32Value(uint32 value) {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
- "MapValueRef::SetUInt32Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapValueRef::SetUInt32Value");
*reinterpret_cast<uint32*>(data_) = value;
}
void SetBoolValue(bool value) {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL,
- "MapValueRef::SetBoolValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapValueRef::SetBoolValue");
*reinterpret_cast<bool*>(data_) = value;
}
// TODO(jieluo) - Checks that enum is member.
void SetEnumValue(int value) {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM,
- "MapValueRef::SetEnumValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM, "MapValueRef::SetEnumValue");
*reinterpret_cast<int*>(data_) = value;
}
void SetStringValue(const std::string& value) {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING,
- "MapValueRef::SetStringValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING, "MapValueRef::SetStringValue");
*reinterpret_cast<std::string*>(data_) = value;
}
void SetFloatValue(float value) {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT,
- "MapValueRef::SetFloatValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT, "MapValueRef::SetFloatValue");
*reinterpret_cast<float*>(data_) = value;
}
void SetDoubleValue(double value) {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE,
- "MapValueRef::SetDoubleValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE, "MapValueRef::SetDoubleValue");
*reinterpret_cast<double*>(data_) = value;
}
int64 GetInt64Value() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
- "MapValueRef::GetInt64Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapValueRef::GetInt64Value");
return *reinterpret_cast<int64*>(data_);
}
uint64 GetUInt64Value() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
- "MapValueRef::GetUInt64Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapValueRef::GetUInt64Value");
return *reinterpret_cast<uint64*>(data_);
}
int32 GetInt32Value() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
- "MapValueRef::GetInt32Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapValueRef::GetInt32Value");
return *reinterpret_cast<int32*>(data_);
}
uint32 GetUInt32Value() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
- "MapValueRef::GetUInt32Value");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapValueRef::GetUInt32Value");
return *reinterpret_cast<uint32*>(data_);
}
bool GetBoolValue() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL,
- "MapValueRef::GetBoolValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapValueRef::GetBoolValue");
return *reinterpret_cast<bool*>(data_);
}
int GetEnumValue() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM,
- "MapValueRef::GetEnumValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM, "MapValueRef::GetEnumValue");
return *reinterpret_cast<int*>(data_);
}
const std::string& GetStringValue() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING,
- "MapValueRef::GetStringValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING, "MapValueRef::GetStringValue");
return *reinterpret_cast<std::string*>(data_);
}
float GetFloatValue() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT,
- "MapValueRef::GetFloatValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT, "MapValueRef::GetFloatValue");
return *reinterpret_cast<float*>(data_);
}
double GetDoubleValue() const {
- TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE,
- "MapValueRef::GetDoubleValue");
+ TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE, "MapValueRef::GetDoubleValue");
return *reinterpret_cast<double*>(data_);
}
@@ -701,21 +668,16 @@
friend class internal::GeneratedMessageReflection;
friend class internal::DynamicMapField;
- void SetType(FieldDescriptor::CppType type) {
- type_ = type;
- }
+ void SetType(FieldDescriptor::CppType type) { type_ = type; }
FieldDescriptor::CppType type() const {
if (type_ == 0 || data_ == NULL) {
- GOOGLE_LOG(FATAL)
- << "Protocol Buffer map usage error:\n"
- << "MapValueRef::type MapValueRef is not initialized.";
+ GOOGLE_LOG(FATAL) << "Protocol Buffer map usage error:\n"
+ << "MapValueRef::type MapValueRef is not initialized.";
}
return (FieldDescriptor::CppType)type_;
}
- void SetValue(const void* val) {
- data_ = const_cast<void*>(val);
- }
+ void SetValue(const void* val) { data_ = const_cast<void*>(val); }
void CopyFrom(const MapValueRef& other) {
type_ = other.type_;
data_ = other.data_;
@@ -764,9 +726,7 @@
map_->InitializeIterator(this);
map_->CopyIterator(this, other);
}
- ~MapIterator() {
- map_->DeleteIterator(this);
- }
+ ~MapIterator() { map_->DeleteIterator(this); }
MapIterator& operator=(const MapIterator& other) {
map_ = other.map_;
map_->CopyIterator(this, other);
@@ -789,12 +749,8 @@
map_->IncreaseIterator(this);
return *this;
}
- const MapKey& GetKey() {
- return key_;
- }
- const MapValueRef& GetValueRef() {
- return value_;
- }
+ const MapKey& GetKey() { return key_; }
+ const MapValueRef& GetValueRef() { return value_; }
MapValueRef* MutableValueRef() {
map_->SetMapDirty();
return &value_;
diff --git a/src/google/protobuf/map_field_inl.h b/src/google/protobuf/map_field_inl.h
index 85d5b03..7baaa5f 100644
--- a/src/google/protobuf/map_field_inl.h
+++ b/src/google/protobuf/map_field_inl.h
@@ -46,25 +46,25 @@
namespace protobuf {
namespace internal {
// UnwrapMapKey template
-template<typename T>
+template <typename T>
T UnwrapMapKey(const MapKey& map_key);
-template<>
+template <>
inline int32 UnwrapMapKey<int32>(const MapKey& map_key) {
return map_key.GetInt32Value();
}
-template<>
+template <>
inline uint32 UnwrapMapKey<uint32>(const MapKey& map_key) {
return map_key.GetUInt32Value();
}
-template<>
+template <>
inline int64 UnwrapMapKey<int64>(const MapKey& map_key) {
return map_key.GetInt64Value();
}
-template<>
+template <>
inline uint64 UnwrapMapKey<uint64>(const MapKey& map_key) {
return map_key.GetUInt64Value();
}
-template<>
+template <>
inline bool UnwrapMapKey<bool>(const MapKey& map_key) {
return map_key.GetBoolValue();
}
@@ -74,25 +74,25 @@
}
// SetMapKey template
-template<typename T>
+template <typename T>
inline void SetMapKey(MapKey* map_key, const T& value);
-template<>
+template <>
inline void SetMapKey<int32>(MapKey* map_key, const int32& value) {
map_key->SetInt32Value(value);
}
-template<>
+template <>
inline void SetMapKey<uint32>(MapKey* map_key, const uint32& value) {
map_key->SetUInt32Value(value);
}
-template<>
+template <>
inline void SetMapKey<int64>(MapKey* map_key, const int64& value) {
map_key->SetInt64Value(value);
}
-template<>
+template <>
inline void SetMapKey<uint64>(MapKey* map_key, const uint64& value) {
map_key->SetUInt64Value(value);
}
-template<>
+template <>
inline void SetMapKey<bool>(MapKey* map_key, const bool& value) {
map_key->SetBoolValue(value);
}
@@ -106,7 +106,7 @@
typename Map<Key, T>::const_iterator&
TypeDefinedMapFieldBase<Key, T>::InternalGetIterator(
const MapIterator* map_iter) const {
- return *reinterpret_cast<typename Map<Key, T>::const_iterator *>(
+ return *reinterpret_cast<typename Map<Key, T>::const_iterator*>(
map_iter->iter_);
}
@@ -122,15 +122,14 @@
}
template <typename Key, typename T>
-bool TypeDefinedMapFieldBase<Key, T>::EqualIterator(const MapIterator& a,
- const MapIterator& b)
- const {
+bool TypeDefinedMapFieldBase<Key, T>::EqualIterator(
+ const MapIterator& a, const MapIterator& b) const {
return InternalGetIterator(&a) == InternalGetIterator(&b);
}
template <typename Key, typename T>
-void TypeDefinedMapFieldBase<Key, T>::IncreaseIterator(MapIterator* map_iter)
- const {
+void TypeDefinedMapFieldBase<Key, T>::IncreaseIterator(
+ MapIterator* map_iter) const {
++InternalGetIterator(map_iter);
SetMapIteratorValue(map_iter);
}
@@ -143,16 +142,15 @@
}
template <typename Key, typename T>
-void TypeDefinedMapFieldBase<Key, T>::DeleteIterator(MapIterator* map_iter)
- const {
- delete reinterpret_cast<typename Map<Key, T>::const_iterator *>(
+void TypeDefinedMapFieldBase<Key, T>::DeleteIterator(
+ MapIterator* map_iter) const {
+ delete reinterpret_cast<typename Map<Key, T>::const_iterator*>(
map_iter->iter_);
}
template <typename Key, typename T>
void TypeDefinedMapFieldBase<Key, T>::CopyIterator(
- MapIterator* this_iter,
- const MapIterator& that_iter) const {
+ MapIterator* this_iter, const MapIterator& that_iter) const {
InternalGetIterator(this_iter) = InternalGetIterator(&that_iter);
this_iter->key_.SetType(that_iter.key_.type());
// MapValueRef::type() fails when containing data is null. However, if
@@ -301,8 +299,8 @@
// know that this MapEntry default_type has also already been constructed.
// So it's safe to just call internal_default_instance().
const Message* default_entry = Derived::internal_default_instance();
- for (typename Map<Key, T>::const_iterator it = map.begin();
- it != map.end(); ++it) {
+ for (typename Map<Key, T>::const_iterator it = map.begin(); it != map.end();
+ ++it) {
EntryType* new_entry =
down_cast<EntryType*>(default_entry->New(this->MapFieldBase::arena_));
repeated_field->AddAllocated(new_entry);
@@ -323,7 +321,8 @@
GOOGLE_CHECK(this->MapFieldBase::repeated_field_ != NULL);
map->clear();
for (typename RepeatedPtrField<EntryType>::iterator it =
- repeated_field->begin(); it != repeated_field->end(); ++it) {
+ repeated_field->begin();
+ it != repeated_field->end(); ++it) {
// Cast is needed because Map's api and internal storage is different when
// value is enum. For enum, we cannot cast an int to enum. Thus, we have to
// copy value. For other types, they have same exposed api type and internal
diff --git a/src/google/protobuf/map_field_lite.h b/src/google/protobuf/map_field_lite.h
index bef2140..180a788 100644
--- a/src/google/protobuf/map_field_lite.h
+++ b/src/google/protobuf/map_field_lite.h
@@ -176,7 +176,7 @@
WireFormatLite::FieldType kKeyFieldType,
WireFormatLite::FieldType kValueFieldType, int default_enum_value>
struct MapEntryToMapField<MapEntryLite<T, Key, Value, kKeyFieldType,
- kValueFieldType, default_enum_value> > {
+ kValueFieldType, default_enum_value>> {
typedef MapFieldLite<MapEntryLite<T, Key, Value, kKeyFieldType,
kValueFieldType, default_enum_value>,
Key, Value, kKeyFieldType, kValueFieldType,
diff --git a/src/google/protobuf/map_field_test.cc b/src/google/protobuf/map_field_test.cc
index ecb25f4..5c44070 100644
--- a/src/google/protobuf/map_field_test.cc
+++ b/src/google/protobuf/map_field_test.cc
@@ -65,9 +65,7 @@
MapFieldBase::SyncMapWithRepeatedField();
}
// Get underlined repeated field without synchronizing map.
- RepeatedPtrField<Message>* InternalRepeatedField() {
- return repeated_field_;
- }
+ RepeatedPtrField<Message>* InternalRepeatedField() { return repeated_field_; }
bool IsMapClean() {
return state_.load(std::memory_order_relaxed) != STATE_MODIFIED_MAP;
}
@@ -80,15 +78,11 @@
void SetRepeatedDirty() {
state_.store(STATE_MODIFIED_REPEATED, std::memory_order_relaxed);
}
- bool ContainsMapKey(const MapKey& map_key) const {
- return false;
- }
+ bool ContainsMapKey(const MapKey& map_key) const { return false; }
bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val) {
return false;
}
- bool DeleteMapValue(const MapKey& map_key) {
- return false;
- }
+ bool DeleteMapValue(const MapKey& map_key) { return false; }
bool EqualIterator(const MapIterator& a, const MapIterator& b) const {
return false;
}
@@ -210,8 +204,7 @@
enum State { CLEAN, MAP_DIRTY, REPEATED_DIRTY };
} // anonymous namespace
-class MapFieldStateTest
- : public testing::TestWithParam<State> {
+class MapFieldStateTest : public testing::TestWithParam<State> {
public:
protected:
typedef unittest::TestMap_MapInt32Int32Entry_DoNotUse EntryType;
diff --git a/src/google/protobuf/map_test.cc b/src/google/protobuf/map_test.cc
index 137a4d8..ec13b3c 100644
--- a/src/google/protobuf/map_test.cc
+++ b/src/google/protobuf/map_test.cc
@@ -132,9 +132,9 @@
Map<int32, int32>::iterator it = map_.find(key);
// iterator dereferenceable
- EXPECT_EQ(key, (*it).first);
+ EXPECT_EQ(key, (*it).first);
EXPECT_EQ(value, (*it).second);
- EXPECT_EQ(key, it->first);
+ EXPECT_EQ(key, it->first);
EXPECT_EQ(value, it->second);
// iterator mutable
@@ -244,13 +244,9 @@
EXPECT_EQ("abc", to.GetStringValue());
}
-TEST_F(MapImplTest, CountNonExist) {
- EXPECT_EQ(0, map_.count(0));
-}
+TEST_F(MapImplTest, CountNonExist) { EXPECT_EQ(0, map_.count(0)); }
-TEST_F(MapImplTest, ContainNotExist) {
- EXPECT_FALSE(map_.contains(0));
-}
+TEST_F(MapImplTest, ContainNotExist) { EXPECT_FALSE(map_.contains(0)); }
TEST_F(MapImplTest, ImmutableContainNotExist) {
EXPECT_FALSE(const_map_.contains(0));
@@ -433,8 +429,7 @@
}
template <typename T, typename U>
-static void TestValidityForAllKeysExcept(int key_to_avoid,
- const T& check_map,
+static void TestValidityForAllKeysExcept(int key_to_avoid, const T& check_map,
const U& map) {
typedef typename U::value_type value_type; // a key-value pair
for (typename U::const_iterator it = map.begin(); it != map.end(); ++it) {
@@ -466,7 +461,8 @@
static void TestOldVersusNewIterator(int skip, Map<int, int>* m) {
const int initial_size = m->size();
IteratorType it = m->begin();
- for (int i = 0; i < skip && it != m->end(); it++, i++) {}
+ for (int i = 0; i < skip && it != m->end(); it++, i++) {
+ }
if (it == m->end()) return;
const IteratorType old = it;
GOOGLE_LOG(INFO) << "skip=" << skip << ", old->first=" << old->first;
@@ -633,8 +629,9 @@
TEST_F(MapImplTest, IteratorCategory) {
EXPECT_TRUE(IsForwardIteratorHelper(
std::iterator_traits<Map<int, int>::iterator>::iterator_category()));
- EXPECT_TRUE(IsForwardIteratorHelper(std::iterator_traits<
- Map<int, int>::const_iterator>::iterator_category()));
+ EXPECT_TRUE(IsForwardIteratorHelper(
+ std::iterator_traits<
+ Map<int, int>::const_iterator>::iterator_category()));
}
TEST_F(MapImplTest, InsertSingle) {
@@ -948,11 +945,10 @@
another[9398] = 41999;
another[8070] = 42056;
another.swap(map_);
- EXPECT_THAT(another, testing::UnorderedElementsAre(
- testing::Pair(9398, 41999)));
- EXPECT_THAT(map_, testing::UnorderedElementsAre(
- testing::Pair(8070, 42056),
- testing::Pair(9398, 41999)));
+ EXPECT_THAT(another,
+ testing::UnorderedElementsAre(testing::Pair(9398, 41999)));
+ EXPECT_THAT(map_, testing::UnorderedElementsAre(testing::Pair(8070, 42056),
+ testing::Pair(9398, 41999)));
}
TEST_F(MapImplTest, SwapArena) {
@@ -965,23 +961,18 @@
m2[10244] = 10247;
m2[8070] = 42056;
m1.swap(map_);
- EXPECT_THAT(m1, testing::UnorderedElementsAre(
- testing::Pair(9398, 41999)));
- EXPECT_THAT(map_, testing::UnorderedElementsAre(
- testing::Pair(8070, 42056),
- testing::Pair(9398, 41999)));
+ EXPECT_THAT(m1, testing::UnorderedElementsAre(testing::Pair(9398, 41999)));
+ EXPECT_THAT(map_, testing::UnorderedElementsAre(testing::Pair(8070, 42056),
+ testing::Pair(9398, 41999)));
m2.swap(m1);
- EXPECT_THAT(m1, testing::UnorderedElementsAre(
- testing::Pair(8070, 42056),
- testing::Pair(10244, 10247)));
- EXPECT_THAT(m2, testing::UnorderedElementsAre(
- testing::Pair(9398, 41999)));
+ EXPECT_THAT(m1, testing::UnorderedElementsAre(testing::Pair(8070, 42056),
+ testing::Pair(10244, 10247)));
+ EXPECT_THAT(m2, testing::UnorderedElementsAre(testing::Pair(9398, 41999)));
}
TEST_F(MapImplTest, CopyAssignMapIterator) {
TestMap message;
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
reflection_tester.SetMapFieldsViaMapReflection(&message);
MapIterator it1 = reflection_tester.MapBegin(&message, "map_int32_int32");
MapIterator it2 = reflection_tester.MapEnd(&message, "map_int32_int32");
@@ -991,9 +982,7 @@
// Map Field Reflection Test ========================================
-static int Func(int i, int j) {
- return i * j;
-}
+static int Func(int i, int j) { return i * j; }
static std::string StrFunc(int i, int j) {
std::string str;
@@ -1070,10 +1059,8 @@
refl->GetRepeatedPtrField<Message>(message, fd_map_int32_double);
const RepeatedPtrField<Message>& mf_string_string =
refl->GetRepeatedPtrField<Message>(message, fd_map_string_string);
- const RepeatedPtrField<Message>&
- mf_int32_foreign_message =
- refl->GetRepeatedPtrField<Message>(
- message, fd_map_int32_foreign_message);
+ const RepeatedPtrField<Message>& mf_int32_foreign_message =
+ refl->GetRepeatedPtrField<Message>(message, fd_map_int32_foreign_message);
// Get mutable RepeatedPtrField objects for all fields of interest.
RepeatedPtrField<Message>* mmf_int32_int32 =
@@ -1083,8 +1070,8 @@
RepeatedPtrField<Message>* mmf_string_string =
refl->MutableRepeatedPtrField<Message>(&message, fd_map_string_string);
RepeatedPtrField<Message>* mmf_int32_foreign_message =
- refl->MutableRepeatedPtrField<Message>(
- &message, fd_map_int32_foreign_message);
+ refl->MutableRepeatedPtrField<Message>(&message,
+ fd_map_int32_foreign_message);
// Make sure we can do gets through the RepeatedPtrField objects.
for (int i = 0; i < 10; ++i) {
@@ -1119,9 +1106,8 @@
message_int32_message, fd_map_int32_foreign_message_key);
const ForeignMessage& value_int32_message =
down_cast<const ForeignMessage&>(
- message_int32_message.GetReflection()
- ->GetMessage(message_int32_message,
- fd_map_int32_foreign_message_value));
+ message_int32_message.GetReflection()->GetMessage(
+ message_int32_message, fd_map_int32_foreign_message_value));
EXPECT_EQ(value_int32_message.c(), Func(key_int32_message, 6));
}
@@ -1156,9 +1142,8 @@
message_int32_message, fd_map_int32_foreign_message_key);
const ForeignMessage& value_int32_message =
down_cast<const ForeignMessage&>(
- message_int32_message.GetReflection()
- ->GetMessage(message_int32_message,
- fd_map_int32_foreign_message_value));
+ message_int32_message.GetReflection()->GetMessage(
+ message_int32_message, fd_map_int32_foreign_message_value));
EXPECT_EQ(value_int32_message.c(), Func(key_int32_message, 6));
}
}
@@ -1193,9 +1178,8 @@
message_int32_message->GetReflection()->GetInt32(
*message_int32_message, fd_map_int32_foreign_message_key);
ForeignMessage* value_int32_message = down_cast<ForeignMessage*>(
- message_int32_message->GetReflection()
- ->MutableMessage(message_int32_message,
- fd_map_int32_foreign_message_value));
+ message_int32_message->GetReflection()->MutableMessage(
+ message_int32_message, fd_map_int32_foreign_message_value));
value_int32_message->set_c(Func(key_int32_message, -6));
}
}
@@ -1272,10 +1256,9 @@
refl->GetMutableRepeatedFieldRef<Message>(&message, fd_map_int32_double);
const MutableRepeatedFieldRef<Message> mmf_string_string =
refl->GetMutableRepeatedFieldRef<Message>(&message, fd_map_string_string);
- const MutableRepeatedFieldRef<Message>
- mmf_int32_foreign_message =
- refl->GetMutableRepeatedFieldRef<Message>(
- &message, fd_map_int32_foreign_message);
+ const MutableRepeatedFieldRef<Message> mmf_int32_foreign_message =
+ refl->GetMutableRepeatedFieldRef<Message>(&message,
+ fd_map_int32_foreign_message);
// Get entry default instances
std::unique_ptr<Message> entry_int32_int32(
@@ -1350,9 +1333,8 @@
message_int32_message, fd_map_int32_foreign_message_key);
const ForeignMessage& value_int32_message =
down_cast<const ForeignMessage&>(
- message_int32_message.GetReflection()
- ->GetMessage(message_int32_message,
- fd_map_int32_foreign_message_value));
+ message_int32_message.GetReflection()->GetMessage(
+ message_int32_message, fd_map_int32_foreign_message_value));
EXPECT_EQ(value_int32_message.c(), Func(key_int32_message, 6));
}
@@ -1391,9 +1373,8 @@
message_int32_message, fd_map_int32_foreign_message_key);
const ForeignMessage& value_int32_message =
down_cast<const ForeignMessage&>(
- message_int32_message.GetReflection()
- ->GetMessage(message_int32_message,
- fd_map_int32_foreign_message_value));
+ message_int32_message.GetReflection()->GetMessage(
+ message_int32_message, fd_map_int32_foreign_message_value));
EXPECT_EQ(value_int32_message.c(), Func(key_int32_message, 6));
}
}
@@ -1518,9 +1499,9 @@
const Message& message = *it;
int32 key = message.GetReflection()->GetInt32(
message, fd_map_int32_foreign_message_key);
- const ForeignMessage& sub_message = down_cast<const ForeignMessage&>(
- message.GetReflection()
- ->GetMessage(message, fd_map_int32_foreign_message_value));
+ const ForeignMessage& sub_message =
+ down_cast<const ForeignMessage&>(message.GetReflection()->GetMessage(
+ message, fd_map_int32_foreign_message_value));
result[key].MergeFrom(sub_message);
++index;
}
@@ -1552,8 +1533,8 @@
EXPECT_EQ(1234.0, message.map_int32_double().at(4321));
entry_string_string->GetReflection()->SetString(
- entry_string_string.get(),
- fd_map_string_string->message_type()->field(0), "4321");
+ entry_string_string.get(), fd_map_string_string->message_type()->field(0),
+ "4321");
entry_string_string->GetReflection()->SetString(
entry_string_string.get(), fd_map_string_string->message_type()->field(1),
"1234");
@@ -1575,12 +1556,13 @@
EXPECT_EQ(1234, message.map_int32_foreign_message().at(4321).c());
// Test Reflection::AddAllocatedMessage
- Message* free_entry_string_string = MessageFactory::generated_factory()
- ->GetPrototype(fd_map_string_string->message_type())
- ->New();
+ Message* free_entry_string_string =
+ MessageFactory::generated_factory()
+ ->GetPrototype(fd_map_string_string->message_type())
+ ->New();
entry_string_string->GetReflection()->SetString(
- free_entry_string_string,
- fd_map_string_string->message_type()->field(0), "4321");
+ free_entry_string_string, fd_map_string_string->message_type()->field(0),
+ "4321");
entry_string_string->GetReflection()->SetString(
free_entry_string_string, fd_map_string_string->message_type()->field(1),
"1234");
@@ -1672,30 +1654,30 @@
{
const Message& message0a =
mmf_int32_foreign_message.Get(0, entry_int32_foreign_message.get());
- const ForeignMessage& sub_message0a = down_cast<const ForeignMessage&>(
- message0a.GetReflection()
- ->GetMessage(message0a, fd_map_int32_foreign_message_value));
+ const ForeignMessage& sub_message0a =
+ down_cast<const ForeignMessage&>(message0a.GetReflection()->GetMessage(
+ message0a, fd_map_int32_foreign_message_value));
int32 int32_value0a = sub_message0a.c();
const Message& message9a =
mmf_int32_foreign_message.Get(9, entry_int32_foreign_message.get());
- const ForeignMessage& sub_message9a = down_cast<const ForeignMessage&>(
- message9a.GetReflection()
- ->GetMessage(message9a, fd_map_int32_foreign_message_value));
+ const ForeignMessage& sub_message9a =
+ down_cast<const ForeignMessage&>(message9a.GetReflection()->GetMessage(
+ message9a, fd_map_int32_foreign_message_value));
int32 int32_value9a = sub_message9a.c();
mmf_int32_foreign_message.SwapElements(0, 9);
const Message& message0b =
mmf_int32_foreign_message.Get(0, entry_int32_foreign_message.get());
- const ForeignMessage& sub_message0b = down_cast<const ForeignMessage&>(
- message0b.GetReflection()
- ->GetMessage(message0b, fd_map_int32_foreign_message_value));
+ const ForeignMessage& sub_message0b =
+ down_cast<const ForeignMessage&>(message0b.GetReflection()->GetMessage(
+ message0b, fd_map_int32_foreign_message_value));
int32 int32_value0b = sub_message0b.c();
const Message& message9b =
mmf_int32_foreign_message.Get(9, entry_int32_foreign_message.get());
- const ForeignMessage& sub_message9b = down_cast<const ForeignMessage&>(
- message9b.GetReflection()
- ->GetMessage(message9b, fd_map_int32_foreign_message_value));
+ const ForeignMessage& sub_message9b =
+ down_cast<const ForeignMessage&>(message9b.GetReflection()->GetMessage(
+ message9b, fd_map_int32_foreign_message_value));
int32 int32_value9b = sub_message9b.c();
EXPECT_EQ(int32_value9a, int32_value0b);
@@ -1734,34 +1716,26 @@
const FieldDescriptor* fd_map_int32_foreign_message =
desc->FindFieldByName("map_int32_foreign_message");
- // Get MutableRepeatedFieldRef objects for all fields of interest.
+ // Get MutableRepeatedFieldRef objects for all fields of interest.
const MutableRepeatedFieldRef<Message> mmf_int32_int32 =
- refl->GetMutableRepeatedFieldRef<Message>(
- &m0, fd_map_int32_int32);
+ refl->GetMutableRepeatedFieldRef<Message>(&m0, fd_map_int32_int32);
const MutableRepeatedFieldRef<Message> mmf_int32_double =
- refl->GetMutableRepeatedFieldRef<Message>(
- &m0, fd_map_int32_double);
+ refl->GetMutableRepeatedFieldRef<Message>(&m0, fd_map_int32_double);
const MutableRepeatedFieldRef<Message> mmf_string_string =
- refl->GetMutableRepeatedFieldRef<Message>(
- &m0, fd_map_string_string);
- const MutableRepeatedFieldRef<Message>
- mmf_int32_foreign_message =
- refl->GetMutableRepeatedFieldRef<Message>(
- &m0, fd_map_int32_foreign_message);
+ refl->GetMutableRepeatedFieldRef<Message>(&m0, fd_map_string_string);
+ const MutableRepeatedFieldRef<Message> mmf_int32_foreign_message =
+ refl->GetMutableRepeatedFieldRef<Message>(&m0,
+ fd_map_int32_foreign_message);
// Test MutableRepeatedRef::CopyFrom
mmf_int32_int32.CopyFrom(
- refl->GetRepeatedFieldRef<Message>(
- m1, fd_map_int32_int32));
+ refl->GetRepeatedFieldRef<Message>(m1, fd_map_int32_int32));
mmf_int32_double.CopyFrom(
- refl->GetRepeatedFieldRef<Message>(
- m1, fd_map_int32_double));
+ refl->GetRepeatedFieldRef<Message>(m1, fd_map_int32_double));
mmf_string_string.CopyFrom(
- refl->GetRepeatedFieldRef<Message>(
- m1, fd_map_string_string));
+ refl->GetRepeatedFieldRef<Message>(m1, fd_map_string_string));
mmf_int32_foreign_message.CopyFrom(
- refl->GetRepeatedFieldRef<Message>(
- m1, fd_map_int32_foreign_message));
+ refl->GetRepeatedFieldRef<Message>(m1, fd_map_int32_foreign_message));
for (int i = 0; i < 10; ++i) {
EXPECT_EQ(Func(i, 11), m0.map_int32_int32().at(i + 10));
@@ -1772,17 +1746,13 @@
// Test MutableRepeatedRef::MergeFrom
mmf_int32_int32.MergeFrom(
- refl->GetRepeatedFieldRef<Message>(
- m2, fd_map_int32_int32));
+ refl->GetRepeatedFieldRef<Message>(m2, fd_map_int32_int32));
mmf_int32_double.MergeFrom(
- refl->GetRepeatedFieldRef<Message>(
- m2, fd_map_int32_double));
+ refl->GetRepeatedFieldRef<Message>(m2, fd_map_int32_double));
mmf_string_string.MergeFrom(
- refl->GetRepeatedFieldRef<Message>(
- m2, fd_map_string_string));
+ refl->GetRepeatedFieldRef<Message>(m2, fd_map_string_string));
mmf_int32_foreign_message.MergeFrom(
- refl->GetRepeatedFieldRef<Message>(
- m2, fd_map_int32_foreign_message));
+ refl->GetRepeatedFieldRef<Message>(m2, fd_map_int32_foreign_message));
for (int i = 0; i < 10; ++i) {
EXPECT_EQ(Func(i, 21), m0.map_int32_int32().at(i + 20));
EXPECT_EQ(Func(i, 22), m0.map_int32_double().at(i + 20));
@@ -1793,17 +1763,13 @@
// Test MutableRepeatedRef::Swap
// Swap between m0 and m2.
mmf_int32_int32.Swap(
- refl->GetMutableRepeatedFieldRef<Message>(
- &m2, fd_map_int32_int32));
+ refl->GetMutableRepeatedFieldRef<Message>(&m2, fd_map_int32_int32));
mmf_int32_double.Swap(
- refl->GetMutableRepeatedFieldRef<Message>(
- &m2, fd_map_int32_double));
+ refl->GetMutableRepeatedFieldRef<Message>(&m2, fd_map_int32_double));
mmf_string_string.Swap(
- refl->GetMutableRepeatedFieldRef<Message>(
- &m2, fd_map_string_string));
- mmf_int32_foreign_message.Swap(
- refl->GetMutableRepeatedFieldRef<Message>(
- &m2, fd_map_int32_foreign_message));
+ refl->GetMutableRepeatedFieldRef<Message>(&m2, fd_map_string_string));
+ mmf_int32_foreign_message.Swap(refl->GetMutableRepeatedFieldRef<Message>(
+ &m2, fd_map_int32_foreign_message));
for (int i = 0; i < 10; ++i) {
// Check the content of m0.
EXPECT_EQ(Func(i, 21), m0.map_int32_int32().at(i + 20));
@@ -2015,10 +1981,8 @@
// Construct a new version of the dynamic message via the factory.
DynamicMessageFactory factory;
std::unique_ptr<Message> message1;
- message1.reset(
- factory.GetPrototype(unittest::TestMap::descriptor())->New());
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ message1.reset(factory.GetPrototype(unittest::TestMap::descriptor())->New());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
reflection_tester.SetMapFieldsViaReflection(message1.get());
reflection_tester.ExpectMapFieldsSetViaReflection(*message1);
reflection_tester.ExpectMapFieldsSetViaReflectionIterator(message1.get());
@@ -2032,10 +1996,8 @@
// Construct a new version of the dynamic message via the factory.
DynamicMessageFactory factory;
std::unique_ptr<Message> message1;
- message1.reset(
- factory.GetPrototype(unittest::TestMap::descriptor())->New());
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ message1.reset(factory.GetPrototype(unittest::TestMap::descriptor())->New());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
reflection_tester.SetMapFieldsViaMapReflection(message1.get());
reflection_tester.ExpectMapFieldsSetViaReflection(*message1);
reflection_tester.ExpectMapFieldsSetViaReflectionIterator(message1.get());
@@ -2047,23 +2009,19 @@
// Construct two dynamic message and sets via map reflection.
DynamicMessageFactory factory;
std::unique_ptr<Message> message1;
- message1.reset(
- factory.GetPrototype(unittest::TestMap::descriptor())->New());
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ message1.reset(factory.GetPrototype(unittest::TestMap::descriptor())->New());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
reflection_tester.SetMapFieldsViaMapReflection(message1.get());
// message2 is created by same factory.
std::unique_ptr<Message> message2;
- message2.reset(
- factory.GetPrototype(unittest::TestMap::descriptor())->New());
+ message2.reset(factory.GetPrototype(unittest::TestMap::descriptor())->New());
reflection_tester.SetMapFieldsViaMapReflection(message2.get());
// message3 is created by different factory.
DynamicMessageFactory factory3;
std::unique_ptr<Message> message3;
- message3.reset(
- factory3.GetPrototype(unittest::TestMap::descriptor())->New());
+ message3.reset(factory3.GetPrototype(unittest::TestMap::descriptor())->New());
reflection_tester.SetMapFieldsViaMapReflection(message3.get());
message2->MergeFrom(*message1);
@@ -2087,27 +2045,23 @@
// Construct a new version of the dynamic message via the factory.
DynamicMessageFactory factory;
std::unique_ptr<Message> message1;
- message1.reset(
- factory.GetPrototype(unittest::TestMap::descriptor())->New());
+ message1.reset(factory.GetPrototype(unittest::TestMap::descriptor())->New());
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
message1->MergeFrom(message2);
reflection_tester.ExpectMapFieldsSetViaReflection(*message1);
reflection_tester.ExpectMapFieldsSetViaReflectionIterator(message1.get());
}
TEST(GeneratedMapFieldTest, DynamicMessageCopyFromMapReflection) {
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
unittest::TestMap message2;
reflection_tester.SetMapFieldsViaMapReflection(&message2);
// Construct a dynamic message via the factory.
DynamicMessageFactory factory;
std::unique_ptr<Message> message1;
- message1.reset(
- factory.GetPrototype(unittest::TestMap::descriptor())->New());
+ message1.reset(factory.GetPrototype(unittest::TestMap::descriptor())->New());
message1->MergeFrom(message2);
reflection_tester.ExpectMapFieldsSetViaReflectionIterator(message1.get());
@@ -2116,12 +2070,10 @@
TEST(GeneratedMapFieldTest, SyncDynamicMapWithRepeatedField) {
// Construct a dynamic message via the factory.
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
DynamicMessageFactory factory;
std::unique_ptr<Message> message;
- message.reset(
- factory.GetPrototype(unittest::TestMap::descriptor())->New());
+ message.reset(factory.GetPrototype(unittest::TestMap::descriptor())->New());
reflection_tester.SetMapFieldsViaReflection(message.get());
reflection_tester.ExpectMapFieldsSetViaReflectionIterator(message.get());
reflection_tester.ExpectMapFieldsSetViaReflection(*message);
@@ -2336,8 +2288,8 @@
for (int k = i, j = 0; j < items; j++, k >>= kBitsOfIPerItem) {
bool is_key = k & 0x1;
bool is_value = !is_key && (k & 0x2);
- wire_format.push_back(is_key ? kKeyTag :
- is_value ? kValueTag : kJunkTag);
+ wire_format.push_back(is_key ? kKeyTag
+ : is_value ? kValueTag : kJunkTag);
char c = static_cast<char>(k & mask) >> 2; // One char after the tag.
wire_format.push_back(c);
if (is_key) expected_key = static_cast<int>(c);
@@ -2499,10 +2451,10 @@
EXPECT_EQ(99, map_message.map_field().find(key)->second.dummy5());
// Test key then value then value then key.
- s.push_back(s[2]); // Copy the key's tag.
+ s.push_back(s[2]); // Copy the key's tag.
key = 19;
- s.push_back(key); // Second key is 19 instead of 0.
- s[1] += 2; // Adjust encoded size.
+ s.push_back(key); // Second key is 19 instead of 0.
+ s[1] += 2; // Adjust encoded size.
ASSERT_TRUE(map_message.ParseFromString(s));
ASSERT_EQ(1, map_message.map_field().size());
ASSERT_EQ(1, map_message.map_field().count(key));
@@ -2517,8 +2469,7 @@
TEST(GeneratedMapFieldReflectionTest, SpaceUsed) {
unittest::TestMap message;
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
reflection_tester.SetMapFieldsViaReflection(&message);
EXPECT_LT(0, message.GetReflection()->SpaceUsed(message));
@@ -2528,8 +2479,7 @@
// Set every field to a unique value then go back and check all those
// values.
unittest::TestMap message;
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
reflection_tester.SetMapFieldsViaReflection(&message);
MapTestUtil::ExpectMapFieldsSet(message);
reflection_tester.ExpectMapFieldsSetViaReflection(message);
@@ -2587,8 +2537,7 @@
MapTestUtil::SetMapFields(&message);
MapTestUtil::ExpectMapFieldsSet(message);
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
reflection_tester.ClearMapFieldsViaReflection(&message);
reflection_tester.ExpectClearViaReflection(message);
reflection_tester.ExpectClearViaReflectionIterator(&message);
@@ -2596,8 +2545,7 @@
TEST(GeneratedMapFieldReflectionTest, RemoveLast) {
unittest::TestMap message;
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
MapTestUtil::SetMapFields(&message);
MapTestUtil::ExpectMapsSize(message, 2);
@@ -2644,8 +2592,7 @@
TEST(GeneratedMapFieldReflectionTest, SwapElements) {
unittest::TestMap message;
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
MapTestUtil::SetMapFields(&message);
@@ -2684,8 +2631,7 @@
TEST(GeneratedMapFieldReflectionTest, MutableUnknownFields) {
unittest::TestMap message;
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
reflection_tester.MutableUnknownFieldsOfMapFieldsViaReflection(&message);
}
@@ -2740,8 +2686,7 @@
TEST(GeneratedMapFieldReflectionTest, MapEntryClear) {
unittest::TestMap message;
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
reflection_tester.MutableUnknownFieldsOfMapFieldsViaReflection(&message);
}
@@ -2762,8 +2707,7 @@
TEST(GeneratedMapFieldReflectionTest, SetViaMapReflection) {
unittest::TestMap message;
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
reflection_tester.SetMapFieldsViaMapReflection(&message);
reflection_tester.ExpectMapFieldsSetViaReflection(message);
reflection_tester.ExpectMapFieldsSetViaReflectionIterator(&message);
@@ -2783,8 +2727,7 @@
: pool_(DescriptorPool::generated_pool()), factory_(pool_) {}
virtual void SetUp() {
- map_descriptor_ =
- pool_->FindMessageTypeByName("protobuf_unittest.TestMap");
+ map_descriptor_ = pool_->FindMessageTypeByName("protobuf_unittest.TestMap");
recursive_map_descriptor_ =
pool_->FindMessageTypeByName("protobuf_unittest.TestRecursiveMapMessage");
ASSERT_TRUE(map_descriptor_ != NULL);
@@ -2952,15 +2895,15 @@
MapTestUtil::SetMapFields(&message);
// Set some unknown fields in message.
- message.GetReflection()->MutableUnknownFields(&message)->
- AddVarint(123456, 654321);
+ message.GetReflection()->MutableUnknownFields(&message)->AddVarint(123456,
+ 654321);
// Discard them.
ReflectionOps::DiscardUnknownFields(&message);
MapTestUtil::ExpectMapFieldsSet(message);
- EXPECT_EQ(0, message.GetReflection()->
- GetUnknownFields(message).field_count());
+ EXPECT_EQ(0,
+ message.GetReflection()->GetUnknownFields(message).field_count());
}
TEST(ReflectionOpsForMapFieldTest, IsInitialized) {
@@ -3042,8 +2985,7 @@
std::unique_ptr<Message> dynamic_message;
dynamic_message.reset(
factory.GetPrototype(unittest::TestMap::descriptor())->New());
- MapReflectionTester reflection_tester(
- unittest::TestMap::descriptor());
+ MapReflectionTester reflection_tester(unittest::TestMap::descriptor());
reflection_tester.SetMapFieldsViaReflection(dynamic_message.get());
reflection_tester.ExpectMapFieldsSetViaReflection(*dynamic_message);
@@ -3106,7 +3048,7 @@
io::ArrayInputStream stream(data.data(), data.size());
protobuf_unittest::TestAllTypes message;
EXPECT_FALSE(
- message.ParseFromBoundedZeroCopyStream(&stream, data.size() + 1));
+ message.ParseFromBoundedZeroCopyStream(&stream, data.size() + 1));
}
}
@@ -3263,10 +3205,10 @@
tester.SetMapFieldsViaReflection(message.get());
std::string expected_text;
- GOOGLE_CHECK_OK(File::GetContents(
- TestUtil::GetTestDataPath("net/proto2/internal/"
- "testdata/map_test_data.txt"),
- &expected_text, true));
+ GOOGLE_CHECK_OK(
+ File::GetContents(TestUtil::GetTestDataPath("net/proto2/internal/"
+ "testdata/map_test_data.txt"),
+ &expected_text, true));
EXPECT_EQ(message->DebugString(), expected_text);
}
@@ -3312,8 +3254,7 @@
(*source.mutable_map_int32_int32())[1] = 1;
// Get iterator.
- Map<int32, int32>::iterator iter =
- source.mutable_map_int32_int32()->find(1);
+ Map<int32, int32>::iterator iter = source.mutable_map_int32_int32()->find(1);
// Serialize message to text format, which will invalidate the previous
// iterator previously.
diff --git a/src/google/protobuf/map_test_util.cc b/src/google/protobuf/map_test_util.cc
index 83502af..51c7366 100644
--- a/src/google/protobuf/map_test_util.cc
+++ b/src/google/protobuf/map_test_util.cc
@@ -78,49 +78,59 @@
message);
}
-void MapTestUtil::ExpectMapFieldsModified(
- const unittest::TestMap& message) {
+void MapTestUtil::ExpectMapFieldsModified(const unittest::TestMap& message) {
MapTestUtilImpl::ExpectMapFieldsModified<
unittest::MapEnum, unittest::MAP_ENUM_BAR, unittest::MAP_ENUM_FOO>(
message);
}
-void MapTestUtil::ExpectMapsSize(
- const unittest::TestMap& message, int size) {
+void MapTestUtil::ExpectMapsSize(const unittest::TestMap& message, int size) {
const Descriptor* descriptor = message.GetDescriptor();
EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_int32_int32")));
+ message, descriptor->FindFieldByName("map_int32_int32")));
EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_int64_int64")));
+ message, descriptor->FindFieldByName("map_int64_int64")));
+ EXPECT_EQ(size,
+ message.GetReflection()->FieldSize(
+ message, descriptor->FindFieldByName("map_uint32_uint32")));
+ EXPECT_EQ(size,
+ message.GetReflection()->FieldSize(
+ message, descriptor->FindFieldByName("map_uint64_uint64")));
+ EXPECT_EQ(size,
+ message.GetReflection()->FieldSize(
+ message, descriptor->FindFieldByName("map_sint32_sint32")));
+ EXPECT_EQ(size,
+ message.GetReflection()->FieldSize(
+ message, descriptor->FindFieldByName("map_sint64_sint64")));
+ EXPECT_EQ(size,
+ message.GetReflection()->FieldSize(
+ message, descriptor->FindFieldByName("map_fixed32_fixed32")));
+ EXPECT_EQ(size,
+ message.GetReflection()->FieldSize(
+ message, descriptor->FindFieldByName("map_fixed64_fixed64")));
+ EXPECT_EQ(size,
+ message.GetReflection()->FieldSize(
+ message, descriptor->FindFieldByName("map_sfixed32_sfixed32")));
+ EXPECT_EQ(size,
+ message.GetReflection()->FieldSize(
+ message, descriptor->FindFieldByName("map_sfixed64_sfixed64")));
EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_uint32_uint32")));
+ message, descriptor->FindFieldByName("map_int32_float")));
+ EXPECT_EQ(size,
+ message.GetReflection()->FieldSize(
+ message, descriptor->FindFieldByName("map_int32_double")));
EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_uint64_uint64")));
+ message, descriptor->FindFieldByName("map_bool_bool")));
+ EXPECT_EQ(size,
+ message.GetReflection()->FieldSize(
+ message, descriptor->FindFieldByName("map_string_string")));
EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_sint32_sint32")));
- EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_sint64_sint64")));
- EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_fixed32_fixed32")));
- EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_fixed64_fixed64")));
- EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_sfixed32_sfixed32")));
- EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_sfixed64_sfixed64")));
- EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_int32_float")));
- EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_int32_double")));
- EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_bool_bool")));
- EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_string_string")));
- EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_int32_bytes")));
- EXPECT_EQ(size, message.GetReflection()->FieldSize(
- message, descriptor->FindFieldByName("map_int32_foreign_message")));
+ message, descriptor->FindFieldByName("map_int32_bytes")));
+ EXPECT_EQ(
+ size,
+ message.GetReflection()->FieldSize(
+ message, descriptor->FindFieldByName("map_int32_foreign_message")));
}
std::vector<const Message*> MapTestUtil::GetMapEntries(
@@ -129,39 +139,40 @@
std::vector<const Message*> result;
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_int32_int32"), index));
+ message, descriptor->FindFieldByName("map_int32_int32"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_int64_int64"), index));
+ message, descriptor->FindFieldByName("map_int64_int64"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_uint32_uint32"), index));
+ message, descriptor->FindFieldByName("map_uint32_uint32"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_uint64_uint64"), index));
+ message, descriptor->FindFieldByName("map_uint64_uint64"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_sint32_sint32"), index));
+ message, descriptor->FindFieldByName("map_sint32_sint32"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_sint64_sint64"), index));
+ message, descriptor->FindFieldByName("map_sint64_sint64"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_fixed32_fixed32"), index));
+ message, descriptor->FindFieldByName("map_fixed32_fixed32"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_fixed64_fixed64"), index));
+ message, descriptor->FindFieldByName("map_fixed64_fixed64"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_sfixed32_sfixed32"), index));
+ message, descriptor->FindFieldByName("map_sfixed32_sfixed32"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_sfixed64_sfixed64"), index));
+ message, descriptor->FindFieldByName("map_sfixed64_sfixed64"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_int32_float"), index));
+ message, descriptor->FindFieldByName("map_int32_float"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_int32_double"), index));
+ message, descriptor->FindFieldByName("map_int32_double"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_bool_bool"), index));
+ message, descriptor->FindFieldByName("map_bool_bool"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_string_string"), index));
+ message, descriptor->FindFieldByName("map_string_string"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_int32_bytes"), index));
+ message, descriptor->FindFieldByName("map_int32_bytes"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_int32_enum"), index));
+ message, descriptor->FindFieldByName("map_int32_enum"), index));
result.push_back(&message.GetReflection()->GetRepeatedMessage(
- message, descriptor->FindFieldByName("map_int32_foreign_message"), index));
+ message, descriptor->FindFieldByName("map_int32_foreign_message"),
+ index));
return result;
}
@@ -172,76 +183,74 @@
std::vector<const Message*> result;
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_int32_int32")));
+ message, descriptor->FindFieldByName("map_int32_int32")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_int64_int64")));
+ message, descriptor->FindFieldByName("map_int64_int64")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_uint32_uint32")));
+ message, descriptor->FindFieldByName("map_uint32_uint32")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_uint64_uint64")));
+ message, descriptor->FindFieldByName("map_uint64_uint64")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_sint32_sint32")));
+ message, descriptor->FindFieldByName("map_sint32_sint32")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_sint64_sint64")));
+ message, descriptor->FindFieldByName("map_sint64_sint64")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_fixed32_fixed32")));
+ message, descriptor->FindFieldByName("map_fixed32_fixed32")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_fixed64_fixed64")));
+ message, descriptor->FindFieldByName("map_fixed64_fixed64")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_sfixed32_sfixed32")));
+ message, descriptor->FindFieldByName("map_sfixed32_sfixed32")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_sfixed64_sfixed64")));
+ message, descriptor->FindFieldByName("map_sfixed64_sfixed64")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_int32_float")));
+ message, descriptor->FindFieldByName("map_int32_float")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_int32_double")));
+ message, descriptor->FindFieldByName("map_int32_double")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_bool_bool")));
+ message, descriptor->FindFieldByName("map_bool_bool")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_string_string")));
+ message, descriptor->FindFieldByName("map_string_string")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_int32_bytes")));
+ message, descriptor->FindFieldByName("map_int32_bytes")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_int32_enum")));
+ message, descriptor->FindFieldByName("map_int32_enum")));
result.push_back(message->GetReflection()->ReleaseLast(
- message, descriptor->FindFieldByName("map_int32_foreign_message")));
+ message, descriptor->FindFieldByName("map_int32_foreign_message")));
return result;
}
-MapReflectionTester::MapReflectionTester(
- const Descriptor* base_descriptor)
- : base_descriptor_(base_descriptor) {
+MapReflectionTester::MapReflectionTester(const Descriptor* base_descriptor)
+ : base_descriptor_(base_descriptor) {
const DescriptorPool* pool = base_descriptor->file()->pool();
map_enum_foo_ = pool->FindEnumValueByName("protobuf_unittest.MAP_ENUM_FOO");
map_enum_bar_ = pool->FindEnumValueByName("protobuf_unittest.MAP_ENUM_BAR");
map_enum_baz_ = pool->FindEnumValueByName("protobuf_unittest.MAP_ENUM_BAZ");
- foreign_c_ = pool->FindFieldByName(
- "protobuf_unittest.ForeignMessage.c");
- map_int32_int32_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapInt32Int32Entry.key");
- map_int32_int32_val_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapInt32Int32Entry.value");
- map_int64_int64_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapInt64Int64Entry.key");
- map_int64_int64_val_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapInt64Int64Entry.value");
- map_uint32_uint32_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapUint32Uint32Entry.key");
+ foreign_c_ = pool->FindFieldByName("protobuf_unittest.ForeignMessage.c");
+ map_int32_int32_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapInt32Int32Entry.key");
+ map_int32_int32_val_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapInt32Int32Entry.value");
+ map_int64_int64_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapInt64Int64Entry.key");
+ map_int64_int64_val_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapInt64Int64Entry.value");
+ map_uint32_uint32_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapUint32Uint32Entry.key");
map_uint32_uint32_val_ = pool->FindFieldByName(
"protobuf_unittest.TestMap.MapUint32Uint32Entry.value");
- map_uint64_uint64_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapUint64Uint64Entry.key");
+ map_uint64_uint64_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapUint64Uint64Entry.key");
map_uint64_uint64_val_ = pool->FindFieldByName(
"protobuf_unittest.TestMap.MapUint64Uint64Entry.value");
- map_sint32_sint32_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapSint32Sint32Entry.key");
+ map_sint32_sint32_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapSint32Sint32Entry.key");
map_sint32_sint32_val_ = pool->FindFieldByName(
"protobuf_unittest.TestMap.MapSint32Sint32Entry.value");
- map_sint64_sint64_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapSint64Sint64Entry.key");
+ map_sint64_sint64_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapSint64Sint64Entry.key");
map_sint64_sint64_val_ = pool->FindFieldByName(
"protobuf_unittest.TestMap.MapSint64Sint64Entry.value");
map_fixed32_fixed32_key_ = pool->FindFieldByName(
@@ -260,30 +269,30 @@
"protobuf_unittest.TestMap.MapSfixed64Sfixed64Entry.key");
map_sfixed64_sfixed64_val_ = pool->FindFieldByName(
"protobuf_unittest.TestMap.MapSfixed64Sfixed64Entry.value");
- map_int32_float_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapInt32FloatEntry.key");
- map_int32_float_val_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapInt32FloatEntry.value");
- map_int32_double_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapInt32DoubleEntry.key");
+ map_int32_float_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapInt32FloatEntry.key");
+ map_int32_float_val_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapInt32FloatEntry.value");
+ map_int32_double_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapInt32DoubleEntry.key");
map_int32_double_val_ = pool->FindFieldByName(
"protobuf_unittest.TestMap.MapInt32DoubleEntry.value");
- map_bool_bool_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapBoolBoolEntry.key");
- map_bool_bool_val_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapBoolBoolEntry.value");
- map_string_string_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapStringStringEntry.key");
+ map_bool_bool_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapBoolBoolEntry.key");
+ map_bool_bool_val_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapBoolBoolEntry.value");
+ map_string_string_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapStringStringEntry.key");
map_string_string_val_ = pool->FindFieldByName(
"protobuf_unittest.TestMap.MapStringStringEntry.value");
- map_int32_bytes_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapInt32BytesEntry.key");
- map_int32_bytes_val_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapInt32BytesEntry.value");
- map_int32_enum_key_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapInt32EnumEntry.key");
- map_int32_enum_val_ = pool->FindFieldByName(
- "protobuf_unittest.TestMap.MapInt32EnumEntry.value");
+ map_int32_bytes_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapInt32BytesEntry.key");
+ map_int32_bytes_val_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapInt32BytesEntry.value");
+ map_int32_enum_key_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapInt32EnumEntry.key");
+ map_int32_enum_val_ =
+ pool->FindFieldByName("protobuf_unittest.TestMap.MapInt32EnumEntry.value");
map_int32_foreign_message_key_ = pool->FindFieldByName(
"protobuf_unittest.TestMap.MapInt32ForeignMessageEntry.key");
map_int32_foreign_message_val_ = pool->FindFieldByName(
@@ -336,227 +345,203 @@
return result;
}
-void MapReflectionTester::SetMapFieldsViaReflection(
- Message* message) {
+void MapReflectionTester::SetMapFieldsViaReflection(Message* message) {
const Reflection* reflection = message->GetReflection();
Message* sub_message = NULL;
Message* sub_foreign_message = NULL;
// Add first element.
sub_message = reflection->AddMessage(message, F("map_int32_int32"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_int32_key_, 0);
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_int32_val_, 0);
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_int32_key_, 0);
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_int32_val_, 0);
sub_message = reflection->AddMessage(message, F("map_int64_int64"));
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_int64_int64_key_, 0);
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_int64_int64_val_, 0);
+ sub_message->GetReflection()->SetInt64(sub_message, map_int64_int64_key_, 0);
+ sub_message->GetReflection()->SetInt64(sub_message, map_int64_int64_val_, 0);
sub_message = reflection->AddMessage(message, F("map_uint32_uint32"));
- sub_message->GetReflection()
- ->SetUInt32(sub_message, map_uint32_uint32_key_, 0);
- sub_message->GetReflection()
- ->SetUInt32(sub_message, map_uint32_uint32_val_, 0);
+ sub_message->GetReflection()->SetUInt32(sub_message, map_uint32_uint32_key_,
+ 0);
+ sub_message->GetReflection()->SetUInt32(sub_message, map_uint32_uint32_val_,
+ 0);
sub_message = reflection->AddMessage(message, F("map_uint64_uint64"));
- sub_message->GetReflection()
- ->SetUInt64(sub_message, map_uint64_uint64_key_, 0);
- sub_message->GetReflection()
- ->SetUInt64(sub_message, map_uint64_uint64_val_, 0);
+ sub_message->GetReflection()->SetUInt64(sub_message, map_uint64_uint64_key_,
+ 0);
+ sub_message->GetReflection()->SetUInt64(sub_message, map_uint64_uint64_val_,
+ 0);
sub_message = reflection->AddMessage(message, F("map_sint32_sint32"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_sint32_sint32_key_, 0);
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_sint32_sint32_val_, 0);
+ sub_message->GetReflection()->SetInt32(sub_message, map_sint32_sint32_key_,
+ 0);
+ sub_message->GetReflection()->SetInt32(sub_message, map_sint32_sint32_val_,
+ 0);
sub_message = reflection->AddMessage(message, F("map_sint64_sint64"));
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_sint64_sint64_key_, 0);
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_sint64_sint64_val_, 0);
+ sub_message->GetReflection()->SetInt64(sub_message, map_sint64_sint64_key_,
+ 0);
+ sub_message->GetReflection()->SetInt64(sub_message, map_sint64_sint64_val_,
+ 0);
sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32"));
- sub_message->GetReflection()
- ->SetUInt32(sub_message, map_fixed32_fixed32_key_, 0);
- sub_message->GetReflection()
- ->SetUInt32(sub_message, map_fixed32_fixed32_val_, 0);
+ sub_message->GetReflection()->SetUInt32(sub_message, map_fixed32_fixed32_key_,
+ 0);
+ sub_message->GetReflection()->SetUInt32(sub_message, map_fixed32_fixed32_val_,
+ 0);
sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64"));
- sub_message->GetReflection()
- ->SetUInt64(sub_message, map_fixed64_fixed64_key_, 0);
- sub_message->GetReflection()
- ->SetUInt64(sub_message, map_fixed64_fixed64_val_, 0);
+ sub_message->GetReflection()->SetUInt64(sub_message, map_fixed64_fixed64_key_,
+ 0);
+ sub_message->GetReflection()->SetUInt64(sub_message, map_fixed64_fixed64_val_,
+ 0);
sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_sfixed32_sfixed32_key_, 0);
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_sfixed32_sfixed32_val_, 0);
+ sub_message->GetReflection()->SetInt32(sub_message,
+ map_sfixed32_sfixed32_key_, 0);
+ sub_message->GetReflection()->SetInt32(sub_message,
+ map_sfixed32_sfixed32_val_, 0);
sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64"));
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_sfixed64_sfixed64_key_, 0);
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_sfixed64_sfixed64_val_, 0);
+ sub_message->GetReflection()->SetInt64(sub_message,
+ map_sfixed64_sfixed64_key_, 0);
+ sub_message->GetReflection()->SetInt64(sub_message,
+ map_sfixed64_sfixed64_val_, 0);
sub_message = reflection->AddMessage(message, F("map_int32_float"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_float_key_, 0);
- sub_message->GetReflection()
- ->SetFloat(sub_message, map_int32_float_val_, 0.0);
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_float_key_, 0);
+ sub_message->GetReflection()->SetFloat(sub_message, map_int32_float_val_,
+ 0.0);
sub_message = reflection->AddMessage(message, F("map_int32_double"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_double_key_, 0);
- sub_message->GetReflection()
- ->SetDouble(sub_message, map_int32_double_val_, 0.0);
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_double_key_, 0);
+ sub_message->GetReflection()->SetDouble(sub_message, map_int32_double_val_,
+ 0.0);
sub_message = reflection->AddMessage(message, F("map_bool_bool"));
- sub_message->GetReflection()
- ->SetBool(sub_message, map_bool_bool_key_, false);
- sub_message->GetReflection()
- ->SetBool(sub_message, map_bool_bool_val_, false);
+ sub_message->GetReflection()->SetBool(sub_message, map_bool_bool_key_, false);
+ sub_message->GetReflection()->SetBool(sub_message, map_bool_bool_val_, false);
sub_message = reflection->AddMessage(message, F("map_string_string"));
- sub_message->GetReflection()
- ->SetString(sub_message, map_string_string_key_, "0");
- sub_message->GetReflection()
- ->SetString(sub_message, map_string_string_val_, "0");
+ sub_message->GetReflection()->SetString(sub_message, map_string_string_key_,
+ "0");
+ sub_message->GetReflection()->SetString(sub_message, map_string_string_val_,
+ "0");
sub_message = reflection->AddMessage(message, F("map_int32_bytes"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_bytes_key_, 0);
- sub_message->GetReflection()
- ->SetString(sub_message, map_int32_bytes_val_, "0");
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_bytes_key_, 0);
+ sub_message->GetReflection()->SetString(sub_message, map_int32_bytes_val_,
+ "0");
sub_message = reflection->AddMessage(message, F("map_int32_enum"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_enum_key_, 0);
- sub_message->GetReflection()
- ->SetEnum(sub_message, map_int32_enum_val_, map_enum_bar_);
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_enum_key_, 0);
+ sub_message->GetReflection()->SetEnum(sub_message, map_int32_enum_val_,
+ map_enum_bar_);
- sub_message = reflection
- ->AddMessage(message, F("map_int32_foreign_message"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_foreign_message_key_, 0);
- sub_foreign_message = sub_message->GetReflection()->
- MutableMessage(sub_message, map_int32_foreign_message_val_, NULL);
- sub_foreign_message->GetReflection()->
- SetInt32(sub_foreign_message, foreign_c_, 0);
+ sub_message = reflection->AddMessage(message, F("map_int32_foreign_message"));
+ sub_message->GetReflection()->SetInt32(sub_message,
+ map_int32_foreign_message_key_, 0);
+ sub_foreign_message = sub_message->GetReflection()->MutableMessage(
+ sub_message, map_int32_foreign_message_val_, NULL);
+ sub_foreign_message->GetReflection()->SetInt32(sub_foreign_message,
+ foreign_c_, 0);
// Add second element
sub_message = reflection->AddMessage(message, F("map_int32_int32"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_int32_key_, 1);
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_int32_val_, 1);
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_int32_key_, 1);
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_int32_val_, 1);
sub_message = reflection->AddMessage(message, F("map_int64_int64"));
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_int64_int64_key_, 1);
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_int64_int64_val_, 1);
+ sub_message->GetReflection()->SetInt64(sub_message, map_int64_int64_key_, 1);
+ sub_message->GetReflection()->SetInt64(sub_message, map_int64_int64_val_, 1);
sub_message = reflection->AddMessage(message, F("map_uint32_uint32"));
- sub_message->GetReflection()
- ->SetUInt32(sub_message, map_uint32_uint32_key_, 1);
- sub_message->GetReflection()
- ->SetUInt32(sub_message, map_uint32_uint32_val_, 1);
+ sub_message->GetReflection()->SetUInt32(sub_message, map_uint32_uint32_key_,
+ 1);
+ sub_message->GetReflection()->SetUInt32(sub_message, map_uint32_uint32_val_,
+ 1);
sub_message = reflection->AddMessage(message, F("map_uint64_uint64"));
- sub_message->GetReflection()
- ->SetUInt64(sub_message, map_uint64_uint64_key_, 1);
- sub_message->GetReflection()
- ->SetUInt64(sub_message, map_uint64_uint64_val_, 1);
+ sub_message->GetReflection()->SetUInt64(sub_message, map_uint64_uint64_key_,
+ 1);
+ sub_message->GetReflection()->SetUInt64(sub_message, map_uint64_uint64_val_,
+ 1);
sub_message = reflection->AddMessage(message, F("map_sint32_sint32"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_sint32_sint32_key_, 1);
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_sint32_sint32_val_, 1);
+ sub_message->GetReflection()->SetInt32(sub_message, map_sint32_sint32_key_,
+ 1);
+ sub_message->GetReflection()->SetInt32(sub_message, map_sint32_sint32_val_,
+ 1);
sub_message = reflection->AddMessage(message, F("map_sint64_sint64"));
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_sint64_sint64_key_, 1);
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_sint64_sint64_val_, 1);
+ sub_message->GetReflection()->SetInt64(sub_message, map_sint64_sint64_key_,
+ 1);
+ sub_message->GetReflection()->SetInt64(sub_message, map_sint64_sint64_val_,
+ 1);
sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32"));
- sub_message->GetReflection()
- ->SetUInt32(sub_message, map_fixed32_fixed32_key_, 1);
- sub_message->GetReflection()
- ->SetUInt32(sub_message, map_fixed32_fixed32_val_, 1);
+ sub_message->GetReflection()->SetUInt32(sub_message, map_fixed32_fixed32_key_,
+ 1);
+ sub_message->GetReflection()->SetUInt32(sub_message, map_fixed32_fixed32_val_,
+ 1);
sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64"));
- sub_message->GetReflection()
- ->SetUInt64(sub_message, map_fixed64_fixed64_key_, 1);
- sub_message->GetReflection()
- ->SetUInt64(sub_message, map_fixed64_fixed64_val_, 1);
+ sub_message->GetReflection()->SetUInt64(sub_message, map_fixed64_fixed64_key_,
+ 1);
+ sub_message->GetReflection()->SetUInt64(sub_message, map_fixed64_fixed64_val_,
+ 1);
sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_sfixed32_sfixed32_key_, 1);
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_sfixed32_sfixed32_val_, 1);
+ sub_message->GetReflection()->SetInt32(sub_message,
+ map_sfixed32_sfixed32_key_, 1);
+ sub_message->GetReflection()->SetInt32(sub_message,
+ map_sfixed32_sfixed32_val_, 1);
sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64"));
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_sfixed64_sfixed64_key_, 1);
- sub_message->GetReflection()
- ->SetInt64(sub_message, map_sfixed64_sfixed64_val_, 1);
+ sub_message->GetReflection()->SetInt64(sub_message,
+ map_sfixed64_sfixed64_key_, 1);
+ sub_message->GetReflection()->SetInt64(sub_message,
+ map_sfixed64_sfixed64_val_, 1);
sub_message = reflection->AddMessage(message, F("map_int32_float"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_float_key_, 1);
- sub_message->GetReflection()
- ->SetFloat(sub_message, map_int32_float_val_, 1.0);
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_float_key_, 1);
+ sub_message->GetReflection()->SetFloat(sub_message, map_int32_float_val_,
+ 1.0);
sub_message = reflection->AddMessage(message, F("map_int32_double"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_double_key_, 1);
- sub_message->GetReflection()
- ->SetDouble(sub_message, map_int32_double_val_, 1.0);
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_double_key_, 1);
+ sub_message->GetReflection()->SetDouble(sub_message, map_int32_double_val_,
+ 1.0);
sub_message = reflection->AddMessage(message, F("map_bool_bool"));
- sub_message->GetReflection()
- ->SetBool(sub_message, map_bool_bool_key_, true);
- sub_message->GetReflection()
- ->SetBool(sub_message, map_bool_bool_val_, true);
+ sub_message->GetReflection()->SetBool(sub_message, map_bool_bool_key_, true);
+ sub_message->GetReflection()->SetBool(sub_message, map_bool_bool_val_, true);
sub_message = reflection->AddMessage(message, F("map_string_string"));
- sub_message->GetReflection()
- ->SetString(sub_message, map_string_string_key_, "1");
- sub_message->GetReflection()
- ->SetString(sub_message, map_string_string_val_, "1");
+ sub_message->GetReflection()->SetString(sub_message, map_string_string_key_,
+ "1");
+ sub_message->GetReflection()->SetString(sub_message, map_string_string_val_,
+ "1");
sub_message = reflection->AddMessage(message, F("map_int32_bytes"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_bytes_key_, 1);
- sub_message->GetReflection()
- ->SetString(sub_message, map_int32_bytes_val_, "1");
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_bytes_key_, 1);
+ sub_message->GetReflection()->SetString(sub_message, map_int32_bytes_val_,
+ "1");
sub_message = reflection->AddMessage(message, F("map_int32_enum"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_enum_key_, 1);
- sub_message->GetReflection()
- ->SetEnum(sub_message, map_int32_enum_val_, map_enum_baz_);
+ sub_message->GetReflection()->SetInt32(sub_message, map_int32_enum_key_, 1);
+ sub_message->GetReflection()->SetEnum(sub_message, map_int32_enum_val_,
+ map_enum_baz_);
- sub_message = reflection
- ->AddMessage(message, F("map_int32_foreign_message"));
- sub_message->GetReflection()
- ->SetInt32(sub_message, map_int32_foreign_message_key_, 1);
- sub_foreign_message = sub_message->GetReflection()->
- MutableMessage(sub_message, map_int32_foreign_message_val_, NULL);
- sub_foreign_message->GetReflection()->
- SetInt32(sub_foreign_message, foreign_c_, 1);
+ sub_message = reflection->AddMessage(message, F("map_int32_foreign_message"));
+ sub_message->GetReflection()->SetInt32(sub_message,
+ map_int32_foreign_message_key_, 1);
+ sub_foreign_message = sub_message->GetReflection()->MutableMessage(
+ sub_message, map_int32_foreign_message_val_, NULL);
+ sub_foreign_message->GetReflection()->SetInt32(sub_foreign_message,
+ foreign_c_, 1);
}
-void MapReflectionTester::SetMapFieldsViaMapReflection(
- Message* message) {
+void MapReflectionTester::SetMapFieldsViaMapReflection(Message* message) {
const Reflection* reflection = message->GetReflection();
Message* sub_foreign_message = NULL;
@@ -565,13 +550,13 @@
// Add first element.
MapKey map_key;
map_key.SetInt32Value(0);
- EXPECT_TRUE(reflection->InsertOrLookupMapValue(
- message, F("map_int32_int32"), map_key, &map_val));
+ EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_int32"),
+ map_key, &map_val));
map_val.SetInt32Value(0);
map_key.SetInt64Value(0);
- EXPECT_TRUE(reflection->InsertOrLookupMapValue(
- message, F("map_int64_int64"), map_key, &map_val));
+ EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int64_int64"),
+ map_key, &map_val));
map_val.SetInt64Value(0);
map_key.SetUInt32Value(0);
@@ -615,18 +600,18 @@
map_val.SetInt64Value(0);
map_key.SetInt32Value(0);
- EXPECT_TRUE(reflection->InsertOrLookupMapValue(
- message, F("map_int32_float"), map_key, &map_val));
+ EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_float"),
+ map_key, &map_val));
map_val.SetFloatValue(0.0);
map_key.SetInt32Value(0);
- EXPECT_TRUE(reflection->InsertOrLookupMapValue(
- message, F("map_int32_double"), map_key, &map_val));
+ EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_double"),
+ map_key, &map_val));
map_val.SetDoubleValue(0.0);
map_key.SetBoolValue(false);
- EXPECT_TRUE(reflection->InsertOrLookupMapValue(
- message, F("map_bool_bool"), map_key, &map_val));
+ EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_bool_bool"),
+ map_key, &map_val));
map_val.SetBoolValue(false);
map_key.SetStringValue("0");
@@ -635,113 +620,113 @@
map_val.SetStringValue("0");
map_key.SetInt32Value(0);
- EXPECT_TRUE(reflection->InsertOrLookupMapValue(
- message, F("map_int32_bytes"), map_key, &map_val));
+ EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_bytes"),
+ map_key, &map_val));
map_val.SetStringValue("0");
map_key.SetInt32Value(0);
- EXPECT_TRUE(reflection->InsertOrLookupMapValue(
- message, F("map_int32_enum"), map_key, &map_val));
+ EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_enum"),
+ map_key, &map_val));
map_val.SetEnumValue(map_enum_bar_->number());
map_key.SetInt32Value(0);
EXPECT_TRUE(reflection->InsertOrLookupMapValue(
message, F("map_int32_foreign_message"), map_key, &map_val));
sub_foreign_message = map_val.MutableMessageValue();
- sub_foreign_message->GetReflection()->SetInt32(
- sub_foreign_message, foreign_c_, 0);
+ sub_foreign_message->GetReflection()->SetInt32(sub_foreign_message,
+ foreign_c_, 0);
// Add second element
map_key.SetInt32Value(1);
- EXPECT_TRUE(reflection->InsertOrLookupMapValue(
- message, F("map_int32_int32"), map_key, &map_val));
+ EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_int32"),
+ map_key, &map_val));
map_val.SetInt32Value(1);
- EXPECT_FALSE(reflection->InsertOrLookupMapValue(
- message, F("map_int32_int32"), map_key, &map_val));
+ EXPECT_FALSE(reflection->InsertOrLookupMapValue(message, F("map_int32_int32"),
+ map_key, &map_val));
map_key.SetInt64Value(1);
- EXPECT_TRUE(reflection->InsertOrLookupMapValue(
- message, F("map_int64_int64"), map_key, &map_val));
+ EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int64_int64"),
+ map_key, &map_val));
map_val.SetInt64Value(1);
- EXPECT_FALSE(reflection->InsertOrLookupMapValue(
- message, F("map_int64_int64"), map_key, &map_val));
+ EXPECT_FALSE(reflection->InsertOrLookupMapValue(message, F("map_int64_int64"),
+ map_key, &map_val));
map_key.SetUInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_uint32_uint32"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_uint32_uint32"), map_key,
+ &map_val);
map_val.SetUInt32Value(1);
map_key.SetUInt64Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_uint64_uint64"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_uint64_uint64"), map_key,
+ &map_val);
map_val.SetUInt64Value(1);
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_sint32_sint32"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_sint32_sint32"), map_key,
+ &map_val);
map_val.SetInt32Value(1);
map_key.SetInt64Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_sint64_sint64"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_sint64_sint64"), map_key,
+ &map_val);
map_val.SetInt64Value(1);
map_key.SetUInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_fixed32_fixed32"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_fixed32_fixed32"), map_key,
+ &map_val);
map_val.SetUInt32Value(1);
map_key.SetUInt64Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_fixed64_fixed64"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_fixed64_fixed64"), map_key,
+ &map_val);
map_val.SetUInt64Value(1);
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_sfixed32_sfixed32"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_sfixed32_sfixed32"),
+ map_key, &map_val);
map_val.SetInt32Value(1);
map_key.SetInt64Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_sfixed64_sfixed64"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_sfixed64_sfixed64"),
+ map_key, &map_val);
map_val.SetInt64Value(1);
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_int32_float"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_int32_float"), map_key,
+ &map_val);
map_val.SetFloatValue(1.0);
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_int32_double"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_int32_double"), map_key,
+ &map_val);
map_val.SetDoubleValue(1.0);
map_key.SetBoolValue(true);
- reflection->InsertOrLookupMapValue(
- message, F("map_bool_bool"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_bool_bool"), map_key,
+ &map_val);
map_val.SetBoolValue(true);
map_key.SetStringValue("1");
- reflection->InsertOrLookupMapValue(
- message, F("map_string_string"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_string_string"), map_key,
+ &map_val);
map_val.SetStringValue("1");
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_int32_bytes"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_int32_bytes"), map_key,
+ &map_val);
map_val.SetStringValue("1");
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_int32_enum"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_int32_enum"), map_key,
+ &map_val);
map_val.SetEnumValue(map_enum_baz_->number());
map_key.SetInt32Value(1);
EXPECT_TRUE(reflection->InsertOrLookupMapValue(
message, F("map_int32_foreign_message"), map_key, &map_val));
sub_foreign_message = map_val.MutableMessageValue();
- sub_foreign_message->GetReflection()->SetInt32(
- sub_foreign_message, foreign_c_, 1);
+ sub_foreign_message->GetReflection()->SetInt32(sub_foreign_message,
+ foreign_c_, 1);
}
void MapReflectionTester::GetMapValueViaMapReflection(
@@ -770,8 +755,7 @@
return reflection->MapEnd(message, F(field_name));
}
-void MapReflectionTester::ClearMapFieldsViaReflection(
- Message* message) {
+void MapReflectionTester::ClearMapFieldsViaReflection(Message* message) {
const Reflection* reflection = message->GetReflection();
reflection->ClearField(message, F("map_int32_int32"));
@@ -793,8 +777,7 @@
reflection->ClearField(message, F("map_int32_foreign_message"));
}
-void MapReflectionTester::ModifyMapFieldsViaReflection(
- Message* message) {
+void MapReflectionTester::ModifyMapFieldsViaReflection(Message* message) {
const Reflection* reflection = message->GetReflection();
MapValueRef map_val;
Message* sub_foreign_message;
@@ -802,13 +785,13 @@
// Modify the second element
MapKey map_key;
map_key.SetInt32Value(1);
- EXPECT_FALSE(reflection->InsertOrLookupMapValue(
- message, F("map_int32_int32"), map_key, &map_val));
+ EXPECT_FALSE(reflection->InsertOrLookupMapValue(message, F("map_int32_int32"),
+ map_key, &map_val));
map_val.SetInt32Value(2);
map_key.SetInt64Value(1);
- EXPECT_FALSE(reflection->InsertOrLookupMapValue(
- message, F("map_int64_int64"), map_key, &map_val));
+ EXPECT_FALSE(reflection->InsertOrLookupMapValue(message, F("map_int64_int64"),
+ map_key, &map_val));
map_val.SetInt64Value(2);
map_key.SetUInt32Value(1);
@@ -817,80 +800,79 @@
map_val.SetUInt32Value(2);
map_key.SetUInt64Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_uint64_uint64"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_uint64_uint64"), map_key,
+ &map_val);
map_val.SetUInt64Value(2);
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_sint32_sint32"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_sint32_sint32"), map_key,
+ &map_val);
map_val.SetInt32Value(2);
map_key.SetInt64Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_sint64_sint64"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_sint64_sint64"), map_key,
+ &map_val);
map_val.SetInt64Value(2);
map_key.SetUInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_fixed32_fixed32"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_fixed32_fixed32"), map_key,
+ &map_val);
map_val.SetUInt32Value(2);
map_key.SetUInt64Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_fixed64_fixed64"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_fixed64_fixed64"), map_key,
+ &map_val);
map_val.SetUInt64Value(2);
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_sfixed32_sfixed32"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_sfixed32_sfixed32"),
+ map_key, &map_val);
map_val.SetInt32Value(2);
map_key.SetInt64Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_sfixed64_sfixed64"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_sfixed64_sfixed64"),
+ map_key, &map_val);
map_val.SetInt64Value(2);
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_int32_float"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_int32_float"), map_key,
+ &map_val);
map_val.SetFloatValue(2.0);
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_int32_double"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_int32_double"), map_key,
+ &map_val);
map_val.SetDoubleValue(2.0);
map_key.SetBoolValue(true);
- reflection->InsertOrLookupMapValue(
- message, F("map_bool_bool"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_bool_bool"), map_key,
+ &map_val);
map_val.SetBoolValue(false);
map_key.SetStringValue("1");
- reflection->InsertOrLookupMapValue(
- message, F("map_string_string"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_string_string"), map_key,
+ &map_val);
map_val.SetStringValue("2");
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_int32_bytes"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_int32_bytes"), map_key,
+ &map_val);
map_val.SetStringValue("2");
map_key.SetInt32Value(1);
- reflection->InsertOrLookupMapValue(
- message, F("map_int32_enum"), map_key, &map_val);
+ reflection->InsertOrLookupMapValue(message, F("map_int32_enum"), map_key,
+ &map_val);
map_val.SetEnumValue(map_enum_foo_->number());
map_key.SetInt32Value(1);
EXPECT_FALSE(reflection->InsertOrLookupMapValue(
message, F("map_int32_foreign_message"), map_key, &map_val));
sub_foreign_message = map_val.MutableMessageValue();
- sub_foreign_message->GetReflection()->SetInt32(
- sub_foreign_message, foreign_c_, 2);
+ sub_foreign_message->GetReflection()->SetInt32(sub_foreign_message,
+ foreign_c_, 2);
}
-void MapReflectionTester::RemoveLastMapsViaReflection(
- Message* message) {
+void MapReflectionTester::RemoveLastMapsViaReflection(Message* message) {
const Reflection* reflection = message->GetReflection();
std::vector<const FieldDescriptor*> output;
@@ -902,8 +884,7 @@
}
}
-void MapReflectionTester::ReleaseLastMapsViaReflection(
- Message* message) {
+void MapReflectionTester::ReleaseLastMapsViaReflection(Message* message) {
const Reflection* reflection = message->GetReflection();
std::vector<const FieldDescriptor*> output;
@@ -914,8 +895,8 @@
if (field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) continue;
Message* released = reflection->ReleaseLast(message, field);
- ASSERT_TRUE(released != NULL) << "ReleaseLast returned NULL for: "
- << field->name();
+ ASSERT_TRUE(released != NULL)
+ << "ReleaseLast returned NULL for: " << field->name();
delete released;
}
}
@@ -931,8 +912,8 @@
}
}
-void MapReflectionTester::
- MutableUnknownFieldsOfMapFieldsViaReflection(Message* message) {
+void MapReflectionTester::MutableUnknownFieldsOfMapFieldsViaReflection(
+ Message* message) {
const Reflection* reflection = message->GetReflection();
Message* sub_message = NULL;
@@ -1024,15 +1005,15 @@
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_int32_int32"), i);
- int32 key = sub_message->GetReflection()->GetInt32(
- *sub_message, map_int32_int32_key_);
- int32 val = sub_message->GetReflection()->GetInt32(
- *sub_message, map_int32_int32_val_);
+ int32 key = sub_message->GetReflection()->GetInt32(*sub_message,
+ map_int32_int32_key_);
+ int32 val = sub_message->GetReflection()->GetInt32(*sub_message,
+ map_int32_int32_val_);
EXPECT_EQ(map[key], val);
// Check with Map Reflection
map_key.SetInt32Value(key);
- EXPECT_TRUE(reflection->ContainsMapKey(
- message, F("map_int32_int32"), map_key));
+ EXPECT_TRUE(
+ reflection->ContainsMapKey(message, F("map_int32_int32"), map_key));
}
}
{
@@ -1043,15 +1024,15 @@
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_int64_int64"), i);
- int64 key = sub_message->GetReflection()->GetInt64(
- *sub_message, map_int64_int64_key_);
- int64 val = sub_message->GetReflection()->GetInt64(
- *sub_message, map_int64_int64_val_);
+ int64 key = sub_message->GetReflection()->GetInt64(*sub_message,
+ map_int64_int64_key_);
+ int64 val = sub_message->GetReflection()->GetInt64(*sub_message,
+ map_int64_int64_val_);
EXPECT_EQ(map[key], val);
// Check with Map Reflection
map_key.SetInt64Value(key);
- EXPECT_TRUE(reflection->ContainsMapKey(
- message, F("map_int64_int64"), map_key));
+ EXPECT_TRUE(
+ reflection->ContainsMapKey(message, F("map_int64_int64"), map_key));
}
}
{
@@ -1069,8 +1050,8 @@
EXPECT_EQ(map[key], val);
// Check with Map Reflection
map_key.SetUInt32Value(key);
- EXPECT_TRUE(reflection->ContainsMapKey(
- message, F("map_uint32_uint32"), map_key));
+ EXPECT_TRUE(
+ reflection->ContainsMapKey(message, F("map_uint32_uint32"), map_key));
}
}
{
@@ -1087,8 +1068,8 @@
EXPECT_EQ(map[key], val);
// Check with Map Reflection
map_key.SetUInt64Value(key);
- EXPECT_TRUE(reflection->ContainsMapKey(
- message, F("map_uint64_uint64"), map_key));
+ EXPECT_TRUE(
+ reflection->ContainsMapKey(message, F("map_uint64_uint64"), map_key));
}
}
{
@@ -1106,7 +1087,7 @@
// Check with Map Reflection
map_key.SetInt32Value(key);
EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_sint32_sint32"), map_key));
+ message, F("map_sint32_sint32"), map_key));
}
}
{
@@ -1124,7 +1105,7 @@
// Check with Map Reflection
map_key.SetInt64Value(key);
EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_sint64_sint64"), map_key));
+ message, F("map_sint64_sint64"), map_key));
}
}
{
@@ -1142,7 +1123,7 @@
// Check with Map Reflection
map_key.SetUInt32Value(key);
EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_fixed32_fixed32"), map_key));
+ message, F("map_fixed32_fixed32"), map_key));
}
}
{
@@ -1160,7 +1141,7 @@
// Check with Map Reflection
map_key.SetUInt64Value(key);
EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_fixed64_fixed64"), map_key));
+ message, F("map_fixed64_fixed64"), map_key));
}
}
{
@@ -1178,7 +1159,7 @@
// Check with Map Reflection
map_key.SetInt32Value(key);
EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_sfixed32_sfixed32"), map_key));
+ message, F("map_sfixed32_sfixed32"), map_key));
}
}
{
@@ -1196,7 +1177,7 @@
// Check with Map Reflection
map_key.SetInt64Value(key);
EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_sfixed64_sfixed64"), map_key));
+ message, F("map_sfixed64_sfixed64"), map_key));
}
}
{
@@ -1206,15 +1187,15 @@
for (int i = 0; i < 2; i++) {
sub_message =
&reflection->GetRepeatedMessage(message, F("map_int32_float"), i);
- int32 key = sub_message->GetReflection()->GetInt32(
- *sub_message, map_int32_float_key_);
- float val = sub_message->GetReflection()->GetFloat(
- *sub_message, map_int32_float_val_);
+ int32 key = sub_message->GetReflection()->GetInt32(*sub_message,
+ map_int32_float_key_);
+ float val = sub_message->GetReflection()->GetFloat(*sub_message,
+ map_int32_float_val_);
EXPECT_EQ(map[key], val);
// Check with Map Reflection
map_key.SetInt32Value(key);
- EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_int32_float"), map_key));
+ EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_int32_float"),
+ map_key));
}
}
{
@@ -1224,15 +1205,15 @@
for (int i = 0; i < 2; i++) {
sub_message =
&reflection->GetRepeatedMessage(message, F("map_int32_double"), i);
- int32 key = sub_message->GetReflection()->GetInt32(
- *sub_message, map_int32_double_key_);
+ int32 key = sub_message->GetReflection()->GetInt32(*sub_message,
+ map_int32_double_key_);
double val = sub_message->GetReflection()->GetDouble(
*sub_message, map_int32_double_val_);
EXPECT_EQ(map[key], val);
// Check with Map Reflection
map_key.SetInt32Value(key);
- EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_int32_double"), map_key));
+ EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_int32_double"),
+ map_key));
}
}
{
@@ -1242,15 +1223,15 @@
for (int i = 0; i < 2; i++) {
sub_message =
&reflection->GetRepeatedMessage(message, F("map_bool_bool"), i);
- bool key = sub_message->GetReflection()->GetBool(
- *sub_message, map_bool_bool_key_);
- bool val = sub_message->GetReflection()->GetBool(
- *sub_message, map_bool_bool_val_);
+ bool key = sub_message->GetReflection()->GetBool(*sub_message,
+ map_bool_bool_key_);
+ bool val = sub_message->GetReflection()->GetBool(*sub_message,
+ map_bool_bool_val_);
EXPECT_EQ(map[key], val);
// Check with Map Reflection
map_key.SetBoolValue(key);
- EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_bool_bool"), map_key));
+ EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_bool_bool"),
+ map_key));
}
}
{
@@ -1268,7 +1249,7 @@
// Check with Map Reflection
map_key.SetStringValue(key);
EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_string_string"), map_key));
+ message, F("map_string_string"), map_key));
}
}
{
@@ -1278,15 +1259,15 @@
for (int i = 0; i < 2; i++) {
sub_message =
&reflection->GetRepeatedMessage(message, F("map_int32_bytes"), i);
- int32 key = sub_message->GetReflection()->GetInt32(
- *sub_message, map_int32_bytes_key_);
+ int32 key = sub_message->GetReflection()->GetInt32(*sub_message,
+ map_int32_bytes_key_);
std::string val = sub_message->GetReflection()->GetString(
*sub_message, map_int32_bytes_val_);
EXPECT_EQ(map[key], val);
// Check with Map Reflection
map_key.SetInt32Value(key);
- EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_int32_bytes"), map_key));
+ EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_int32_bytes"),
+ map_key));
}
}
{
@@ -1294,17 +1275,17 @@
map[0] = map_enum_bar_;
map[1] = map_enum_baz_;
for (int i = 0; i < 2; i++) {
- sub_message = &reflection->GetRepeatedMessage(
- message, F("map_int32_enum"), i);
- int32 key = sub_message->GetReflection()->GetInt32(
- *sub_message, map_int32_enum_key_);
+ sub_message =
+ &reflection->GetRepeatedMessage(message, F("map_int32_enum"), i);
+ int32 key = sub_message->GetReflection()->GetInt32(*sub_message,
+ map_int32_enum_key_);
const EnumValueDescriptor* val = sub_message->GetReflection()->GetEnum(
*sub_message, map_int32_enum_val_);
EXPECT_EQ(map[key], val);
// Check with Map Reflection
map_key.SetInt32Value(key);
- EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_int32_enum"), map_key));
+ EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_int32_enum"),
+ map_key));
}
}
{
@@ -1314,17 +1295,17 @@
for (int i = 0; i < 2; i++) {
sub_message = &reflection->GetRepeatedMessage(
message, F("map_int32_foreign_message"), i);
- int32 key = sub_message->GetReflection()->GetInt32(
+ int32 key = sub_message->GetReflection()->GetInt32(
*sub_message, map_int32_foreign_message_key_);
const Message& foreign_message = sub_message->GetReflection()->GetMessage(
*sub_message, map_int32_foreign_message_val_);
- int32 val = foreign_message.GetReflection()->GetInt32(
- foreign_message, foreign_c_);
+ int32 val = foreign_message.GetReflection()->GetInt32(foreign_message,
+ foreign_c_);
EXPECT_EQ(map[key], val);
// Check with Map Reflection
map_key.SetInt32Value(key);
EXPECT_EQ(true, reflection->ContainsMapKey(
- message, F("map_int32_foreign_message"), map_key));
+ message, F("map_int32_foreign_message"), map_key));
}
}
}
@@ -1386,10 +1367,9 @@
std::map<uint32, uint32> map;
map[0] = 0;
map[1] = 1;
- for (MapIterator iter = reflection->MapBegin(
- message, F("map_uint32_uint32"));
- iter != reflection->MapEnd(message, F("map_uint32_uint32"));
- ++iter) {
+ for (MapIterator iter =
+ reflection->MapBegin(message, F("map_uint32_uint32"));
+ iter != reflection->MapEnd(message, F("map_uint32_uint32")); ++iter) {
EXPECT_EQ(map[iter.GetKey().GetUInt32Value()],
iter.GetValueRef().GetUInt32Value());
}
@@ -1398,10 +1378,9 @@
std::map<uint64, uint64> map;
map[0] = 0;
map[1] = 1;
- for (MapIterator iter = reflection->MapBegin(
- message, F("map_uint64_uint64"));
- iter != reflection->MapEnd(message, F("map_uint64_uint64"));
- ++iter) {
+ for (MapIterator iter =
+ reflection->MapBegin(message, F("map_uint64_uint64"));
+ iter != reflection->MapEnd(message, F("map_uint64_uint64")); ++iter) {
EXPECT_EQ(map[iter.GetKey().GetUInt64Value()],
iter.GetValueRef().GetUInt64Value());
}
@@ -1410,10 +1389,9 @@
std::map<int32, int32> map;
map[0] = 0;
map[1] = 1;
- for (MapIterator iter = reflection->MapBegin(
- message, F("map_sint32_sint32"));
- iter != reflection->MapEnd(message, F("map_sint32_sint32"));
- ++iter) {
+ for (MapIterator iter =
+ reflection->MapBegin(message, F("map_sint32_sint32"));
+ iter != reflection->MapEnd(message, F("map_sint32_sint32")); ++iter) {
EXPECT_EQ(map[iter.GetKey().GetInt32Value()],
iter.GetValueRef().GetInt32Value());
}
@@ -1422,8 +1400,8 @@
std::map<int64, int64> map;
map[0] = 0;
map[1] = 1;
- for (MapIterator iter = reflection->MapBegin(
- message, F("map_sint64_sint64"));
+ for (MapIterator iter =
+ reflection->MapBegin(message, F("map_sint64_sint64"));
iter != reflection->MapEnd(message, F("map_sint64_sint64")); ++iter) {
EXPECT_EQ(map[iter.GetKey().GetInt64Value()],
iter.GetValueRef().GetInt64Value());
@@ -1433,8 +1411,8 @@
std::map<uint32, uint32> map;
map[0] = 0;
map[1] = 1;
- for (MapIterator iter = reflection->MapBegin(
- message, F("map_fixed32_fixed32"));
+ for (MapIterator iter =
+ reflection->MapBegin(message, F("map_fixed32_fixed32"));
iter != reflection->MapEnd(message, F("map_fixed32_fixed32"));
++iter) {
EXPECT_EQ(map[iter.GetKey().GetUInt32Value()],
@@ -1445,8 +1423,8 @@
std::map<uint64, uint64> map;
map[0] = 0;
map[1] = 1;
- for (MapIterator iter = reflection->MapBegin(
- message, F("map_fixed64_fixed64"));
+ for (MapIterator iter =
+ reflection->MapBegin(message, F("map_fixed64_fixed64"));
iter != reflection->MapEnd(message, F("map_fixed64_fixed64"));
++iter) {
EXPECT_EQ(map[iter.GetKey().GetUInt64Value()],
@@ -1457,8 +1435,8 @@
std::map<int32, int32> map;
map[0] = 0;
map[1] = 1;
- for (MapIterator iter = reflection->MapBegin(
- message, F("map_sfixed32_sfixed32"));
+ for (MapIterator iter =
+ reflection->MapBegin(message, F("map_sfixed32_sfixed32"));
iter != reflection->MapEnd(message, F("map_sfixed32_sfixed32"));
++iter) {
EXPECT_EQ(map[iter.GetKey().GetInt32Value()],
@@ -1479,8 +1457,8 @@
std::map<int32, double> map;
map[0] = 0.0;
map[1] = 1.0;
- for (MapIterator iter = reflection->MapBegin(
- message, F("map_int32_double"));
+ for (MapIterator iter =
+ reflection->MapBegin(message, F("map_int32_double"));
iter != reflection->MapEnd(message, F("map_int32_double")); ++iter) {
EXPECT_EQ(map[iter.GetKey().GetInt32Value()],
iter.GetValueRef().GetDoubleValue());
@@ -1501,8 +1479,8 @@
map["0"] = "0";
map["1"] = "1";
int size = 0;
- for (MapIterator iter = reflection->MapBegin(
- message, F("map_string_string"));
+ for (MapIterator iter =
+ reflection->MapBegin(message, F("map_string_string"));
iter != reflection->MapEnd(message, F("map_string_string"));
++iter, ++size) {
// Check const methods do not invalidate map.
@@ -1541,8 +1519,8 @@
map[0] = 0;
map[1] = 1;
int size = 0;
- for (MapIterator iter = reflection->MapBegin(
- message, F("map_int32_foreign_message"));
+ for (MapIterator iter =
+ reflection->MapBegin(message, F("map_int32_foreign_message"));
iter != reflection->MapEnd(message, F("map_int32_foreign_message"));
++iter, ++size) {
// Check const methods do not invalidate map.
@@ -1559,8 +1537,7 @@
}
}
-void MapReflectionTester::ExpectClearViaReflection(
- const Message& message) {
+void MapReflectionTester::ExpectClearViaReflection(const Message& message) {
const Reflection* reflection = message.GetReflection();
// Map fields are empty.
EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_int32")));
@@ -1580,12 +1557,11 @@
EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_bytes")));
EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_enum")));
EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_foreign_message")));
- EXPECT_TRUE(reflection->GetMapData(
- message, F("map_int32_foreign_message"))->IsMapValid());
+ EXPECT_TRUE(reflection->GetMapData(message, F("map_int32_foreign_message"))
+ ->IsMapValid());
}
-void MapReflectionTester::ExpectClearViaReflectionIterator(
- Message* message) {
+void MapReflectionTester::ExpectClearViaReflectionIterator(Message* message) {
const Reflection* reflection = message->GetReflection();
EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_int32")) ==
reflection->MapEnd(message, F("map_int32_int32")));
@@ -1623,8 +1599,7 @@
reflection->MapEnd(message, F("map_int32_foreign_message")));
}
-void MapReflectionTester::ExpectMapEntryClearViaReflection(
- Message* message) {
+void MapReflectionTester::ExpectMapEntryClearViaReflection(Message* message) {
const Reflection* reflection = message->GetReflection();
const Message* sub_message;
@@ -1806,7 +1781,7 @@
EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message,
key_descriptor));
EXPECT_EQ("", sub_message->GetReflection()->GetString(*sub_message,
- value_descriptor));
+ value_descriptor));
}
{
const FieldDescriptor* descriptor = F("map_int32_enum");
diff --git a/src/google/protobuf/map_test_util.h b/src/google/protobuf/map_test_util.h
index ede290b..00d2fa4 100644
--- a/src/google/protobuf/map_test_util.h
+++ b/src/google/protobuf/map_test_util.h
@@ -63,8 +63,7 @@
// Check that all fields have the values that they should have after
// SetMapFieldsInitialized() is called.
- static void ExpectMapFieldsSetInitialized(
- const unittest::TestMap& message);
+ static void ExpectMapFieldsSetInitialized(const unittest::TestMap& message);
// Expect that the message is modified as would be expected from
// ModifyMapFields().
diff --git a/src/google/protobuf/map_test_util_impl.h b/src/google/protobuf/map_test_util_impl.h
index 2e8b4ba..70145b7 100644
--- a/src/google/protobuf/map_test_util_impl.h
+++ b/src/google/protobuf/map_test_util_impl.h
@@ -36,7 +36,7 @@
#include <gtest/gtest.h>
-namespace protobuf_unittest {} // forward declaration
+namespace protobuf_unittest {} // namespace protobuf_unittest
namespace google {
namespace protobuf {
@@ -46,13 +46,13 @@
class MapTestUtilImpl {
public:
// Set every field in the TestMap message to a unique value.
- template <typename EnumType, EnumType enum_value0,
- EnumType enum_value1, typename MapMessage>
+ template <typename EnumType, EnumType enum_value0, EnumType enum_value1,
+ typename MapMessage>
static void SetMapFields(MapMessage* message);
// Set every field in the TestArenaMap message to a unique value.
- template <typename EnumType, EnumType enum_value0,
- EnumType enum_value1, typename MapMessage>
+ template <typename EnumType, EnumType enum_value0, EnumType enum_value1,
+ typename MapMessage>
static void SetArenaMapFields(MapMessage* message);
// Set every field in the message to a default value.
@@ -66,14 +66,14 @@
// Check that all fields have the values that they should have after
// SetMapFields() is called.
- template <typename EnumType, EnumType enum_value0,
- EnumType enum_value1, typename MapMessage>
+ template <typename EnumType, EnumType enum_value0, EnumType enum_value1,
+ typename MapMessage>
static void ExpectMapFieldsSet(const MapMessage& message);
// Check that all fields have the values that they should have after
// SetMapFields() is called for TestArenaMap.
- template <typename EnumType, EnumType enum_value0,
- EnumType enum_value1, typename MapMessage>
+ template <typename EnumType, EnumType enum_value0, EnumType enum_value1,
+ typename MapMessage>
static void ExpectArenaMapFieldsSet(const MapMessage& message);
// Check that all fields have the values that they should have after
@@ -83,8 +83,8 @@
// Expect that the message is modified as would be expected from
// ModifyMapFields().
- template <typename EnumType, EnumType enum_value0,
- EnumType enum_value1, typename MapMessage>
+ template <typename EnumType, EnumType enum_value0, EnumType enum_value1,
+ typename MapMessage>
static void ExpectMapFieldsModified(const MapMessage& message);
// Check that all fields are empty.
@@ -104,8 +104,8 @@
// MapMessage* message);
};
-template <typename EnumType, EnumType enum_value0,
- EnumType enum_value1, typename MapMessage>
+template <typename EnumType, EnumType enum_value0, EnumType enum_value1,
+ typename MapMessage>
void MapTestUtilImpl::SetMapFields(MapMessage* message) {
// Add first element.
(*message->mutable_map_int32_int32())[0] = 0;
@@ -146,8 +146,8 @@
(*message->mutable_map_int32_foreign_message())[1].set_c(1);
}
-template <typename EnumType, EnumType enum_value0,
- EnumType enum_value1, typename MapMessage>
+template <typename EnumType, EnumType enum_value0, EnumType enum_value1,
+ typename MapMessage>
void MapTestUtilImpl::SetArenaMapFields(MapMessage* message) {
// Add first element.
(*message->mutable_map_int32_int32())[0] = 0;
@@ -255,10 +255,8 @@
EXPECT_EQ(0, message.map_int32_foreign_message().size());
}
-
-
-template <typename EnumType, EnumType enum_value0,
- EnumType enum_value1, typename MapMessage>
+template <typename EnumType, EnumType enum_value0, EnumType enum_value1,
+ typename MapMessage>
void MapTestUtilImpl::ExpectMapFieldsSet(const MapMessage& message) {
ASSERT_EQ(2, message.map_int32_int32().size());
ASSERT_EQ(2, message.map_int64_int64().size());
@@ -315,8 +313,8 @@
EXPECT_EQ(1, message.map_int32_foreign_message().at(1).c());
}
-template <typename EnumType, EnumType enum_value0,
- EnumType enum_value1, typename MapMessage>
+template <typename EnumType, EnumType enum_value0, EnumType enum_value1,
+ typename MapMessage>
void MapTestUtilImpl::ExpectArenaMapFieldsSet(const MapMessage& message) {
EXPECT_EQ(2, message.map_int32_int32().size());
EXPECT_EQ(2, message.map_int64_int64().size());
@@ -377,8 +375,7 @@
}
template <typename EnumType, EnumType enum_value, typename MapMessage>
-void MapTestUtilImpl::ExpectMapFieldsSetInitialized(
- const MapMessage& message) {
+void MapTestUtilImpl::ExpectMapFieldsSetInitialized(const MapMessage& message) {
EXPECT_EQ(1, message.map_int32_int32().size());
EXPECT_EQ(1, message.map_int64_int64().size());
EXPECT_EQ(1, message.map_uint32_uint32().size());
@@ -416,10 +413,9 @@
EXPECT_EQ(0, message.map_int32_foreign_message().at(0).ByteSize());
}
-template <typename EnumType, EnumType enum_value0,
- EnumType enum_value1, typename MapMessage>
-void MapTestUtilImpl::ExpectMapFieldsModified(
- const MapMessage& message) {
+template <typename EnumType, EnumType enum_value0, EnumType enum_value1,
+ typename MapMessage>
+void MapTestUtilImpl::ExpectMapFieldsModified(const MapMessage& message) {
// ModifyMapFields only sets the second element of each field. In addition to
// verifying this, we also verify that the first element and size were *not*
// modified.
diff --git a/src/google/protobuf/map_type_handler.h b/src/google/protobuf/map_type_handler.h
index 0caf1a7..7964a97 100644
--- a/src/google/protobuf/map_type_handler.h
+++ b/src/google/protobuf/map_type_handler.h
@@ -46,15 +46,15 @@
// Used for compile time type selection. MapIf::type will be TrueType if Flag is
// true and FalseType otherwise.
-template<bool Flag, typename TrueType, typename FalseType>
+template <bool Flag, typename TrueType, typename FalseType>
struct MapIf;
-template<typename TrueType, typename FalseType>
+template <typename TrueType, typename FalseType>
struct MapIf<true, TrueType, FalseType> {
typedef TrueType type;
};
-template<typename TrueType, typename FalseType>
+template <typename TrueType, typename FalseType>
struct MapIf<false, TrueType, FalseType> {
typedef FalseType type;
};
@@ -78,7 +78,8 @@
template <typename Type>
class MapValueInitializer<false, Type> {
public:
- static inline void Initialize(Type& /* value */, int /* default_enum_value */) {}
+ static inline void Initialize(Type& /* value */,
+ int /* default_enum_value */) {}
};
template <typename Type, bool is_arena_constructable>
@@ -119,23 +120,23 @@
WireFormatLite::WIRETYPE_##WireFormatType; \
};
-TYPE_TRAITS(MESSAGE , Type, LENGTH_DELIMITED, true, false)
-TYPE_TRAITS(STRING , ArenaStringPtr, LENGTH_DELIMITED, false, false)
-TYPE_TRAITS(BYTES , ArenaStringPtr , LENGTH_DELIMITED, false, false)
-TYPE_TRAITS(INT64 , int64 , VARINT , false, false)
-TYPE_TRAITS(UINT64 , uint64 , VARINT , false, false)
-TYPE_TRAITS(INT32 , int32 , VARINT , false, false)
-TYPE_TRAITS(UINT32 , uint32 , VARINT , false, false)
-TYPE_TRAITS(SINT64 , int64 , VARINT , false, false)
-TYPE_TRAITS(SINT32 , int32 , VARINT , false, false)
-TYPE_TRAITS(ENUM , int , VARINT , false, true )
-TYPE_TRAITS(DOUBLE , double , FIXED64, false, false)
-TYPE_TRAITS(FLOAT , float , FIXED32, false, false)
-TYPE_TRAITS(FIXED64 , uint64 , FIXED64, false, false)
-TYPE_TRAITS(FIXED32 , uint32 , FIXED32, false, false)
-TYPE_TRAITS(SFIXED64, int64 , FIXED64, false, false)
-TYPE_TRAITS(SFIXED32, int32 , FIXED32, false, false)
-TYPE_TRAITS(BOOL , bool , VARINT , false, false)
+TYPE_TRAITS(MESSAGE, Type, LENGTH_DELIMITED, true, false)
+TYPE_TRAITS(STRING, ArenaStringPtr, LENGTH_DELIMITED, false, false)
+TYPE_TRAITS(BYTES, ArenaStringPtr, LENGTH_DELIMITED, false, false)
+TYPE_TRAITS(INT64, int64, VARINT, false, false)
+TYPE_TRAITS(UINT64, uint64, VARINT, false, false)
+TYPE_TRAITS(INT32, int32, VARINT, false, false)
+TYPE_TRAITS(UINT32, uint32, VARINT, false, false)
+TYPE_TRAITS(SINT64, int64, VARINT, false, false)
+TYPE_TRAITS(SINT32, int32, VARINT, false, false)
+TYPE_TRAITS(ENUM, int, VARINT, false, true)
+TYPE_TRAITS(DOUBLE, double, FIXED64, false, false)
+TYPE_TRAITS(FLOAT, float, FIXED32, false, false)
+TYPE_TRAITS(FIXED64, uint64, FIXED64, false, false)
+TYPE_TRAITS(FIXED32, uint32, FIXED32, false, false)
+TYPE_TRAITS(SFIXED64, int64, FIXED64, false, false)
+TYPE_TRAITS(SFIXED32, int32, FIXED32, false, false)
+TYPE_TRAITS(BOOL, bool, VARINT, false, false)
#undef TYPE_TRAITS
@@ -148,7 +149,8 @@
// Enum type cannot be used for MapTypeHandler::Read. Define a type which will
// replace Enum with int.
typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE,
- Type>::MapEntryAccessorType MapEntryAccessorType;
+ Type>::MapEntryAccessorType
+ MapEntryAccessorType;
// Internal stored type in MapEntryLite for given wire field type.
typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE,
Type>::TypeOnMemory TypeOnMemory;
@@ -198,8 +200,8 @@
static inline void AssignDefaultValue(Type** value);
// Return default instance if value is not initialized when calling const
// reference accessor.
- static inline const Type& DefaultIfNotInitialized(
- const Type* value, const Type* default_value);
+ static inline const Type& DefaultIfNotInitialized(const Type* value,
+ const Type* default_value);
// Check if all required fields have values set.
static inline bool IsInitialized(Type* value);
};
@@ -276,8 +278,7 @@
#undef MAP_HANDLER
template <typename Type>
-inline size_t
-MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::ByteSize(
+inline size_t MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::ByteSize(
const MapEntryAccessorType& value) {
return WireFormatLite::MessageSizeNoVirtual(value);
}
@@ -290,14 +291,14 @@
}
GOOGLE_PROTOBUF_BYTE_SIZE(STRING, String)
-GOOGLE_PROTOBUF_BYTE_SIZE(BYTES , Bytes)
-GOOGLE_PROTOBUF_BYTE_SIZE(INT64 , Int64)
+GOOGLE_PROTOBUF_BYTE_SIZE(BYTES, Bytes)
+GOOGLE_PROTOBUF_BYTE_SIZE(INT64, Int64)
GOOGLE_PROTOBUF_BYTE_SIZE(UINT64, UInt64)
-GOOGLE_PROTOBUF_BYTE_SIZE(INT32 , Int32)
+GOOGLE_PROTOBUF_BYTE_SIZE(INT32, Int32)
GOOGLE_PROTOBUF_BYTE_SIZE(UINT32, UInt32)
GOOGLE_PROTOBUF_BYTE_SIZE(SINT64, SInt64)
GOOGLE_PROTOBUF_BYTE_SIZE(SINT32, SInt32)
-GOOGLE_PROTOBUF_BYTE_SIZE(ENUM , Enum)
+GOOGLE_PROTOBUF_BYTE_SIZE(ENUM, Enum)
#undef GOOGLE_PROTOBUF_BYTE_SIZE
@@ -308,23 +309,21 @@
return WireFormatLite::k##DeclaredType##Size; \
}
-FIXED_BYTE_SIZE(DOUBLE , Double)
-FIXED_BYTE_SIZE(FLOAT , Float)
-FIXED_BYTE_SIZE(FIXED64 , Fixed64)
-FIXED_BYTE_SIZE(FIXED32 , Fixed32)
+FIXED_BYTE_SIZE(DOUBLE, Double)
+FIXED_BYTE_SIZE(FLOAT, Float)
+FIXED_BYTE_SIZE(FIXED64, Fixed64)
+FIXED_BYTE_SIZE(FIXED32, Fixed32)
FIXED_BYTE_SIZE(SFIXED64, SFixed64)
FIXED_BYTE_SIZE(SFIXED32, SFixed32)
-FIXED_BYTE_SIZE(BOOL , Bool)
+FIXED_BYTE_SIZE(BOOL, Bool)
#undef FIXED_BYTE_SIZE
template <typename Type>
-inline int
-MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetCachedSize(
+inline int MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetCachedSize(
const MapEntryAccessorType& value) {
- return static_cast<int>(
- WireFormatLite::LengthDelimitedSize(
- static_cast<size_t>(value.GetCachedSize())));
+ return static_cast<int>(WireFormatLite::LengthDelimitedSize(
+ static_cast<size_t>(value.GetCachedSize())));
}
#define GET_CACHED_SIZE(FieldType, DeclaredType) \
@@ -336,14 +335,14 @@
}
GET_CACHED_SIZE(STRING, String)
-GET_CACHED_SIZE(BYTES , Bytes)
-GET_CACHED_SIZE(INT64 , Int64)
+GET_CACHED_SIZE(BYTES, Bytes)
+GET_CACHED_SIZE(INT64, Int64)
GET_CACHED_SIZE(UINT64, UInt64)
-GET_CACHED_SIZE(INT32 , Int32)
+GET_CACHED_SIZE(INT32, Int32)
GET_CACHED_SIZE(UINT32, UInt32)
GET_CACHED_SIZE(SINT64, SInt64)
GET_CACHED_SIZE(SINT32, SInt32)
-GET_CACHED_SIZE(ENUM , Enum)
+GET_CACHED_SIZE(ENUM, Enum)
#undef GET_CACHED_SIZE
@@ -355,13 +354,13 @@
return WireFormatLite::k##DeclaredType##Size; \
}
-GET_FIXED_CACHED_SIZE(DOUBLE , Double)
-GET_FIXED_CACHED_SIZE(FLOAT , Float)
-GET_FIXED_CACHED_SIZE(FIXED64 , Fixed64)
-GET_FIXED_CACHED_SIZE(FIXED32 , Fixed32)
+GET_FIXED_CACHED_SIZE(DOUBLE, Double)
+GET_FIXED_CACHED_SIZE(FLOAT, Float)
+GET_FIXED_CACHED_SIZE(FIXED64, Fixed64)
+GET_FIXED_CACHED_SIZE(FIXED32, Fixed32)
GET_FIXED_CACHED_SIZE(SFIXED64, SFixed64)
GET_FIXED_CACHED_SIZE(SFIXED32, SFixed32)
-GET_FIXED_CACHED_SIZE(BOOL , Bool)
+GET_FIXED_CACHED_SIZE(BOOL, Bool)
#undef GET_FIXED_CACHED_SIZE
@@ -392,22 +391,22 @@
return WireFormatLite::Write##DeclaredType##ToArray(field, value, target); \
}
-WRITE_METHOD(STRING , String)
-WRITE_METHOD(BYTES , Bytes)
-WRITE_METHOD(INT64 , Int64)
-WRITE_METHOD(UINT64 , UInt64)
-WRITE_METHOD(INT32 , Int32)
-WRITE_METHOD(UINT32 , UInt32)
-WRITE_METHOD(SINT64 , SInt64)
-WRITE_METHOD(SINT32 , SInt32)
-WRITE_METHOD(ENUM , Enum)
-WRITE_METHOD(DOUBLE , Double)
-WRITE_METHOD(FLOAT , Float)
-WRITE_METHOD(FIXED64 , Fixed64)
-WRITE_METHOD(FIXED32 , Fixed32)
+WRITE_METHOD(STRING, String)
+WRITE_METHOD(BYTES, Bytes)
+WRITE_METHOD(INT64, Int64)
+WRITE_METHOD(UINT64, UInt64)
+WRITE_METHOD(INT32, Int32)
+WRITE_METHOD(UINT32, UInt32)
+WRITE_METHOD(SINT64, SInt64)
+WRITE_METHOD(SINT32, SInt32)
+WRITE_METHOD(ENUM, Enum)
+WRITE_METHOD(DOUBLE, Double)
+WRITE_METHOD(FLOAT, Float)
+WRITE_METHOD(FIXED64, Fixed64)
+WRITE_METHOD(FIXED32, Fixed32)
WRITE_METHOD(SFIXED64, SFixed64)
WRITE_METHOD(SFIXED32, SFixed32)
-WRITE_METHOD(BOOL , Bool)
+WRITE_METHOD(BOOL, Bool)
#undef WRITE_METHOD
@@ -554,8 +553,8 @@
template <typename Type>
inline const Type&
-MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
- Type>::GetExternalReference(const Type* value) {
+MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetExternalReference(
+ const Type* value) {
return *value;
}
@@ -578,10 +577,8 @@
}
template <typename Type>
inline void
-MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
- Type>::ClearMaybeByDefaultEnum(Type** value,
- Arena* /* arena */,
- int /* default_enum_value */) {
+MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::ClearMaybeByDefaultEnum(
+ Type** value, Arena* /* arena */, int /* default_enum_value */) {
if (*value != NULL) (*value)->Clear();
}
template <typename Type>
@@ -598,14 +595,13 @@
template <typename Type>
inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
- Type>::AssignDefaultValue(Type** value) {
+ Type>::AssignDefaultValue(Type** value) {
*value = const_cast<Type*>(Type::internal_default_instance());
}
template <typename Type>
-inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
- Type>::Initialize(Type** x,
- Arena* /* arena */) {
+inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Initialize(
+ Type** x, Arena* /* arena */) {
*x = NULL;
}
@@ -617,26 +613,26 @@
}
template <typename Type>
-inline Type* MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
- Type>::EnsureMutable(Type** value,
- Arena* arena) {
+inline Type* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::EnsureMutable(
+ Type** value, Arena* arena) {
if (*value == NULL) {
- *value =
- MapArenaMessageCreator<Type, Arena::is_arena_constructable<Type>::
- type::value>::CreateMessage(arena);
+ *value = MapArenaMessageCreator<
+ Type,
+ Arena::is_arena_constructable<Type>::type::value>::CreateMessage(arena);
}
return *value;
}
template <typename Type>
-inline const Type& MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::
- DefaultIfNotInitialized(const Type* value, const Type* default_value) {
+inline const Type&
+MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::DefaultIfNotInitialized(
+ const Type* value, const Type* default_value) {
return value != NULL ? *value : *default_value;
}
template <typename Type>
-inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
- Type>::IsInitialized(Type* value) {
+inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::IsInitialized(
+ Type* value) {
return value->IsInitialized();
}
@@ -730,82 +726,81 @@
STRING_OR_BYTES_HANDLER_FUNCTIONS(BYTES)
#undef STRING_OR_BYTES_HANDLER_FUNCTIONS
-#define PRIMITIVE_HANDLER_FUNCTIONS(FieldType) \
- template <typename Type> \
- inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
- Type>::MapEntryAccessorType& \
- MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
- Type>::GetExternalReference(const TypeOnMemory& value) { \
- return value; \
- } \
- template <typename Type> \
- inline size_t \
- MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
- Type>::SpaceUsedInMapEntryLong(const TypeOnMemory& /* value */) { \
- return 0; \
- } \
- template <typename Type> \
- inline size_t \
- MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::SpaceUsedInMapLong( \
- const TypeOnMemory& /* value */) { \
- return sizeof(Type); \
- } \
- template <typename Type> \
- inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear( \
- TypeOnMemory* value, Arena* /* arena */) { \
- *value = 0; \
- } \
- template <typename Type> \
- inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>:: \
- ClearMaybeByDefaultEnum(TypeOnMemory* value, Arena* /* arena */, \
- int default_enum_value) { \
- *value = static_cast<TypeOnMemory>(default_enum_value); \
- } \
- template <typename Type> \
- inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge( \
- const MapEntryAccessorType& from, TypeOnMemory* to, \
- Arena* /* arena */) { \
- *to = from; \
- } \
- template <typename Type> \
- inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
- Type>::DeleteNoArena(TypeOnMemory& /* x */) {} \
- template <typename Type> \
- inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
- Type>::AssignDefaultValue(TypeOnMemory* /* value */) {} \
- template <typename Type> \
- inline void \
- MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Initialize( \
- TypeOnMemory* value, Arena* /* arena */) { \
- *value = 0; \
- } \
- template <typename Type> \
- inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>:: \
- InitializeMaybeByDefaultEnum(TypeOnMemory* value, \
- int default_enum_value, \
- Arena* /* arena */) { \
- *value = static_cast<TypeOnMemory>(default_enum_value); \
- } \
- template <typename Type> \
- inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
- Type>::MapEntryAccessorType* \
- MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable( \
- TypeOnMemory* value, Arena* /* arena */) { \
- return value; \
- } \
- template <typename Type> \
- inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
- Type>::MapEntryAccessorType& \
- MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
- Type>::DefaultIfNotInitialized(const TypeOnMemory& value, \
- const TypeOnMemory& \
- /* default_value */) { \
- return value; \
- } \
- template <typename Type> \
- inline bool MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
- Type>::IsInitialized(const TypeOnMemory& /* value */) { \
- return true; \
+#define PRIMITIVE_HANDLER_FUNCTIONS(FieldType) \
+ template <typename Type> \
+ inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
+ Type>::MapEntryAccessorType& \
+ MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
+ Type>::GetExternalReference(const TypeOnMemory& value) { \
+ return value; \
+ } \
+ template <typename Type> \
+ inline size_t MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>:: \
+ SpaceUsedInMapEntryLong(const TypeOnMemory& /* value */) { \
+ return 0; \
+ } \
+ template <typename Type> \
+ inline size_t \
+ MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::SpaceUsedInMapLong( \
+ const TypeOnMemory& /* value */) { \
+ return sizeof(Type); \
+ } \
+ template <typename Type> \
+ inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear( \
+ TypeOnMemory* value, Arena* /* arena */) { \
+ *value = 0; \
+ } \
+ template <typename Type> \
+ inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>:: \
+ ClearMaybeByDefaultEnum(TypeOnMemory* value, Arena* /* arena */, \
+ int default_enum_value) { \
+ *value = static_cast<TypeOnMemory>(default_enum_value); \
+ } \
+ template <typename Type> \
+ inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge( \
+ const MapEntryAccessorType& from, TypeOnMemory* to, \
+ Arena* /* arena */) { \
+ *to = from; \
+ } \
+ template <typename Type> \
+ inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
+ Type>::DeleteNoArena(TypeOnMemory& /* x */) {} \
+ template <typename Type> \
+ inline void \
+ MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::AssignDefaultValue( \
+ TypeOnMemory* /* value */) {} \
+ template <typename Type> \
+ inline void \
+ MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Initialize( \
+ TypeOnMemory* value, Arena* /* arena */) { \
+ *value = 0; \
+ } \
+ template <typename Type> \
+ inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>:: \
+ InitializeMaybeByDefaultEnum( \
+ TypeOnMemory* value, int default_enum_value, Arena* /* arena */) { \
+ *value = static_cast<TypeOnMemory>(default_enum_value); \
+ } \
+ template <typename Type> \
+ inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
+ Type>::MapEntryAccessorType* \
+ MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable( \
+ TypeOnMemory* value, Arena* /* arena */) { \
+ return value; \
+ } \
+ template <typename Type> \
+ inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
+ Type>::MapEntryAccessorType& \
+ MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>:: \
+ DefaultIfNotInitialized(const TypeOnMemory& value, \
+ const TypeOnMemory& /* default_value */) { \
+ return value; \
+ } \
+ template <typename Type> \
+ inline bool \
+ MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::IsInitialized( \
+ const TypeOnMemory& /* value */) { \
+ return true; \
}
PRIMITIVE_HANDLER_FUNCTIONS(INT64)
PRIMITIVE_HANDLER_FUNCTIONS(UINT64)
diff --git a/src/google/protobuf/message.h b/src/google/protobuf/message.h
index 2528413..e274383 100644
--- a/src/google/protobuf/message.h
+++ b/src/google/protobuf/message.h
@@ -149,37 +149,37 @@
namespace internal {
class MapFieldBase;
}
-class UnknownFieldSet; // unknown_field_set.h
+class UnknownFieldSet; // unknown_field_set.h
namespace io {
-class ZeroCopyInputStream; // zero_copy_stream.h
-class ZeroCopyOutputStream; // zero_copy_stream.h
-class CodedInputStream; // coded_stream.h
-class CodedOutputStream; // coded_stream.h
-}
+class ZeroCopyInputStream; // zero_copy_stream.h
+class ZeroCopyOutputStream; // zero_copy_stream.h
+class CodedInputStream; // coded_stream.h
+class CodedOutputStream; // coded_stream.h
+} // namespace io
namespace python {
-class MapReflectionFriend; // scalar_map_container.h
+class MapReflectionFriend; // scalar_map_container.h
}
namespace expr {
class CelMapReflectionFriend; // field_backed_map_impl.cc
}
namespace internal {
-class MapFieldPrinterHelper; // text_format.cc
+class MapFieldPrinterHelper; // text_format.cc
}
namespace internal {
-class ReflectionAccessor; // message.cc
-class ReflectionOps; // reflection_ops.h
-class MapKeySorter; // wire_format.cc
-class WireFormat; // wire_format.h
+class ReflectionAccessor; // message.cc
+class ReflectionOps; // reflection_ops.h
+class MapKeySorter; // wire_format.cc
+class WireFormat; // wire_format.h
class MapFieldReflectionTest; // map_test.cc
-}
+} // namespace internal
-template<typename T>
-class RepeatedField; // repeated_field.h
+template <typename T>
+class RepeatedField; // repeated_field.h
-template<typename T>
+template <typename T>
class RepeatedPtrField; // repeated_field.h
// A container to hold message metadata.
@@ -342,7 +342,6 @@
virtual void SetCachedSize(int size) const;
public:
-
// Introspection ---------------------------------------------------
@@ -366,7 +365,7 @@
// Get a struct containing the metadata for the Message. Most subclasses only
// need to implement this method, rather than the GetDescriptor() and
// GetReflection() wrappers.
- virtual Metadata GetMetadata() const = 0;
+ virtual Metadata GetMetadata() const = 0;
private:
@@ -381,10 +380,10 @@
// Forward-declare RepeatedFieldRef templates. The second type parameter is
// used for SFINAE tricks. Users should ignore it.
-template<typename T, typename Enable = void>
+template <typename T, typename Enable = void>
class RepeatedFieldRef;
-template<typename T, typename Enable = void>
+template <typename T, typename Enable = void>
class MutableRepeatedFieldRef;
// This interface contains methods that can be used to dynamically access
@@ -499,16 +498,13 @@
virtual void Swap(Message* message1, Message* message2) const = 0;
// Swap fields listed in fields vector of two messages.
- virtual void SwapFields(Message* message1,
- Message* message2,
- const std::vector<const FieldDescriptor*>& fields)
- const = 0;
+ virtual void SwapFields(
+ Message* message1, Message* message2,
+ const std::vector<const FieldDescriptor*>& fields) const = 0;
// Swap two elements of a repeated field.
- virtual void SwapElements(Message* message,
- const FieldDescriptor* field,
- int index1,
- int index2) const = 0;
+ virtual void SwapElements(Message* message, const FieldDescriptor* field,
+ int index1, int index2) const = 0;
// List all fields of the message which are currently set, except for unknown
// fields, but including extension known to the parser (i.e. compiled in).
@@ -526,20 +522,20 @@
// These get the value of a non-repeated field. They return the default
// value for fields that aren't set.
- virtual int32 GetInt32 (const Message& message,
- const FieldDescriptor* field) const = 0;
- virtual int64 GetInt64 (const Message& message,
- const FieldDescriptor* field) const = 0;
+ virtual int32 GetInt32(const Message& message,
+ const FieldDescriptor* field) const = 0;
+ virtual int64 GetInt64(const Message& message,
+ const FieldDescriptor* field) const = 0;
virtual uint32 GetUInt32(const Message& message,
const FieldDescriptor* field) const = 0;
virtual uint64 GetUInt64(const Message& message,
const FieldDescriptor* field) const = 0;
- virtual float GetFloat (const Message& message,
- const FieldDescriptor* field) const = 0;
+ virtual float GetFloat(const Message& message,
+ const FieldDescriptor* field) const = 0;
virtual double GetDouble(const Message& message,
const FieldDescriptor* field) const = 0;
- virtual bool GetBool (const Message& message,
- const FieldDescriptor* field) const = 0;
+ virtual bool GetBool(const Message& message,
+ const FieldDescriptor* field) const = 0;
virtual std::string GetString(const Message& message,
const FieldDescriptor* field) const = 0;
virtual const EnumValueDescriptor* GetEnum(
@@ -550,8 +546,8 @@
// known value descriptor, a new value descriptor is created. (Such a value
// will only be present when the new unknown-enum-value semantics are enabled
// for a message.)
- virtual int GetEnumValue(
- const Message& message, const FieldDescriptor* field) const = 0;
+ virtual int GetEnumValue(const Message& message,
+ const FieldDescriptor* field) const = 0;
// See MutableMessage() for the meaning of the "factory" parameter.
virtual const Message& GetMessage(const Message& message,
@@ -581,25 +577,24 @@
// Singular field mutators -----------------------------------------
// These mutate the value of a non-repeated field.
- virtual void SetInt32 (Message* message,
- const FieldDescriptor* field, int32 value) const = 0;
- virtual void SetInt64 (Message* message,
- const FieldDescriptor* field, int64 value) const = 0;
- virtual void SetUInt32(Message* message,
- const FieldDescriptor* field, uint32 value) const = 0;
- virtual void SetUInt64(Message* message,
- const FieldDescriptor* field, uint64 value) const = 0;
- virtual void SetFloat (Message* message,
- const FieldDescriptor* field, float value) const = 0;
- virtual void SetDouble(Message* message,
- const FieldDescriptor* field, double value) const = 0;
- virtual void SetBool (Message* message,
- const FieldDescriptor* field, bool value) const = 0;
+ virtual void SetInt32(Message* message, const FieldDescriptor* field,
+ int32 value) const = 0;
+ virtual void SetInt64(Message* message, const FieldDescriptor* field,
+ int64 value) const = 0;
+ virtual void SetUInt32(Message* message, const FieldDescriptor* field,
+ uint32 value) const = 0;
+ virtual void SetUInt64(Message* message, const FieldDescriptor* field,
+ uint64 value) const = 0;
+ virtual void SetFloat(Message* message, const FieldDescriptor* field,
+ float value) const = 0;
+ virtual void SetDouble(Message* message, const FieldDescriptor* field,
+ double value) const = 0;
+ virtual void SetBool(Message* message, const FieldDescriptor* field,
+ bool value) const = 0;
virtual void SetString(Message* message, const FieldDescriptor* field,
const std::string& value) const = 0;
- virtual void SetEnum (Message* message,
- const FieldDescriptor* field,
- const EnumValueDescriptor* value) const = 0;
+ virtual void SetEnum(Message* message, const FieldDescriptor* field,
+ const EnumValueDescriptor* value) const = 0;
// Set an enum field's value with an integer rather than EnumValueDescriptor.
// For proto3 this is just setting the enum field to the value specified, for
// proto2 it's more complicated. If value is a known enum value the field is
@@ -607,8 +602,7 @@
// set. Note this matches the behavior of parsing unknown enum values.
// If multiple calls with unknown values happen than they are all added to the
// unknown field set in order of the calls.
- virtual void SetEnumValue(Message* message,
- const FieldDescriptor* field,
+ virtual void SetEnumValue(Message* message, const FieldDescriptor* field,
int value) const = 0;
// Get a mutable pointer to a field with a message type. If a MessageFactory
@@ -628,8 +622,7 @@
// sub_message, passing ownership to the message. If the field contained a
// message, that message is deleted. If sub_message is NULL, the field is
// cleared.
- virtual void SetAllocatedMessage(Message* message,
- Message* sub_message,
+ virtual void SetAllocatedMessage(Message* message, Message* sub_message,
const FieldDescriptor* field) const = 0;
// Releases the message specified by 'field' and returns the pointer,
// ReleaseMessage() will return the message the message object if it exists.
@@ -646,44 +639,44 @@
// Repeated field getters ------------------------------------------
// These get the value of one element of a repeated field.
- virtual int32 GetRepeatedInt32 (const Message& message,
- const FieldDescriptor* field,
- int index) const = 0;
- virtual int64 GetRepeatedInt64 (const Message& message,
- const FieldDescriptor* field,
- int index) const = 0;
+ virtual int32 GetRepeatedInt32(const Message& message,
+ const FieldDescriptor* field,
+ int index) const = 0;
+ virtual int64 GetRepeatedInt64(const Message& message,
+ const FieldDescriptor* field,
+ int index) const = 0;
virtual uint32 GetRepeatedUInt32(const Message& message,
const FieldDescriptor* field,
int index) const = 0;
virtual uint64 GetRepeatedUInt64(const Message& message,
const FieldDescriptor* field,
int index) const = 0;
- virtual float GetRepeatedFloat (const Message& message,
- const FieldDescriptor* field,
- int index) const = 0;
+ virtual float GetRepeatedFloat(const Message& message,
+ const FieldDescriptor* field,
+ int index) const = 0;
virtual double GetRepeatedDouble(const Message& message,
const FieldDescriptor* field,
int index) const = 0;
- virtual bool GetRepeatedBool (const Message& message,
- const FieldDescriptor* field,
- int index) const = 0;
+ virtual bool GetRepeatedBool(const Message& message,
+ const FieldDescriptor* field,
+ int index) const = 0;
virtual std::string GetRepeatedString(const Message& message,
const FieldDescriptor* field,
int index) const = 0;
virtual const EnumValueDescriptor* GetRepeatedEnum(
- const Message& message,
- const FieldDescriptor* field, int index) const = 0;
+ const Message& message, const FieldDescriptor* field,
+ int index) const = 0;
// GetRepeatedEnumValue() returns an enum field's value as an integer rather
// than an EnumValueDescriptor*. If the integer value does not correspond to a
// known value descriptor, a new value descriptor is created. (Such a value
// will only be present when the new unknown-enum-value semantics are enabled
// for a message.)
- virtual int GetRepeatedEnumValue(
- const Message& message,
- const FieldDescriptor* field, int index) const = 0;
- virtual const Message& GetRepeatedMessage(
- const Message& message,
- const FieldDescriptor* field, int index) const = 0;
+ virtual int GetRepeatedEnumValue(const Message& message,
+ const FieldDescriptor* field,
+ int index) const = 0;
+ virtual const Message& GetRepeatedMessage(const Message& message,
+ const FieldDescriptor* field,
+ int index) const = 0;
// See GetStringReference(), above.
virtual const std::string& GetRepeatedStringReference(
@@ -694,31 +687,24 @@
// Repeated field mutators -----------------------------------------
// These mutate the value of one element of a repeated field.
- virtual void SetRepeatedInt32 (Message* message,
- const FieldDescriptor* field,
- int index, int32 value) const = 0;
- virtual void SetRepeatedInt64 (Message* message,
- const FieldDescriptor* field,
- int index, int64 value) const = 0;
- virtual void SetRepeatedUInt32(Message* message,
- const FieldDescriptor* field,
+ virtual void SetRepeatedInt32(Message* message, const FieldDescriptor* field,
+ int index, int32 value) const = 0;
+ virtual void SetRepeatedInt64(Message* message, const FieldDescriptor* field,
+ int index, int64 value) const = 0;
+ virtual void SetRepeatedUInt32(Message* message, const FieldDescriptor* field,
int index, uint32 value) const = 0;
- virtual void SetRepeatedUInt64(Message* message,
- const FieldDescriptor* field,
+ virtual void SetRepeatedUInt64(Message* message, const FieldDescriptor* field,
int index, uint64 value) const = 0;
- virtual void SetRepeatedFloat (Message* message,
- const FieldDescriptor* field,
- int index, float value) const = 0;
- virtual void SetRepeatedDouble(Message* message,
- const FieldDescriptor* field,
+ virtual void SetRepeatedFloat(Message* message, const FieldDescriptor* field,
+ int index, float value) const = 0;
+ virtual void SetRepeatedDouble(Message* message, const FieldDescriptor* field,
int index, double value) const = 0;
- virtual void SetRepeatedBool (Message* message,
- const FieldDescriptor* field,
- int index, bool value) const = 0;
+ virtual void SetRepeatedBool(Message* message, const FieldDescriptor* field,
+ int index, bool value) const = 0;
virtual void SetRepeatedString(Message* message, const FieldDescriptor* field,
int index, const std::string& value) const = 0;
- virtual void SetRepeatedEnum(Message* message,
- const FieldDescriptor* field, int index,
+ virtual void SetRepeatedEnum(Message* message, const FieldDescriptor* field,
+ int index,
const EnumValueDescriptor* value) const = 0;
// Set an enum field's value with an integer rather than EnumValueDescriptor.
// For proto3 this is just setting the enum field to the value specified, for
@@ -732,32 +718,32 @@
int value) const = 0;
// Get a mutable pointer to an element of a repeated field with a message
// type.
- virtual Message* MutableRepeatedMessage(
- Message* message, const FieldDescriptor* field, int index) const = 0;
+ virtual Message* MutableRepeatedMessage(Message* message,
+ const FieldDescriptor* field,
+ int index) const = 0;
// Repeated field adders -------------------------------------------
// These add an element to a repeated field.
- virtual void AddInt32 (Message* message,
- const FieldDescriptor* field, int32 value) const = 0;
- virtual void AddInt64 (Message* message,
- const FieldDescriptor* field, int64 value) const = 0;
- virtual void AddUInt32(Message* message,
- const FieldDescriptor* field, uint32 value) const = 0;
- virtual void AddUInt64(Message* message,
- const FieldDescriptor* field, uint64 value) const = 0;
- virtual void AddFloat (Message* message,
- const FieldDescriptor* field, float value) const = 0;
- virtual void AddDouble(Message* message,
- const FieldDescriptor* field, double value) const = 0;
- virtual void AddBool (Message* message,
- const FieldDescriptor* field, bool value) const = 0;
+ virtual void AddInt32(Message* message, const FieldDescriptor* field,
+ int32 value) const = 0;
+ virtual void AddInt64(Message* message, const FieldDescriptor* field,
+ int64 value) const = 0;
+ virtual void AddUInt32(Message* message, const FieldDescriptor* field,
+ uint32 value) const = 0;
+ virtual void AddUInt64(Message* message, const FieldDescriptor* field,
+ uint64 value) const = 0;
+ virtual void AddFloat(Message* message, const FieldDescriptor* field,
+ float value) const = 0;
+ virtual void AddDouble(Message* message, const FieldDescriptor* field,
+ double value) const = 0;
+ virtual void AddBool(Message* message, const FieldDescriptor* field,
+ bool value) const = 0;
virtual void AddString(Message* message, const FieldDescriptor* field,
const std::string& value) const = 0;
- virtual void AddEnum (Message* message,
- const FieldDescriptor* field,
- const EnumValueDescriptor* value) const = 0;
+ virtual void AddEnum(Message* message, const FieldDescriptor* field,
+ const EnumValueDescriptor* value) const = 0;
// Add an integer value to a repeated enum field rather than
// EnumValueDescriptor. For proto3 this is just setting the enum field to the
// value specified, for proto2 it's more complicated. If value is a known enum
@@ -765,12 +751,10 @@
// to the unknown field set. Note this matches the behavior of parsing unknown
// enum values. If multiple calls with unknown values happen than they are all
// added to the unknown field set in order of the calls.
- virtual void AddEnumValue(Message* message,
- const FieldDescriptor* field,
+ virtual void AddEnumValue(Message* message, const FieldDescriptor* field,
int value) const = 0;
// See MutableMessage() for comments on the "factory" parameter.
- virtual Message* AddMessage(Message* message,
- const FieldDescriptor* field,
+ virtual Message* AddMessage(Message* message, const FieldDescriptor* field,
MessageFactory* factory = NULL) const = 0;
// Appends an already-allocated object 'new_entry' to the repeated field
@@ -806,13 +790,13 @@
// Note that to use this method users need to include the header file
// "net/proto2/public/reflection.h" (which defines the RepeatedFieldRef
// class templates).
- template<typename T>
- RepeatedFieldRef<T> GetRepeatedFieldRef(
- const Message& message, const FieldDescriptor* field) const;
+ template <typename T>
+ RepeatedFieldRef<T> GetRepeatedFieldRef(const Message& message,
+ const FieldDescriptor* field) const;
// Like GetRepeatedFieldRef() but return an object that can also be used
// manipulate the underlying repeated field.
- template<typename T>
+ template <typename T>
MutableRepeatedFieldRef<T> GetMutableRepeatedFieldRef(
Message* message, const FieldDescriptor* field) const;
@@ -936,8 +920,8 @@
const Message& message, const FieldDescriptor* field,
FieldDescriptor::CppType cpptype, int ctype,
const Descriptor* message_type) const {
- return MutableRawRepeatedField(
- const_cast<Message*>(&message), field, cpptype, ctype, message_type);
+ return MutableRawRepeatedField(const_cast<Message*>(&message), field,
+ cpptype, ctype, message_type);
}
// The following methods are used to implement (Mutable)RepeatedFieldRef.
@@ -956,10 +940,10 @@
// "cpp_type"/"message_type" is consistent with the actual type of the field.
// We use 1 routine rather than 2 (const vs mutable) because it is protected
// and it doesn't change the message.
- virtual void* RepeatedFieldData(
- Message* message, const FieldDescriptor* field,
- FieldDescriptor::CppType cpp_type,
- const Descriptor* message_type) const;
+ virtual void* RepeatedFieldData(Message* message,
+ const FieldDescriptor* field,
+ FieldDescriptor::CppType cpp_type,
+ const Descriptor* message_type) const;
// The returned pointer should point to a singleton instance which implements
// the RepeatedFieldAccessor interface.
@@ -967,9 +951,9 @@
const FieldDescriptor* field) const;
private:
- template<typename T, typename Enable>
+ template <typename T, typename Enable>
friend class RepeatedFieldRef;
- template<typename T, typename Enable>
+ template <typename T, typename Enable>
friend class MutableRepeatedFieldRef;
friend class python::MapReflectionFriend;
#define GOOGLE_PROTOBUF_HAS_CEL_MAP_REFLECTION_FRIEND
@@ -988,8 +972,8 @@
// file here is not possible because it would cause a circular include cycle.
// We use 1 routine rather than 2 (const vs mutable) because it is private
// and mutable a repeated string field doesn't change the message.
- void* MutableRawRepeatedString(
- Message* message, const FieldDescriptor* field, bool is_string) const;
+ void* MutableRawRepeatedString(Message* message, const FieldDescriptor* field,
+ bool is_string) const;
friend class MapReflectionTester;
// TODO(jieluo) - make the map APIs pure virtual after updating
@@ -1022,16 +1006,14 @@
// Returns a MapIterator referring to the first element in the map field.
// If the map field is empty, this function returns the same as
// reflection::MapEnd. Mutation to the field may invalidate the iterator.
- virtual MapIterator MapBegin(
- Message* message,
- const FieldDescriptor* field) const;
+ virtual MapIterator MapBegin(Message* message,
+ const FieldDescriptor* field) const;
// Returns a MapIterator referring to the theoretical element that would
// follow the last element in the map field. It does not point to any
// real element. Mutation to the field may invalidate the iterator.
- virtual MapIterator MapEnd(
- Message* message,
- const FieldDescriptor* field) const;
+ virtual MapIterator MapEnd(Message* message,
+ const FieldDescriptor* field) const;
// Get the number of <key, value> pair of a map field. The result may be
// different from FieldSize which can have duplicate keys.
@@ -1150,7 +1132,7 @@
const T* DynamicCastToGenerated(const Message* from) {
// Compile-time assert that T is a generated type that has a
// default_instance() accessor, but avoid actually calling it.
- const T&(*get_default_instance)() = &T::default_instance;
+ const T& (*get_default_instance)() = &T::default_instance;
(void)get_default_instance;
// Compile-time assert that T is a subclass of google::protobuf::Message.
@@ -1239,38 +1221,34 @@
// -----
-template<>
+template <>
inline const RepeatedPtrField<Message>& Reflection::GetRepeatedPtrField(
const Message& message, const FieldDescriptor* field) const {
- return *static_cast<const RepeatedPtrField<Message>* >(
- GetRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE,
- -1, NULL));
+ return *static_cast<const RepeatedPtrField<Message>*>(GetRawRepeatedField(
+ message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, NULL));
}
-template<>
+template <>
inline RepeatedPtrField<Message>* Reflection::MutableRepeatedPtrField(
Message* message, const FieldDescriptor* field) const {
- return static_cast<RepeatedPtrField<Message>* >(
- MutableRawRepeatedField(message, field,
- FieldDescriptor::CPPTYPE_MESSAGE, -1,
- NULL));
+ return static_cast<RepeatedPtrField<Message>*>(MutableRawRepeatedField(
+ message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, NULL));
}
-template<typename PB>
+template <typename PB>
inline const RepeatedPtrField<PB>& Reflection::GetRepeatedPtrField(
const Message& message, const FieldDescriptor* field) const {
- return *static_cast<const RepeatedPtrField<PB>* >(
- GetRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE,
- -1, PB::default_instance().GetDescriptor()));
+ return *static_cast<const RepeatedPtrField<PB>*>(
+ GetRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1,
+ PB::default_instance().GetDescriptor()));
}
-template<typename PB>
+template <typename PB>
inline RepeatedPtrField<PB>* Reflection::MutableRepeatedPtrField(
Message* message, const FieldDescriptor* field) const {
- return static_cast<RepeatedPtrField<PB>* >(
- MutableRawRepeatedField(message, field,
- FieldDescriptor::CPPTYPE_MESSAGE, -1,
- PB::default_instance().GetDescriptor()));
+ return static_cast<RepeatedPtrField<PB>*>(
+ MutableRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE,
+ -1, PB::default_instance().GetDescriptor()));
}
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/message_lite.cc b/src/google/protobuf/message_lite.cc
index f531a7c..e8f1344 100644
--- a/src/google/protobuf/message_lite.cc
+++ b/src/google/protobuf/message_lite.cc
@@ -147,13 +147,13 @@
template <bool aliasing>
bool MergePartialFromImpl(BoundedZCIS input, MessageLite* msg) {
- // We must prevent reading more than limit from the input. Due to the nature
- // of EpsCopyInputStream the stream will always read kSlopBytes ahead of
- // the parser, we can't always backup so we must prevent from reading past
- // limit in the first place.
- io::LimitingInputStream zcis(input.zcis, input.limit);
- return MergePartialFromImpl<aliasing>(&zcis, msg) &&
- zcis.ByteCount() == input.limit;
+ const char* ptr;
+ internal::ParseContext ctx(io::CodedInputStream::GetDefaultRecursionLimit(),
+ aliasing, &ptr, input.zcis, input.limit);
+ ptr = msg->_InternalParse(ptr, &ctx);
+ if (PROTOBUF_PREDICT_FALSE(!ptr)) return false;
+ ctx.BackUp(ptr);
+ return ctx.EndedAtLimit();
}
#else // !GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
@@ -276,8 +276,8 @@
return ParseFrom<kParsePartial>(input);
}
-bool MessageLite::MergePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input,
- int size) {
+bool MessageLite::MergePartialFromBoundedZeroCopyStream(
+ io::ZeroCopyInputStream* input, int size) {
return ParseFrom<kMergePartial>(internal::BoundedZCIS{input, size});
}
diff --git a/src/google/protobuf/message_lite.h b/src/google/protobuf/message_lite.h
index 8deb143..bc5d4c7 100644
--- a/src/google/protobuf/message_lite.h
+++ b/src/google/protobuf/message_lite.h
@@ -122,13 +122,9 @@
template <typename T>
class ExplicitlyConstructed {
public:
- void DefaultConstruct() {
- new (&union_) T();
- }
+ void DefaultConstruct() { new (&union_) T(); }
- void Destruct() {
- get_mutable()->~T();
- }
+ void Destruct() { get_mutable()->~T(); }
constexpr const T& get() const { return reinterpret_cast<const T&>(union_); }
T* get_mutable() { return reinterpret_cast<T*>(&union_); }
@@ -244,9 +240,7 @@
// The format of the returned string is subject to change, so please do not
// assume it will remain stable over time.
std::string DebugString() const;
- std::string ShortDebugString() const {
- return DebugString();
- }
+ std::string ShortDebugString() const { return DebugString(); }
// Parsing ---------------------------------------------------------
// Methods for parsing in protocol buffer format. Most of these are
@@ -271,11 +265,11 @@
// Read a protocol buffer from the given zero-copy input stream, expecting
// the message to be exactly "size" bytes long. If successful, exactly
// this many bytes will have been consumed from the input.
- bool MergePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);
+ bool MergePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input,
+ int size);
// Like ParseFromBoundedZeroCopyStream(), but accepts messages that are
// missing required fields.
- bool MergeFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input,
- int size);
+ bool MergeFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);
bool ParseFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);
// Like ParseFromBoundedZeroCopyStream(), but accepts messages that are
// missing required fields.
@@ -316,7 +310,7 @@
// MergeFromCodedStream() is just implemented as MergePartialFromCodedStream()
// followed by IsInitialized().
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
- virtual bool MergePartialFromCodedStream(io::CodedInputStream* input);
+ bool MergePartialFromCodedStream(io::CodedInputStream* input);
#else
virtual bool MergePartialFromCodedStream(io::CodedInputStream* input) = 0;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
@@ -376,15 +370,12 @@
// Legacy ByteSize() API.
PROTOBUF_DEPRECATED_MSG("Please use ByteSizeLong() instead")
- int ByteSize() const {
- return internal::ToIntSize(ByteSizeLong());
- }
+ int ByteSize() const { return internal::ToIntSize(ByteSizeLong()); }
// Serializes the message without recomputing the size. The message must not
// have changed since the last call to ByteSize(), and the value returned by
// ByteSize must be non-negative. Otherwise the results are undefined.
- virtual void SerializeWithCachedSizes(
- io::CodedOutputStream* output) const;
+ virtual void SerializeWithCachedSizes(io::CodedOutputStream* output) const;
// Functions below here are not part of the public interface. It isn't
// enforced, but they should be treated as private, and will be private
diff --git a/src/google/protobuf/message_unittest.inc b/src/google/protobuf/message_unittest.inc
index d61ca7d..0cd46d4 100644
--- a/src/google/protobuf/message_unittest.inc
+++ b/src/google/protobuf/message_unittest.inc
@@ -60,7 +60,8 @@
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
-#include <google/protobuf/stubs/io_win32.h>
+
+#include <google/protobuf/io/io_win32.h>
namespace google {
namespace protobuf {
@@ -68,8 +69,8 @@
#if defined(_WIN32)
// DO NOT include <io.h>, instead create functions in io_win32.{h,cc} and import
// them like we do below.
-using google::protobuf::internal::win32::close;
-using google::protobuf::internal::win32::open;
+using google::protobuf::io::win32::close;
+using google::protobuf::io::win32::open;
#endif
#ifndef O_BINARY
diff --git a/src/google/protobuf/metadata.h b/src/google/protobuf/metadata.h
index 928bbf5..009a7e9 100644
--- a/src/google/protobuf/metadata.h
+++ b/src/google/protobuf/metadata.h
@@ -56,19 +56,15 @@
InternalMetadataWithArena() {}
explicit InternalMetadataWithArena(Arena* arena)
: InternalMetadataWithArenaBase<UnknownFieldSet,
- InternalMetadataWithArena>(arena) {}
+ InternalMetadataWithArena>(arena) {}
- void DoSwap(UnknownFieldSet* other) {
- mutable_unknown_fields()->Swap(other);
- }
+ void DoSwap(UnknownFieldSet* other) { mutable_unknown_fields()->Swap(other); }
void DoMergeFrom(const UnknownFieldSet& other) {
mutable_unknown_fields()->MergeFrom(other);
}
- void DoClear() {
- mutable_unknown_fields()->Clear();
- }
+ void DoClear() { mutable_unknown_fields()->Clear(); }
static const UnknownFieldSet& default_instance() {
return *UnknownFieldSet::default_instance();
diff --git a/src/google/protobuf/metadata_lite.h b/src/google/protobuf/metadata_lite.h
index e0aa52b..40c7ea7 100644
--- a/src/google/protobuf/metadata_lite.h
+++ b/src/google/protobuf/metadata_lite.h
@@ -143,9 +143,10 @@
return reinterpret_cast<intptr_t>(ptr_) & kPtrTagMask;
}
- template<typename U> U* PtrValue() const {
- return reinterpret_cast<U*>(
- reinterpret_cast<intptr_t>(ptr_) & kPtrValueMask);
+ template <typename U>
+ U* PtrValue() const {
+ return reinterpret_cast<U*>(reinterpret_cast<intptr_t>(ptr_) &
+ kPtrValueMask);
}
// If ptr_'s tag is kTagContainer, it points to an instance of this struct.
@@ -160,8 +161,8 @@
// Two-step assignment works around a bug in clang's static analyzer:
// https://bugs.llvm.org/show_bug.cgi?id=34198.
ptr_ = container;
- ptr_ = reinterpret_cast<void*>(
- reinterpret_cast<intptr_t>(ptr_) | kTagContainer);
+ ptr_ = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(ptr_) |
+ kTagContainer);
container->arena = my_arena;
return &(container->unknown_fields);
}
@@ -187,9 +188,7 @@
mutable_unknown_fields()->append(other);
}
- void DoClear() {
- mutable_unknown_fields()->clear();
- }
+ void DoClear() { mutable_unknown_fields()->clear(); }
static const std::string& default_instance() {
// Can't use GetEmptyStringAlreadyInited() here because empty string
diff --git a/src/google/protobuf/no_field_presence_test.cc b/src/google/protobuf/no_field_presence_test.cc
index 9645d3a..8b05277 100644
--- a/src/google/protobuf/no_field_presence_test.cc
+++ b/src/google/protobuf/no_field_presence_test.cc
@@ -30,8 +30,8 @@
#include <string>
-#include <google/protobuf/unittest_no_field_presence.pb.h>
#include <google/protobuf/unittest.pb.h>
+#include <google/protobuf/unittest_no_field_presence.pb.h>
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/descriptor.h>
#include <gtest/gtest.h>
@@ -120,8 +120,7 @@
m->mutable_optional_proto2_message()->set_optional_int32(44);
m->set_optional_nested_enum(
proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum_BAZ);
- m->set_optional_foreign_enum(
- proto2_nofieldpresence_unittest::FOREIGN_BAZ);
+ m->set_optional_foreign_enum(proto2_nofieldpresence_unittest::FOREIGN_BAZ);
m->mutable_optional_lazy_message()->set_bb(45);
m->add_repeated_int32(100);
m->add_repeated_int64(101);
@@ -143,8 +142,7 @@
m->add_repeated_proto2_message()->set_optional_int32(48);
m->add_repeated_nested_enum(
proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum_BAZ);
- m->add_repeated_foreign_enum(
- proto2_nofieldpresence_unittest::FOREIGN_BAZ);
+ m->add_repeated_foreign_enum(proto2_nofieldpresence_unittest::FOREIGN_BAZ);
m->add_repeated_lazy_message()->set_bb(49);
m->set_oneof_uint32(1);
@@ -153,7 +151,7 @@
}
void CheckNonDefaultValues(
-const proto2_nofieldpresence_unittest::TestAllTypes& m) {
+ const proto2_nofieldpresence_unittest::TestAllTypes& m) {
EXPECT_EQ(100, m.optional_int32());
EXPECT_EQ(101, m.optional_int64());
EXPECT_EQ(102, m.optional_uint32());
@@ -271,8 +269,9 @@
EXPECT_EQ(false, message.has_optional_lazy_message());
// Test field presence of a message field on the default instance.
- EXPECT_EQ(false, proto2_nofieldpresence_unittest::TestAllTypes::
- default_instance().has_optional_nested_message());
+ EXPECT_EQ(false,
+ proto2_nofieldpresence_unittest::TestAllTypes::default_instance()
+ .has_optional_nested_message());
}
TEST(NoFieldPresenceTest, ReflectionHasFieldTest) {
@@ -294,9 +293,11 @@
// Test field presence of a message field on the default instance.
const FieldDescriptor* msg_field =
desc->FindFieldByName("optional_nested_message");
- EXPECT_EQ(false, r->HasField(
- proto2_nofieldpresence_unittest::TestAllTypes::
- default_instance(), msg_field));
+ EXPECT_EQ(
+ false,
+ r->HasField(
+ proto2_nofieldpresence_unittest::TestAllTypes::default_instance(),
+ msg_field));
// Fill all fields, expect everything to report true (check oneofs below).
FillValues(&message);
@@ -441,7 +442,8 @@
message.set_optional_string("");
message.set_optional_bytes("");
message.set_optional_nested_enum(
- proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum_FOO); // first enum entry
+ proto2_nofieldpresence_unittest::
+ TestAllTypes_NestedEnum_FOO); // first enum entry
message.set_optional_foreign_enum(
proto2_nofieldpresence_unittest::FOREIGN_FOO); // first enum entry
@@ -554,8 +556,9 @@
message.oneof_field_case());
message.Clear();
- message.set_oneof_enum(proto2_nofieldpresence_unittest::
- TestAllTypes_NestedEnum_FOO); // default value.
+ message.set_oneof_enum(
+ proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum_FOO); // default
+ // value.
message.SerializeToString(&serialized);
EXPECT_EQ(3, serialized.size());
EXPECT_TRUE(message.ParseFromString(serialized));
@@ -571,4 +574,3 @@
} // namespace
} // namespace protobuf
} // namespace google
-
diff --git a/src/google/protobuf/parse_context.cc b/src/google/protobuf/parse_context.cc
index 2aec32e..9efa521 100644
--- a/src/google/protobuf/parse_context.cc
+++ b/src/google/protobuf/parse_context.cc
@@ -82,8 +82,8 @@
d++;
break;
}
- case 4: { // end group
- if (--d < 0) return true; // We exit early
+ case 4: { // end group
+ if (--d < 0) return true; // We exit early
break;
}
case 5: { // fixed32
@@ -114,11 +114,13 @@
// Note we must use memmove because the previous buffer could be part of
// buffer_.
std::memmove(buffer_, buffer_end_, kSlopBytes);
- if (zcis_ && (d < 0 || !ParseEndsInSlopRegion(buffer_, overrun, d))) {
+ if (overall_limit_ > 0 &&
+ (d < 0 || !ParseEndsInSlopRegion(buffer_, overrun, d))) {
const void* data;
// ZeroCopyInputStream indicates Next may return 0 size buffers. Hence
// we loop.
while (zcis_->Next(&data, &size_)) {
+ overall_limit_ -= size_;
if (size_ > kSlopBytes) {
// We got a large chunk
std::memcpy(buffer_ + kSlopBytes, data, kSlopBytes);
@@ -135,6 +137,7 @@
}
GOOGLE_DCHECK(size_ == 0) << size_;
}
+ overall_limit_ = 0; // Next failed, no more needs for next
}
// End of stream or array
if (aliasing_ == kNoDelta) {
@@ -260,6 +263,7 @@
int size;
limit_ = INT_MAX;
if (zcis->Next(&data, &size)) {
+ overall_limit_ -= size;
if (size > kSlopBytes) {
auto ptr = static_cast<const char*>(data);
limit_ -= size - kSlopBytes;
@@ -275,6 +279,7 @@
return ptr;
}
}
+ overall_limit_ = 0;
next_chunk_ = nullptr;
size_ = 0;
limit_end_ = buffer_end_ = buffer_;
@@ -322,7 +327,8 @@
return {nullptr, 0};
}
-std::pair<const char*, uint64> ParseVarint64Fallback(const char* p, uint64 res) {
+std::pair<const char*, uint64> ParseVarint64Fallback(const char* p,
+ uint64 res) {
return ParseVarint64FallbackInline(p, res);
}
diff --git a/src/google/protobuf/parse_context.h b/src/google/protobuf/parse_context.h
index 1bf6100..81b9406 100644
--- a/src/google/protobuf/parse_context.h
+++ b/src/google/protobuf/parse_context.h
@@ -190,6 +190,9 @@
return ptr > limit_end_ &&
(next_chunk_ == nullptr || ptr - buffer_end_ > limit_);
}
+ // Returns true if more data is available, if false is returned one has to
+ // call Done for further checks.
+ bool DataAvailable(const char* ptr) { return ptr < limit_end_; }
protected:
// Returns true is limit (either an explicit limit or end of stream) is
@@ -206,6 +209,7 @@
}
const char* InitFrom(StringPiece flat) {
+ overall_limit_ = 0;
if (flat.size() > kSlopBytes) {
limit_ = kSlopBytes;
limit_end_ = buffer_end_ = flat.end() - kSlopBytes;
@@ -228,6 +232,7 @@
const char* InitFrom(io::ZeroCopyInputStream* zcis);
const char* InitFrom(io::ZeroCopyInputStream* zcis, int limit) {
+ overall_limit_ = limit;
auto res = InitFrom(zcis);
limit_ = limit - static_cast<int>(buffer_end_ - res);
limit_end_ = buffer_end_ + (std::min)(0, limit_);
@@ -258,6 +263,7 @@
// the ParseContext, but case 2 is most easily and optimally implemented in
// DoneFallback.
uint32 last_tag_minus_1_ = 0;
+ int overall_limit_ = INT_MAX; // Overall limit independent of pushed limits.
std::pair<const char*, bool> DoneFallback(const char* ptr, int d);
const char* Next(int overrun, int d);
diff --git a/src/google/protobuf/preserve_unknown_enum_test.cc b/src/google/protobuf/preserve_unknown_enum_test.cc
index 94addc4..1ac4e13 100644
--- a/src/google/protobuf/preserve_unknown_enum_test.cc
+++ b/src/google/protobuf/preserve_unknown_enum_test.cc
@@ -31,8 +31,8 @@
#include <google/protobuf/unittest.pb.h>
#include <google/protobuf/unittest_preserve_unknown_enum.pb.h>
#include <google/protobuf/unittest_preserve_unknown_enum2.pb.h>
-#include <google/protobuf/dynamic_message.h>
#include <google/protobuf/descriptor.h>
+#include <google/protobuf/dynamic_message.h>
#include <gtest/gtest.h>
namespace google {
@@ -41,22 +41,18 @@
void FillMessage(
proto3_preserve_unknown_enum_unittest::MyMessagePlusExtra* message) {
- message->set_e(
- proto3_preserve_unknown_enum_unittest::E_EXTRA);
- message->add_repeated_e(
- proto3_preserve_unknown_enum_unittest::E_EXTRA);
+ message->set_e(proto3_preserve_unknown_enum_unittest::E_EXTRA);
+ message->add_repeated_e(proto3_preserve_unknown_enum_unittest::E_EXTRA);
message->add_repeated_packed_e(
proto3_preserve_unknown_enum_unittest::E_EXTRA);
message->add_repeated_packed_unexpected_e(
proto3_preserve_unknown_enum_unittest::E_EXTRA);
- message->set_oneof_e_1(
- proto3_preserve_unknown_enum_unittest::E_EXTRA);
+ message->set_oneof_e_1(proto3_preserve_unknown_enum_unittest::E_EXTRA);
}
void CheckMessage(
const proto3_preserve_unknown_enum_unittest::MyMessagePlusExtra& message) {
- EXPECT_EQ(proto3_preserve_unknown_enum_unittest::E_EXTRA,
- message.e());
+ EXPECT_EQ(proto3_preserve_unknown_enum_unittest::E_EXTRA, message.e());
EXPECT_EQ(1, message.repeated_e_size());
EXPECT_EQ(proto3_preserve_unknown_enum_unittest::E_EXTRA,
message.repeated_e(0));
@@ -72,23 +68,18 @@
void CheckMessage(
const proto3_preserve_unknown_enum_unittest::MyMessage& message) {
- EXPECT_EQ(static_cast<int>(
- proto3_preserve_unknown_enum_unittest::E_EXTRA),
+ EXPECT_EQ(static_cast<int>(proto3_preserve_unknown_enum_unittest::E_EXTRA),
static_cast<int>(message.e()));
EXPECT_EQ(1, message.repeated_e_size());
- EXPECT_EQ(static_cast<int>(
- proto3_preserve_unknown_enum_unittest::E_EXTRA),
+ EXPECT_EQ(static_cast<int>(proto3_preserve_unknown_enum_unittest::E_EXTRA),
static_cast<int>(message.repeated_e(0)));
EXPECT_EQ(1, message.repeated_packed_e_size());
- EXPECT_EQ(static_cast<int>(
- proto3_preserve_unknown_enum_unittest::E_EXTRA),
+ EXPECT_EQ(static_cast<int>(proto3_preserve_unknown_enum_unittest::E_EXTRA),
static_cast<int>(message.repeated_packed_e(0)));
EXPECT_EQ(1, message.repeated_packed_unexpected_e_size());
- EXPECT_EQ(static_cast<int>(
- proto3_preserve_unknown_enum_unittest::E_EXTRA),
+ EXPECT_EQ(static_cast<int>(proto3_preserve_unknown_enum_unittest::E_EXTRA),
static_cast<int>(message.repeated_packed_unexpected_e(0)));
- EXPECT_EQ(static_cast<int>(
- proto3_preserve_unknown_enum_unittest::E_EXTRA),
+ EXPECT_EQ(static_cast<int>(proto3_preserve_unknown_enum_unittest::E_EXTRA),
static_cast<int>(message.oneof_e_1()));
}
diff --git a/src/google/protobuf/proto3_arena_lite_unittest.cc b/src/google/protobuf/proto3_arena_lite_unittest.cc
index 9c6d166..e269370 100644
--- a/src/google/protobuf/proto3_arena_lite_unittest.cc
+++ b/src/google/protobuf/proto3_arena_lite_unittest.cc
@@ -52,8 +52,7 @@
m->mutable_optional_foreign_message()->set_c(43);
m->set_optional_nested_enum(
proto3_arena_unittest::TestAllTypes_NestedEnum_BAZ);
- m->set_optional_foreign_enum(
- proto3_arena_unittest::FOREIGN_BAZ);
+ m->set_optional_foreign_enum(proto3_arena_unittest::FOREIGN_BAZ);
m->mutable_optional_lazy_message()->set_bb(45);
m->add_repeated_int32(100);
m->add_repeated_string("asdf");
@@ -62,8 +61,7 @@
m->add_repeated_foreign_message()->set_c(47);
m->add_repeated_nested_enum(
proto3_arena_unittest::TestAllTypes_NestedEnum_BAZ);
- m->add_repeated_foreign_enum(
- proto3_arena_unittest::FOREIGN_BAZ);
+ m->add_repeated_foreign_enum(proto3_arena_unittest::FOREIGN_BAZ);
m->add_repeated_lazy_message()->set_bb(49);
m->set_oneof_uint32(1);
@@ -81,8 +79,7 @@
EXPECT_EQ(43, m.optional_foreign_message().c());
EXPECT_EQ(proto3_arena_unittest::TestAllTypes_NestedEnum_BAZ,
m.optional_nested_enum());
- EXPECT_EQ(proto3_arena_unittest::FOREIGN_BAZ,
- m.optional_foreign_enum());
+ EXPECT_EQ(proto3_arena_unittest::FOREIGN_BAZ, m.optional_foreign_enum());
EXPECT_EQ(true, m.has_optional_lazy_message());
EXPECT_EQ(45, m.optional_lazy_message().bb());
@@ -100,8 +97,7 @@
EXPECT_EQ(proto3_arena_unittest::TestAllTypes_NestedEnum_BAZ,
m.repeated_nested_enum(0));
EXPECT_EQ(1, m.repeated_foreign_enum_size());
- EXPECT_EQ(proto3_arena_unittest::FOREIGN_BAZ,
- m.repeated_foreign_enum(0));
+ EXPECT_EQ(proto3_arena_unittest::FOREIGN_BAZ, m.repeated_foreign_enum(0));
EXPECT_EQ(1, m.repeated_lazy_message_size());
EXPECT_EQ(49, m.repeated_lazy_message(0).bb());
@@ -138,7 +134,7 @@
TEST(Proto3ArenaLiteTest, SetAllocatedMessage) {
Arena arena;
- TestAllTypes *arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
+ TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes::NestedMessage* nested = new TestAllTypes::NestedMessage;
nested->set_bb(118);
arena_message->set_allocated_optional_nested_message(nested);
diff --git a/src/google/protobuf/proto3_arena_unittest.cc b/src/google/protobuf/proto3_arena_unittest.cc
index e3c4777..d4b0135 100644
--- a/src/google/protobuf/proto3_arena_unittest.cc
+++ b/src/google/protobuf/proto3_arena_unittest.cc
@@ -54,8 +54,7 @@
m->mutable_optional_foreign_message()->set_c(43);
m->set_optional_nested_enum(
proto3_arena_unittest::TestAllTypes_NestedEnum_BAZ);
- m->set_optional_foreign_enum(
- proto3_arena_unittest::FOREIGN_BAZ);
+ m->set_optional_foreign_enum(proto3_arena_unittest::FOREIGN_BAZ);
m->mutable_optional_lazy_message()->set_bb(45);
m->add_repeated_int32(100);
m->add_repeated_string("asdf");
@@ -64,8 +63,7 @@
m->add_repeated_foreign_message()->set_c(47);
m->add_repeated_nested_enum(
proto3_arena_unittest::TestAllTypes_NestedEnum_BAZ);
- m->add_repeated_foreign_enum(
- proto3_arena_unittest::FOREIGN_BAZ);
+ m->add_repeated_foreign_enum(proto3_arena_unittest::FOREIGN_BAZ);
m->add_repeated_lazy_message()->set_bb(49);
m->set_oneof_uint32(1);
@@ -83,8 +81,7 @@
EXPECT_EQ(43, m.optional_foreign_message().c());
EXPECT_EQ(proto3_arena_unittest::TestAllTypes_NestedEnum_BAZ,
m.optional_nested_enum());
- EXPECT_EQ(proto3_arena_unittest::FOREIGN_BAZ,
- m.optional_foreign_enum());
+ EXPECT_EQ(proto3_arena_unittest::FOREIGN_BAZ, m.optional_foreign_enum());
EXPECT_EQ(true, m.has_optional_lazy_message());
EXPECT_EQ(45, m.optional_lazy_message().bb());
@@ -102,8 +99,7 @@
EXPECT_EQ(proto3_arena_unittest::TestAllTypes_NestedEnum_BAZ,
m.repeated_nested_enum(0));
EXPECT_EQ(1, m.repeated_foreign_enum_size());
- EXPECT_EQ(proto3_arena_unittest::FOREIGN_BAZ,
- m.repeated_foreign_enum(0));
+ EXPECT_EQ(proto3_arena_unittest::FOREIGN_BAZ, m.repeated_foreign_enum(0));
EXPECT_EQ(1, m.repeated_lazy_message_size());
EXPECT_EQ(49, m.repeated_lazy_message(0).bb());
@@ -161,7 +157,7 @@
TEST(Proto3ArenaTest, SetAllocatedMessage) {
Arena arena;
- TestAllTypes *arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
+ TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes::NestedMessage* nested = new TestAllTypes::NestedMessage;
nested->set_bb(118);
arena_message->set_allocated_optional_nested_message(nested);
@@ -192,8 +188,8 @@
TestAllTypes* message = Arena::CreateMessage<TestAllTypes>(&arena);
const Reflection* r = message->GetReflection();
const Descriptor* d = message->GetDescriptor();
- const FieldDescriptor* msg_field = d->FindFieldByName(
- "optional_nested_message");
+ const FieldDescriptor* msg_field =
+ d->FindFieldByName("optional_nested_message");
message->mutable_optional_nested_message()->set_bb(1);
r->ClearField(message, msg_field);
diff --git a/src/google/protobuf/reflection.h b/src/google/protobuf/reflection.h
index 407ca62..6b1e5f2 100644
--- a/src/google/protobuf/reflection.h
+++ b/src/google/protobuf/reflection.h
@@ -47,39 +47,33 @@
namespace google {
namespace protobuf {
namespace internal {
-template<typename T, typename Enable = void>
+template <typename T, typename Enable = void>
struct RefTypeTraits;
} // namespace internal
-template<typename T>
+template <typename T>
RepeatedFieldRef<T> Reflection::GetRepeatedFieldRef(
const Message& message, const FieldDescriptor* field) const {
return RepeatedFieldRef<T>(message, field);
}
-template<typename T>
+template <typename T>
MutableRepeatedFieldRef<T> Reflection::GetMutableRepeatedFieldRef(
Message* message, const FieldDescriptor* field) const {
return MutableRepeatedFieldRef<T>(message, field);
}
// RepeatedFieldRef definition for non-message types.
-template<typename T>
+template <typename T>
class RepeatedFieldRef<
T, typename std::enable_if<!std::is_base_of<Message, T>::value>::type> {
typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
public:
- bool empty() const {
- return accessor_->IsEmpty(data_);
- }
- int size() const {
- return accessor_->Size(data_);
- }
- T Get(int index) const {
- return accessor_->template Get<T>(data_, index);
- }
+ bool empty() const { return accessor_->IsEmpty(data_); }
+ int size() const { return accessor_->Size(data_); }
+ T Get(int index) const { return accessor_->template Get<T>(data_, index); }
typedef IteratorType iterator;
typedef IteratorType const_iterator;
@@ -89,22 +83,16 @@
typedef int size_type;
typedef ptrdiff_t difference_type;
- iterator begin() const {
- return iterator(data_, accessor_, true);
- }
- iterator end() const {
- return iterator(data_, accessor_, false);
- }
+ iterator begin() const { return iterator(data_, accessor_, true); }
+ iterator end() const { return iterator(data_, accessor_, false); }
private:
friend class Reflection;
- RepeatedFieldRef(
- const Message& message,
- const FieldDescriptor* field) {
+ RepeatedFieldRef(const Message& message, const FieldDescriptor* field) {
const Reflection* reflection = message.GetReflection();
- data_ = reflection->RepeatedFieldData(
- const_cast<Message*>(&message), field,
- internal::RefTypeTraits<T>::cpp_type, NULL);
+ data_ = reflection->RepeatedFieldData(const_cast<Message*>(&message), field,
+ internal::RefTypeTraits<T>::cpp_type,
+ NULL);
accessor_ = reflection->RepeatedFieldAccessor(field);
}
@@ -113,50 +101,38 @@
};
// MutableRepeatedFieldRef definition for non-message types.
-template<typename T>
+template <typename T>
class MutableRepeatedFieldRef<
T, typename std::enable_if<!std::is_base_of<Message, T>::value>::type> {
typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
public:
- bool empty() const {
- return accessor_->IsEmpty(data_);
- }
- int size() const {
- return accessor_->Size(data_);
- }
- T Get(int index) const {
- return accessor_->template Get<T>(data_, index);
- }
+ bool empty() const { return accessor_->IsEmpty(data_); }
+ int size() const { return accessor_->Size(data_); }
+ T Get(int index) const { return accessor_->template Get<T>(data_, index); }
void Set(int index, const T& value) const {
accessor_->template Set<T>(data_, index, value);
}
- void Add(const T& value) const {
- accessor_->template Add<T>(data_, value);
- }
- void RemoveLast() const {
- accessor_->RemoveLast(data_);
- }
+ void Add(const T& value) const { accessor_->template Add<T>(data_, value); }
+ void RemoveLast() const { accessor_->RemoveLast(data_); }
void SwapElements(int index1, int index2) const {
accessor_->SwapElements(data_, index1, index2);
}
- void Clear() const {
- accessor_->Clear(data_);
- }
+ void Clear() const { accessor_->Clear(data_); }
void Swap(const MutableRepeatedFieldRef& other) const {
accessor_->Swap(data_, other.accessor_, other.data_);
}
- template<typename Container>
+ template <typename Container>
void MergeFrom(const Container& container) const {
typedef typename Container::const_iterator Iterator;
for (Iterator it = container.begin(); it != container.end(); ++it) {
Add(*it);
}
}
- template<typename Container>
+ template <typename Container>
void CopyFrom(const Container& container) const {
Clear();
MergeFrom(container);
@@ -164,9 +140,7 @@
private:
friend class Reflection;
- MutableRepeatedFieldRef(
- Message* message,
- const FieldDescriptor* field) {
+ MutableRepeatedFieldRef(Message* message, const FieldDescriptor* field) {
const Reflection* reflection = message->GetReflection();
data_ = reflection->RepeatedFieldData(
message, field, internal::RefTypeTraits<T>::cpp_type, NULL);
@@ -178,19 +152,15 @@
};
// RepeatedFieldRef definition for message types.
-template<typename T>
+template <typename T>
class RepeatedFieldRef<
T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
public:
- bool empty() const {
- return accessor_->IsEmpty(data_);
- }
- int size() const {
- return accessor_->Size(data_);
- }
+ bool empty() const { return accessor_->IsEmpty(data_); }
+ int size() const { return accessor_->Size(data_); }
// This method returns a reference to the underlying message object if it
// exists. If a message object doesn't exist (e.g., data stored in serialized
// form), scratch_space will be filled with the data and a reference to it
@@ -205,9 +175,7 @@
}
// Create a new message of the same type as the messages stored in this
// repeated field. Caller takes ownership of the returned object.
- T* NewMessage() const {
- return static_cast<T*>(default_instance_->New());
- }
+ T* NewMessage() const { return static_cast<T*>(default_instance_->New()); }
typedef IteratorType iterator;
typedef IteratorType const_iterator;
@@ -227,9 +195,7 @@
private:
friend class Reflection;
- RepeatedFieldRef(
- const Message& message,
- const FieldDescriptor* field) {
+ RepeatedFieldRef(const Message& message, const FieldDescriptor* field) {
const Reflection* reflection = message.GetReflection();
data_ = reflection->RepeatedFieldData(
const_cast<Message*>(&message), field,
@@ -246,56 +212,44 @@
};
// MutableRepeatedFieldRef definition for message types.
-template<typename T>
+template <typename T>
class MutableRepeatedFieldRef<
T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
public:
- bool empty() const {
- return accessor_->IsEmpty(data_);
- }
- int size() const {
- return accessor_->Size(data_);
- }
+ bool empty() const { return accessor_->IsEmpty(data_); }
+ int size() const { return accessor_->Size(data_); }
// See comments for RepeatedFieldRef<Message>::Get()
const T& Get(int index, T* scratch_space) const {
return *static_cast<const T*>(accessor_->Get(data_, index, scratch_space));
}
// Create a new message of the same type as the messages stored in this
// repeated field. Caller takes ownership of the returned object.
- T* NewMessage() const {
- return static_cast<T*>(default_instance_->New());
- }
+ T* NewMessage() const { return static_cast<T*>(default_instance_->New()); }
void Set(int index, const T& value) const {
accessor_->Set(data_, index, &value);
}
- void Add(const T& value) const {
- accessor_->Add(data_, &value);
- }
- void RemoveLast() const {
- accessor_->RemoveLast(data_);
- }
+ void Add(const T& value) const { accessor_->Add(data_, &value); }
+ void RemoveLast() const { accessor_->RemoveLast(data_); }
void SwapElements(int index1, int index2) const {
accessor_->SwapElements(data_, index1, index2);
}
- void Clear() const {
- accessor_->Clear(data_);
- }
+ void Clear() const { accessor_->Clear(data_); }
void Swap(const MutableRepeatedFieldRef& other) const {
accessor_->Swap(data_, other.accessor_, other.data_);
}
- template<typename Container>
+ template <typename Container>
void MergeFrom(const Container& container) const {
typedef typename Container::const_iterator Iterator;
for (Iterator it = container.begin(); it != container.end(); ++it) {
Add(*it);
}
}
- template<typename Container>
+ template <typename Container>
void CopyFrom(const Container& container) const {
Clear();
MergeFrom(container);
@@ -303,9 +257,7 @@
private:
friend class Reflection;
- MutableRepeatedFieldRef(
- Message* message,
- const FieldDescriptor* field) {
+ MutableRepeatedFieldRef(Message* message, const FieldDescriptor* field) {
const Reflection* reflection = message->GetReflection();
data_ = reflection->RepeatedFieldData(
message, field, internal::RefTypeTraits<T>::cpp_type,
@@ -360,8 +312,8 @@
// exists, or fill the data into scratch_space and return scratch_space.
// Callers of this method must ensure scratch_space is a valid pointer
// to a mutable object of the correct type.
- virtual const Value* Get(
- const Field* data, int index, Value* scratch_space) const = 0;
+ virtual const Value* Get(const Field* data, int index,
+ Value* scratch_space) const = 0;
virtual void Clear(Field* data) const = 0;
virtual void Set(Field* data, int index, const Value* value) const = 0;
@@ -394,16 +346,15 @@
// Templated methods that make using this interface easier for non-message
// types.
- template<typename T>
+ template <typename T>
T Get(const Field* data, int index) const {
typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
ActualType scratch_space;
- return static_cast<T>(
- *reinterpret_cast<const ActualType*>(
- Get(data, index, static_cast<Value*>(&scratch_space))));
+ return static_cast<T>(*reinterpret_cast<const ActualType*>(
+ Get(data, index, static_cast<Value*>(&scratch_space))));
}
- template<typename T, typename ValueType>
+ template <typename T, typename ValueType>
void Set(Field* data, int index, const ValueType& value) const {
typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
// In this RepeatedFieldAccessor interface we pass/return data using
@@ -417,7 +368,7 @@
Set(data, index, static_cast<const Value*>(&tmp));
}
- template<typename T, typename ValueType>
+ template <typename T, typename ValueType>
void Add(Field* data, const ValueType& value) const {
typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
// In this RepeatedFieldAccessor interface we pass/return data using
@@ -440,7 +391,7 @@
};
// Implement (Mutable)RepeatedFieldRef::iterator
-template<typename T>
+template <typename T>
class RepeatedFieldRefIterator
: public std::iterator<std::forward_iterator_tag, T> {
typedef typename RefTypeTraits<T>::AccessorValueType AccessorValueType;
@@ -459,17 +410,14 @@
scratch_space_(begin ? new AccessorValueType : nullptr) {}
// Constructor for message fields.
RepeatedFieldRefIterator(const void* data,
- const RepeatedFieldAccessor* accessor,
- bool begin,
+ const RepeatedFieldAccessor* accessor, bool begin,
AccessorValueType* scratch_space)
- : data_(data), accessor_(accessor),
- iterator_(begin ? accessor->BeginIterator(data) :
- accessor->EndIterator(data)),
- scratch_space_(scratch_space) {
- }
- ~RepeatedFieldRefIterator() {
- accessor_->DeleteIterator(data_, iterator_);
- }
+ : data_(data),
+ accessor_(accessor),
+ iterator_(begin ? accessor->BeginIterator(data)
+ : accessor->EndIterator(data)),
+ scratch_space_(scratch_space) {}
+ ~RepeatedFieldRefIterator() { accessor_->DeleteIterator(data_, iterator_); }
RepeatedFieldRefIterator operator++(int) {
RepeatedFieldRefIterator tmp(*this);
iterator_ = accessor_->AdvanceIterator(data_, iterator_);
@@ -481,14 +429,12 @@
}
IteratorValueType operator*() const {
return static_cast<IteratorValueType>(
- *static_cast<const AccessorValueType*>(
- accessor_->GetIteratorValue(
- data_, iterator_, scratch_space_.get())));
+ *static_cast<const AccessorValueType*>(accessor_->GetIteratorValue(
+ data_, iterator_, scratch_space_.get())));
}
IteratorPointerType operator->() const {
return static_cast<IteratorPointerType>(
- accessor_->GetIteratorValue(
- data_, iterator_, scratch_space_.get()));
+ accessor_->GetIteratorValue(data_, iterator_, scratch_space_.get()));
}
bool operator!=(const RepeatedFieldRefIterator& other) const {
assert(data_ == other.data_);
@@ -500,9 +446,9 @@
}
RepeatedFieldRefIterator(const RepeatedFieldRefIterator& other)
- : data_(other.data_), accessor_(other.accessor_),
- iterator_(accessor_->CopyIterator(data_, other.iterator_)) {
- }
+ : data_(other.data_),
+ accessor_(other.accessor_),
+ iterator_(accessor_->CopyIterator(data_, other.iterator_)) {}
RepeatedFieldRefIterator& operator=(const RepeatedFieldRefIterator& other) {
if (this != &other) {
accessor_->DeleteIterator(data_, iterator_);
@@ -523,16 +469,17 @@
// TypeTraits that maps the type parameter T of RepeatedFieldRef or
// MutableRepeatedFieldRef to corresponding iterator type,
// RepeatedFieldAccessor type, etc.
-template<typename T>
+template <typename T>
struct PrimitiveTraits {
static const bool is_primitive = false;
};
-#define DEFINE_PRIMITIVE(TYPE, type) \
- template<> struct PrimitiveTraits<type> { \
- static const bool is_primitive = true; \
- static const FieldDescriptor::CppType cpp_type = \
- FieldDescriptor::CPPTYPE_ ## TYPE; \
- };
+#define DEFINE_PRIMITIVE(TYPE, type) \
+ template <> \
+ struct PrimitiveTraits<type> { \
+ static const bool is_primitive = true; \
+ static const FieldDescriptor::CppType cpp_type = \
+ FieldDescriptor::CPPTYPE_##TYPE; \
+ };
DEFINE_PRIMITIVE(INT32, int32)
DEFINE_PRIMITIVE(UINT32, uint32)
DEFINE_PRIMITIVE(INT64, int64)
@@ -542,7 +489,7 @@
DEFINE_PRIMITIVE(BOOL, bool)
#undef DEFINE_PRIMITIVE
-template<typename T>
+template <typename T>
struct RefTypeTraits<
T, typename std::enable_if<PrimitiveTraits<T>::is_primitive>::type> {
typedef RepeatedFieldRefIterator<T> iterator;
@@ -550,14 +497,11 @@
typedef T AccessorValueType;
typedef T IteratorValueType;
typedef T* IteratorPointerType;
- static const FieldDescriptor::CppType cpp_type =
- PrimitiveTraits<T>::cpp_type;
- static const Descriptor* GetMessageFieldDescriptor() {
- return NULL;
- }
+ static const FieldDescriptor::CppType cpp_type = PrimitiveTraits<T>::cpp_type;
+ static const Descriptor* GetMessageFieldDescriptor() { return NULL; }
};
-template<typename T>
+template <typename T>
struct RefTypeTraits<
T, typename std::enable_if<is_proto_enum<T>::value>::type> {
typedef RepeatedFieldRefIterator<T> iterator;
@@ -568,9 +512,7 @@
typedef int32* IteratorPointerType;
static const FieldDescriptor::CppType cpp_type =
FieldDescriptor::CPPTYPE_ENUM;
- static const Descriptor* GetMessageFieldDescriptor() {
- return NULL;
- }
+ static const Descriptor* GetMessageFieldDescriptor() { return NULL; }
};
template <typename T>
@@ -583,25 +525,21 @@
typedef const std::string* IteratorPointerType;
static const FieldDescriptor::CppType cpp_type =
FieldDescriptor::CPPTYPE_STRING;
- static const Descriptor* GetMessageFieldDescriptor() {
- return NULL;
- }
+ static const Descriptor* GetMessageFieldDescriptor() { return NULL; }
};
-template<typename T>
+template <typename T>
struct MessageDescriptorGetter {
static const Descriptor* get() {
return T::default_instance().GetDescriptor();
}
};
-template<>
+template <>
struct MessageDescriptorGetter<Message> {
- static const Descriptor* get() {
- return NULL;
- }
+ static const Descriptor* get() { return NULL; }
};
-template<typename T>
+template <typename T>
struct RefTypeTraits<
T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
typedef RepeatedFieldRefIterator<T> iterator;
diff --git a/src/google/protobuf/reflection_internal.h b/src/google/protobuf/reflection_internal.h
index b4b1d41..40c070f 100644
--- a/src/google/protobuf/reflection_internal.h
+++ b/src/google/protobuf/reflection_internal.h
@@ -82,7 +82,7 @@
// Base class for RepeatedFieldAccessor implementations that manipulates
// RepeatedField<T>.
-template<typename T>
+template <typename T>
class RepeatedFieldWrapper : public RandomAccessRepeatedFieldAccessor {
public:
RepeatedFieldWrapper() {}
@@ -137,7 +137,7 @@
// Base class for RepeatedFieldAccessor implementations that manipulates
// RepeatedPtrField<T>.
-template<typename T>
+template <typename T>
class RepeatedPtrFieldWrapper : public RandomAccessRepeatedFieldAccessor {
public:
bool IsEmpty(const Field* data) const override {
diff --git a/src/google/protobuf/reflection_ops.cc b/src/google/protobuf/reflection_ops.cc
index f8f9dc3..3ced141 100644
--- a/src/google/protobuf/reflection_ops.cc
+++ b/src/google/protobuf/reflection_ops.cc
@@ -74,9 +74,9 @@
const Descriptor* descriptor = from.GetDescriptor();
GOOGLE_CHECK_EQ(to->GetDescriptor(), descriptor)
- << "Tried to merge messages of different types "
- << "(merge " << descriptor->full_name()
- << " to " << to->GetDescriptor()->full_name() << ")";
+ << "Tried to merge messages of different types "
+ << "(merge " << descriptor->full_name() << " to "
+ << to->GetDescriptor()->full_name() << ")";
const Reflection* from_reflection = GetReflectionOrDie(from);
const Reflection* to_reflection = GetReflectionOrDie(*to);
@@ -99,8 +99,7 @@
if (is_from_generated == is_to_generated && field->is_map()) {
const MapFieldBase* from_field =
from_reflection->GetMapData(from, field);
- MapFieldBase* to_field =
- to_reflection->MutableMapData(to, field);
+ MapFieldBase* to_field = to_reflection->MutableMapData(to, field);
if (to_field->IsMapValid() && from_field->IsMapValid()) {
to_field->MergeFrom(*from_field);
continue;
@@ -109,58 +108,58 @@
int count = from_reflection->FieldSize(from, field);
for (int j = 0; j < count; j++) {
switch (field->cpp_type()) {
-#define HANDLE_TYPE(CPPTYPE, METHOD) \
- case FieldDescriptor::CPPTYPE_##CPPTYPE: \
- to_reflection->Add##METHOD(to, field, \
- from_reflection->GetRepeated##METHOD(from, field, j)); \
- break;
+#define HANDLE_TYPE(CPPTYPE, METHOD) \
+ case FieldDescriptor::CPPTYPE_##CPPTYPE: \
+ to_reflection->Add##METHOD( \
+ to, field, from_reflection->GetRepeated##METHOD(from, field, j)); \
+ break;
- HANDLE_TYPE(INT32 , Int32 );
- HANDLE_TYPE(INT64 , Int64 );
+ HANDLE_TYPE(INT32, Int32);
+ HANDLE_TYPE(INT64, Int64);
HANDLE_TYPE(UINT32, UInt32);
HANDLE_TYPE(UINT64, UInt64);
- HANDLE_TYPE(FLOAT , Float );
+ HANDLE_TYPE(FLOAT, Float);
HANDLE_TYPE(DOUBLE, Double);
- HANDLE_TYPE(BOOL , Bool );
+ HANDLE_TYPE(BOOL, Bool);
HANDLE_TYPE(STRING, String);
- HANDLE_TYPE(ENUM , Enum );
+ HANDLE_TYPE(ENUM, Enum);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_MESSAGE:
to_reflection->AddMessage(to, field)->MergeFrom(
- from_reflection->GetRepeatedMessage(from, field, j));
+ from_reflection->GetRepeatedMessage(from, field, j));
break;
}
}
} else {
switch (field->cpp_type()) {
-#define HANDLE_TYPE(CPPTYPE, METHOD) \
- case FieldDescriptor::CPPTYPE_##CPPTYPE: \
- to_reflection->Set##METHOD(to, field, \
- from_reflection->Get##METHOD(from, field)); \
- break;
+#define HANDLE_TYPE(CPPTYPE, METHOD) \
+ case FieldDescriptor::CPPTYPE_##CPPTYPE: \
+ to_reflection->Set##METHOD(to, field, \
+ from_reflection->Get##METHOD(from, field)); \
+ break;
- HANDLE_TYPE(INT32 , Int32 );
- HANDLE_TYPE(INT64 , Int64 );
+ HANDLE_TYPE(INT32, Int32);
+ HANDLE_TYPE(INT64, Int64);
HANDLE_TYPE(UINT32, UInt32);
HANDLE_TYPE(UINT64, UInt64);
- HANDLE_TYPE(FLOAT , Float );
+ HANDLE_TYPE(FLOAT, Float);
HANDLE_TYPE(DOUBLE, Double);
- HANDLE_TYPE(BOOL , Bool );
+ HANDLE_TYPE(BOOL, Bool);
HANDLE_TYPE(STRING, String);
- HANDLE_TYPE(ENUM , Enum );
+ HANDLE_TYPE(ENUM, Enum);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_MESSAGE:
to_reflection->MutableMessage(to, field)->MergeFrom(
- from_reflection->GetMessage(from, field));
+ from_reflection->GetMessage(from, field));
break;
}
}
}
to_reflection->MutableUnknownFields(to)->MergeFrom(
- from_reflection->GetUnknownFields(from));
+ from_reflection->GetUnknownFields(from));
}
void ReflectionOps::Clear(Message* message) {
@@ -221,7 +220,7 @@
for (int j = 0; j < size; j++) {
if (!reflection->GetRepeatedMessage(message, field, j)
- .IsInitialized()) {
+ .IsInitialized()) {
return false;
}
}
@@ -257,7 +256,8 @@
MapIterator end(message, field);
for (map_field->MapBegin(&iter), map_field->MapEnd(&end);
iter != end; ++iter) {
- iter.MutableValueRef()->MutableMessageValue()
+ iter.MutableValueRef()
+ ->MutableMessageValue()
->DiscardUnknownFields();
}
continue;
@@ -269,7 +269,7 @@
int size = reflection->FieldSize(*message, field);
for (int j = 0; j < size; j++) {
reflection->MutableRepeatedMessage(message, field, j)
- ->DiscardUnknownFields();
+ ->DiscardUnknownFields();
}
} else {
reflection->MutableMessage(message, field)->DiscardUnknownFields();
@@ -324,16 +324,14 @@
for (int j = 0; j < size; j++) {
const Message& sub_message =
- reflection->GetRepeatedMessage(message, field, j);
+ reflection->GetRepeatedMessage(message, field, j);
FindInitializationErrors(sub_message,
- SubMessagePrefix(prefix, field, j),
- errors);
+ SubMessagePrefix(prefix, field, j), errors);
}
} else {
const Message& sub_message = reflection->GetMessage(message, field);
FindInitializationErrors(sub_message,
- SubMessagePrefix(prefix, field, -1),
- errors);
+ SubMessagePrefix(prefix, field, -1), errors);
}
}
}
diff --git a/src/google/protobuf/reflection_ops_unittest.cc b/src/google/protobuf/reflection_ops_unittest.cc
index 0f46ff1..bd14193 100644
--- a/src/google/protobuf/reflection_ops_unittest.cc
+++ b/src/google/protobuf/reflection_ops_unittest.cc
@@ -33,9 +33,9 @@
// Sanjay Ghemawat, Jeff Dean, and others.
#include <google/protobuf/reflection_ops.h>
-#include <google/protobuf/descriptor.h>
-#include <google/protobuf/unittest.pb.h>
#include <google/protobuf/test_util.h>
+#include <google/protobuf/unittest.pb.h>
+#include <google/protobuf/descriptor.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
@@ -128,18 +128,21 @@
TestUtil::SetAllExtensions(&message);
// This field will test merging into an empty spot.
- message2.SetExtension(unittest::optional_int32_extension,
- message.GetExtension(unittest::optional_int32_extension));
+ message2.SetExtension(
+ unittest::optional_int32_extension,
+ message.GetExtension(unittest::optional_int32_extension));
message.ClearExtension(unittest::optional_int32_extension);
// This tests overwriting.
- message2.SetExtension(unittest::optional_string_extension,
- message.GetExtension(unittest::optional_string_extension));
+ message2.SetExtension(
+ unittest::optional_string_extension,
+ message.GetExtension(unittest::optional_string_extension));
message.SetExtension(unittest::optional_string_extension, "something else");
// This tests concatenating.
- message2.AddExtension(unittest::repeated_int32_extension,
- message.GetExtension(unittest::repeated_int32_extension, 1));
+ message2.AddExtension(
+ unittest::repeated_int32_extension,
+ message.GetExtension(unittest::repeated_int32_extension, 1));
int32 i = message.GetExtension(unittest::repeated_int32_extension, 0);
message.ClearExtension(unittest::repeated_int32_extension);
message.AddExtension(unittest::repeated_int32_extension, i);
@@ -192,9 +195,7 @@
unittest::TestAllTypes message;
- EXPECT_DEATH(
- ReflectionOps::Merge(message, &message),
- "&from");
+ EXPECT_DEATH(ReflectionOps::Merge(message, &message), "&from");
}
#endif // PROTOBUF_HAS_DEATH_TEST
@@ -235,9 +236,9 @@
&message.GetExtension(unittest::optionalgroup_extension));
EXPECT_NE(&unittest::TestAllTypes::NestedMessage::default_instance(),
&message.GetExtension(unittest::optional_nested_message_extension));
- EXPECT_NE(&unittest::ForeignMessage::default_instance(),
- &message.GetExtension(
- unittest::optional_foreign_message_extension));
+ EXPECT_NE(
+ &unittest::ForeignMessage::default_instance(),
+ &message.GetExtension(unittest::optional_foreign_message_extension));
EXPECT_NE(&unittest_import::ImportMessage::default_instance(),
&message.GetExtension(unittest::optional_import_message_extension));
}
@@ -274,30 +275,29 @@
TestUtil::SetAllFields(&message);
// Set some unknown fields in message.
- message.mutable_unknown_fields()
- ->AddVarint(123456, 654321);
+ message.mutable_unknown_fields()->AddVarint(123456, 654321);
message.mutable_optional_nested_message()
- ->mutable_unknown_fields()
- ->AddVarint(123456, 654321);
+ ->mutable_unknown_fields()
+ ->AddVarint(123456, 654321);
message.mutable_repeated_nested_message(0)
- ->mutable_unknown_fields()
- ->AddVarint(123456, 654321);
+ ->mutable_unknown_fields()
+ ->AddVarint(123456, 654321);
EXPECT_EQ(1, message.unknown_fields().field_count());
- EXPECT_EQ(1, message.optional_nested_message()
- .unknown_fields().field_count());
- EXPECT_EQ(1, message.repeated_nested_message(0)
- .unknown_fields().field_count());
+ EXPECT_EQ(1,
+ message.optional_nested_message().unknown_fields().field_count());
+ EXPECT_EQ(1,
+ message.repeated_nested_message(0).unknown_fields().field_count());
// Discard them.
ReflectionOps::DiscardUnknownFields(&message);
TestUtil::ExpectAllFieldsSet(message);
EXPECT_EQ(0, message.unknown_fields().field_count());
- EXPECT_EQ(0, message.optional_nested_message()
- .unknown_fields().field_count());
- EXPECT_EQ(0, message.repeated_nested_message(0)
- .unknown_fields().field_count());
+ EXPECT_EQ(0,
+ message.optional_nested_message().unknown_fields().field_count());
+ EXPECT_EQ(0,
+ message.repeated_nested_message(0).unknown_fields().field_count());
}
TEST(ReflectionOpsTest, DiscardUnknownExtensions) {
@@ -305,34 +305,35 @@
TestUtil::SetAllExtensions(&message);
// Set some unknown fields.
- message.mutable_unknown_fields()
- ->AddVarint(123456, 654321);
+ message.mutable_unknown_fields()->AddVarint(123456, 654321);
message.MutableExtension(unittest::optional_nested_message_extension)
- ->mutable_unknown_fields()
- ->AddVarint(123456, 654321);
+ ->mutable_unknown_fields()
+ ->AddVarint(123456, 654321);
message.MutableExtension(unittest::repeated_nested_message_extension, 0)
- ->mutable_unknown_fields()
- ->AddVarint(123456, 654321);
+ ->mutable_unknown_fields()
+ ->AddVarint(123456, 654321);
EXPECT_EQ(1, message.unknown_fields().field_count());
+ EXPECT_EQ(1, message.GetExtension(unittest::optional_nested_message_extension)
+ .unknown_fields()
+ .field_count());
EXPECT_EQ(1,
- message.GetExtension(unittest::optional_nested_message_extension)
- .unknown_fields().field_count());
- EXPECT_EQ(1,
- message.GetExtension(unittest::repeated_nested_message_extension, 0)
- .unknown_fields().field_count());
+ message.GetExtension(unittest::repeated_nested_message_extension, 0)
+ .unknown_fields()
+ .field_count());
// Discard them.
ReflectionOps::DiscardUnknownFields(&message);
TestUtil::ExpectAllExtensionsSet(message);
EXPECT_EQ(0, message.unknown_fields().field_count());
+ EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension)
+ .unknown_fields()
+ .field_count());
EXPECT_EQ(0,
- message.GetExtension(unittest::optional_nested_message_extension)
- .unknown_fields().field_count());
- EXPECT_EQ(0,
- message.GetExtension(unittest::repeated_nested_message_extension, 0)
- .unknown_fields().field_count());
+ message.GetExtension(unittest::repeated_nested_message_extension, 0)
+ .unknown_fields()
+ .field_count());
}
TEST(ReflectionOpsTest, IsInitialized) {
@@ -435,16 +436,17 @@
message.mutable_optional_message();
message.add_repeated_message();
message.add_repeated_message();
- EXPECT_EQ("optional_message.a,"
- "optional_message.b,"
- "optional_message.c,"
- "repeated_message[0].a,"
- "repeated_message[0].b,"
- "repeated_message[0].c,"
- "repeated_message[1].a,"
- "repeated_message[1].b,"
- "repeated_message[1].c",
- FindInitializationErrors(message));
+ EXPECT_EQ(
+ "optional_message.a,"
+ "optional_message.b,"
+ "optional_message.c,"
+ "repeated_message[0].a,"
+ "repeated_message[0].b,"
+ "repeated_message[0].c,"
+ "repeated_message[1].a,"
+ "repeated_message[1].b,"
+ "repeated_message[1].c",
+ FindInitializationErrors(message));
}
TEST(ReflectionOpsTest, FindExtensionInitializationErrors) {
@@ -452,23 +454,23 @@
message.MutableExtension(unittest::TestRequired::single);
message.AddExtension(unittest::TestRequired::multi);
message.AddExtension(unittest::TestRequired::multi);
- EXPECT_EQ("(protobuf_unittest.TestRequired.single).a,"
- "(protobuf_unittest.TestRequired.single).b,"
- "(protobuf_unittest.TestRequired.single).c,"
- "(protobuf_unittest.TestRequired.multi)[0].a,"
- "(protobuf_unittest.TestRequired.multi)[0].b,"
- "(protobuf_unittest.TestRequired.multi)[0].c,"
- "(protobuf_unittest.TestRequired.multi)[1].a,"
- "(protobuf_unittest.TestRequired.multi)[1].b,"
- "(protobuf_unittest.TestRequired.multi)[1].c",
- FindInitializationErrors(message));
+ EXPECT_EQ(
+ "(protobuf_unittest.TestRequired.single).a,"
+ "(protobuf_unittest.TestRequired.single).b,"
+ "(protobuf_unittest.TestRequired.single).c,"
+ "(protobuf_unittest.TestRequired.multi)[0].a,"
+ "(protobuf_unittest.TestRequired.multi)[0].b,"
+ "(protobuf_unittest.TestRequired.multi)[0].c,"
+ "(protobuf_unittest.TestRequired.multi)[1].a,"
+ "(protobuf_unittest.TestRequired.multi)[1].b,"
+ "(protobuf_unittest.TestRequired.multi)[1].c",
+ FindInitializationErrors(message));
}
TEST(ReflectionOpsTest, FindOneofInitializationErrors) {
unittest::TestRequiredOneof message;
message.mutable_foo_message();
- EXPECT_EQ("foo_message.required_double",
- FindInitializationErrors(message));
+ EXPECT_EQ("foo_message.required_double", FindInitializationErrors(message));
}
} // namespace
diff --git a/src/google/protobuf/repeated_field.cc b/src/google/protobuf/repeated_field.cc
index 44b0457..e5dbe02 100644
--- a/src/google/protobuf/repeated_field.cc
+++ b/src/google/protobuf/repeated_field.cc
@@ -34,9 +34,9 @@
#include <algorithm>
-#include <google/protobuf/repeated_field.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/repeated_field.h>
#include <google/protobuf/port_def.inc>
@@ -56,9 +56,8 @@
Arena* arena = GetArenaNoVirtual();
new_size = std::max(kMinRepeatedFieldAllocationSize,
std::max(total_size_ * 2, new_size));
- GOOGLE_CHECK_LE(new_size,
- (std::numeric_limits<size_t>::max() - kRepHeaderSize) /
- sizeof(old_rep->elements[0]))
+ GOOGLE_CHECK_LE(new_size, (std::numeric_limits<size_t>::max() - kRepHeaderSize) /
+ sizeof(old_rep->elements[0]))
<< "Requested size is too large to fit into size_t.";
size_t bytes = kRepHeaderSize + sizeof(old_rep->elements[0]) * new_size;
if (arena == NULL) {
diff --git a/src/google/protobuf/repeated_field.h b/src/google/protobuf/repeated_field.h
index 2552e23..4c631f0 100644
--- a/src/google/protobuf/repeated_field.h
+++ b/src/google/protobuf/repeated_field.h
@@ -111,7 +111,6 @@
}
} // namespace internal
-
// RepeatedField is used to represent repeated fields of a primitive type (in
// other words, everything except strings and nested Messages). Most users will
// not ever use a RepeatedField directly; they will use the get-by-index,
@@ -220,15 +219,11 @@
// Reverse iterator support
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
- reverse_iterator rbegin() {
- return reverse_iterator(end());
- }
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const {
return const_reverse_iterator(end());
}
- reverse_iterator rend() {
- return reverse_iterator(begin());
- }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const {
return const_reverse_iterator(begin());
}
@@ -350,13 +345,15 @@
const Element* unsafe_data() const;
};
-template<typename Element>
+template <typename Element>
const size_t RepeatedField<Element>::kRepHeaderSize =
reinterpret_cast<size_t>(&reinterpret_cast<Rep*>(16)->elements[0]) - 16;
namespace internal {
-template <typename It> class RepeatedPtrIterator;
-template <typename It, typename VoidPtr> class RepeatedPtrOverPtrsIterator;
+template <typename It>
+class RepeatedPtrIterator;
+template <typename It, typename VoidPtr>
+class RepeatedPtrOverPtrsIterator;
} // namespace internal
namespace internal {
@@ -393,22 +390,24 @@
// We mangle these names a bit to avoid compatibility issues in 'unclean'
// include environments that may have, e.g., "#define test ..." (yes, this
// exists).
- template<typename U, typename RetType, RetType (U::*)(const U& arg)>
- struct CheckType;
- template<typename U> static HasMerge Check(
- CheckType<U, void, &U::MergeFrom>*);
- template<typename U> static HasMerge Check(
- CheckType<U, bool, &U::MergeFrom>*);
- template<typename U> static HasNoMerge Check(...);
+ template <typename U, typename RetType, RetType (U::*)(const U& arg)>
+ struct CheckType;
+ template <typename U>
+ static HasMerge Check(CheckType<U, void, &U::MergeFrom>*);
+ template <typename U>
+ static HasMerge Check(CheckType<U, bool, &U::MergeFrom>*);
+ template <typename U>
+ static HasNoMerge Check(...);
// Resolves to either std::true_type or std::false_type.
typedef std::integral_constant<bool,
- (sizeof(Check<T>(0)) == sizeof(HasMerge))> type;
+ (sizeof(Check<T>(0)) == sizeof(HasMerge))>
+ type;
};
template <typename T, typename = void>
-struct TypeImplementsMergeBehavior :
- TypeImplementsMergeBehaviorProbeForMergeFrom<T> {};
+struct TypeImplementsMergeBehavior
+ : TypeImplementsMergeBehaviorProbeForMergeFrom<T> {};
template <>
@@ -529,7 +528,7 @@
template <typename TypeHandler>
typename TypeHandler::Type* AddFromCleared();
- template<typename TypeHandler>
+ template <typename TypeHandler>
void AddAllocated(typename TypeHandler::Type* value) {
typename TypeImplementsMergeBehavior<typename TypeHandler::Type>::type t;
AddAllocatedInternal<TypeHandler>(value, t);
@@ -573,12 +572,9 @@
typename TypeHandler::Type* ReleaseLastInternal(std::false_type);
template <typename TypeHandler>
- PROTOBUF_NOINLINE void SwapFallback(
- RepeatedPtrFieldBase* other);
+ PROTOBUF_NOINLINE void SwapFallback(RepeatedPtrFieldBase* other);
- inline Arena* GetArenaNoVirtual() const {
- return arena_;
- }
+ inline Arena* GetArenaNoVirtual() const { return arena_; }
private:
static const int kInitialSize = 0;
@@ -594,11 +590,11 @@
// Placing all fields directly in the RepeatedPtrFieldBase instance costs
// significant performance for memory-sensitive workloads.
Arena* arena_;
- int current_size_;
- int total_size_;
+ int current_size_;
+ int total_size_;
struct Rep {
- int allocated_size;
- void* elements[1];
+ int allocated_size;
+ void* elements[1];
};
static const size_t kRepHeaderSize = sizeof(Rep) - sizeof(void*);
// Contains arena ptr and the elements array. We also keep the invariant that
@@ -616,13 +612,14 @@
// Non-templated inner function to avoid code duplication. Takes a function
// pointer to the type-specific (templated) inner allocate/merge loop.
- void MergeFromInternal(
- const RepeatedPtrFieldBase& other,
- void (RepeatedPtrFieldBase::*inner_loop)(void**, void**, int, int));
+ void MergeFromInternal(const RepeatedPtrFieldBase& other,
+ void (RepeatedPtrFieldBase::*inner_loop)(void**,
+ void**, int,
+ int));
- template<typename TypeHandler>
- void MergeFromInnerLoop(
- void** our_elems, void** other_elems, int length, int already_allocated);
+ template <typename TypeHandler>
+ void MergeFromInnerLoop(void** our_elems, void** other_elems, int length,
+ int already_allocated);
// Internal helper: extend array space if necessary to contain |extend_amount|
// more elements, and return a pointer to the element immediately following
@@ -716,7 +713,7 @@
inline Arena* GenericTypeHandler<MessageLite>::GetArena(MessageLite* value) {
return value->GetArena();
}
-template<>
+template <>
inline void* GenericTypeHandler<MessageLite>::GetMaybeArenaPointer(
MessageLite* value) {
return value->GetMaybeArenaPointer();
@@ -880,15 +877,11 @@
// Reverse iterator support
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
- reverse_iterator rbegin() {
- return reverse_iterator(end());
- }
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const {
return const_reverse_iterator(end());
}
- reverse_iterator rend() {
- return reverse_iterator(begin());
- }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const {
return const_reverse_iterator(begin());
}
@@ -1058,23 +1051,15 @@
template <typename Element>
inline RepeatedField<Element>::RepeatedField()
- : current_size_(0),
- total_size_(0),
- ptr_(NULL) {
-}
+ : current_size_(0), total_size_(0), ptr_(NULL) {}
template <typename Element>
inline RepeatedField<Element>::RepeatedField(Arena* arena)
- : current_size_(0),
- total_size_(0),
- ptr_(arena) {
-}
+ : current_size_(0), total_size_(0), ptr_(arena) {}
template <typename Element>
inline RepeatedField<Element>::RepeatedField(const RepeatedField& other)
- : current_size_(0),
- total_size_(0),
- ptr_(NULL) {
+ : current_size_(0), total_size_(0), ptr_(NULL) {
if (other.current_size_ != 0) {
Reserve(other.size());
AddNAlreadyReserved(other.size());
@@ -1085,9 +1070,7 @@
template <typename Element>
template <typename Iter>
RepeatedField<Element>::RepeatedField(Iter begin, const Iter& end)
- : current_size_(0),
- total_size_(0),
- ptr_(NULL) {
+ : current_size_(0), total_size_(0), ptr_(NULL) {
int reserve = internal::CalculateReserve(begin, end);
if (reserve != -1) {
if (reserve == 0) {
@@ -1118,10 +1101,9 @@
}
template <typename Element>
-inline RepeatedField<Element>&
-RepeatedField<Element>::operator=(const RepeatedField& other) {
- if (this != &other)
- CopyFrom(other);
+inline RepeatedField<Element>& RepeatedField<Element>::operator=(
+ const RepeatedField& other) {
+ if (this != &other) CopyFrom(other);
return *this;
}
@@ -1129,7 +1111,8 @@
inline RepeatedField<Element>::RepeatedField(RepeatedField&& other) noexcept
: RepeatedField() {
// We don't just call Swap(&other) here because it would perform 3 copies if
- // the two fields are on different arenas.
+ // other is on an arena. This field can't be on an arena because arena
+ // construction always uses the Arena* accepting constructor.
if (other.GetArenaNoVirtual()) {
CopyFrom(other);
} else {
@@ -1167,19 +1150,19 @@
return total_size_;
}
-template<typename Element>
+template <typename Element>
inline void RepeatedField<Element>::AddAlreadyReserved(const Element& value) {
GOOGLE_DCHECK_LT(current_size_, total_size_);
elements()[current_size_++] = value;
}
-template<typename Element>
+template <typename Element>
inline Element* RepeatedField<Element>::AddAlreadyReserved() {
GOOGLE_DCHECK_LT(current_size_, total_size_);
return &elements()[current_size_++];
}
-template<typename Element>
+template <typename Element>
inline Element* RepeatedField<Element>::AddNAlreadyReserved(int n) {
GOOGLE_DCHECK_GE(total_size_ - current_size_, n)
<< total_size_ << ", " << current_size_;
@@ -1194,7 +1177,7 @@
return ret;
}
-template<typename Element>
+template <typename Element>
inline void RepeatedField<Element>::Resize(int new_size, const Element& value) {
GOOGLE_DCHECK_GE(new_size, 0);
if (new_size > current_size_) {
@@ -1258,16 +1241,15 @@
}
template <typename Element>
-void RepeatedField<Element>::ExtractSubrange(
- int start, int num, Element* elements) {
+void RepeatedField<Element>::ExtractSubrange(int start, int num,
+ Element* elements) {
GOOGLE_DCHECK_GE(start, 0);
GOOGLE_DCHECK_GE(num, 0);
GOOGLE_DCHECK_LE(start + num, this->current_size_);
// Save the values of the removed elements if requested.
if (elements != NULL) {
- for (int i = 0; i < num; ++i)
- elements[i] = this->Get(i + start);
+ for (int i = 0; i < num; ++i) elements[i] = this->Get(i + start);
}
// Slide remaining elements down to fill the gap.
@@ -1383,8 +1365,7 @@
return total_size_ > 0 ? elements() : NULL;
}
template <typename Element>
-inline typename RepeatedField<Element>::iterator
-RepeatedField<Element>::end() {
+inline typename RepeatedField<Element>::iterator RepeatedField<Element>::end() {
return total_size_ > 0 ? elements() + current_size_ : NULL;
}
template <typename Element>
@@ -1417,7 +1398,8 @@
static_cast<size_t>(new_size),
(std::numeric_limits<size_t>::max() - kRepHeaderSize) / sizeof(Element))
<< "Requested size is too large to fit into size_t.";
- size_t bytes = kRepHeaderSize + sizeof(Element) * static_cast<size_t>(new_size);
+ size_t bytes =
+ kRepHeaderSize + sizeof(Element) * static_cast<size_t>(new_size);
if (arena == NULL) {
new_rep = static_cast<Rep*>(::operator new(bytes));
} else {
@@ -1459,22 +1441,23 @@
}
template <typename Element>
-inline void RepeatedField<Element>::MoveArray(
- Element* to, Element* from, int array_size) {
+inline void RepeatedField<Element>::MoveArray(Element* to, Element* from,
+ int array_size) {
CopyArray(to, from, array_size);
}
template <typename Element>
-inline void RepeatedField<Element>::CopyArray(
- Element* to, const Element* from, int array_size) {
+inline void RepeatedField<Element>::CopyArray(Element* to, const Element* from,
+ int array_size) {
internal::ElementCopier<Element>()(to, from, array_size);
}
namespace internal {
template <typename Element, bool HasTrivialCopy>
-void ElementCopier<Element, HasTrivialCopy>::operator()(
- Element* to, const Element* from, int array_size) {
+void ElementCopier<Element, HasTrivialCopy>::operator()(Element* to,
+ const Element* from,
+ int array_size) {
std::copy(from, from + array_size, to);
}
@@ -1493,11 +1476,7 @@
namespace internal {
inline RepeatedPtrFieldBase::RepeatedPtrFieldBase()
- : arena_(NULL),
- current_size_(0),
- total_size_(0),
- rep_(NULL) {
-}
+ : arena_(NULL), current_size_(0), total_size_(0), rep_(NULL) {}
inline RepeatedPtrFieldBase::RepeatedPtrFieldBase(Arena* arena)
: arena_(arena), current_size_(0), total_size_(0), rep_(NULL) {}
@@ -1545,17 +1524,13 @@
temp.Destroy<TypeHandler>(); // Frees rep_ if `other` had no arena.
}
-inline bool RepeatedPtrFieldBase::empty() const {
- return current_size_ == 0;
-}
+inline bool RepeatedPtrFieldBase::empty() const { return current_size_ == 0; }
-inline int RepeatedPtrFieldBase::size() const {
- return current_size_;
-}
+inline int RepeatedPtrFieldBase::size() const { return current_size_; }
template <typename TypeHandler>
-inline const typename TypeHandler::WeakType&
-RepeatedPtrFieldBase::Get(int index) const {
+inline const typename TypeHandler::WeakType& RepeatedPtrFieldBase::Get(
+ int index) const {
GOOGLE_DCHECK_GE(index, 0);
GOOGLE_DCHECK_LT(index, current_size_);
return *cast<TypeHandler>(rep_->elements[index]);
@@ -1577,8 +1552,7 @@
}
template <typename TypeHandler>
-inline typename TypeHandler::Type*
-RepeatedPtrFieldBase::Mutable(int index) {
+inline typename TypeHandler::Type* RepeatedPtrFieldBase::Mutable(int index) {
GOOGLE_DCHECK_GE(index, 0);
GOOGLE_DCHECK_LT(index, current_size_);
return cast<TypeHandler>(rep_->elements[index]);
@@ -1653,8 +1627,8 @@
inline void RepeatedPtrFieldBase::MergeFrom(const RepeatedPtrFieldBase& other) {
GOOGLE_DCHECK_NE(&other, this);
if (other.current_size_ == 0) return;
- MergeFromInternal(
- other, &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
+ MergeFromInternal(other,
+ &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
}
inline void RepeatedPtrFieldBase::MergeFromInternal(
@@ -1665,8 +1639,8 @@
void** other_elements = other.rep_->elements;
void** new_elements = InternalExtend(other_size);
int allocated_elems = rep_->allocated_size - current_size_;
- (this->*inner_loop)(new_elements, other_elements,
- other_size, allocated_elems);
+ (this->*inner_loop)(new_elements, other_elements, other_size,
+ allocated_elems);
current_size_ += other_size;
if (rep_->allocated_size < current_size_) {
rep_->allocated_size = current_size_;
@@ -1674,9 +1648,10 @@
}
// Merges other_elems to our_elems.
-template<typename TypeHandler>
-void RepeatedPtrFieldBase::MergeFromInnerLoop(
- void** our_elems, void** other_elems, int length, int already_allocated) {
+template <typename TypeHandler>
+void RepeatedPtrFieldBase::MergeFromInnerLoop(void** our_elems,
+ void** other_elems, int length,
+ int already_allocated) {
// Split into two loops, over ranges [0, allocated) and [allocated, length),
// to avoid a branch within the loop.
for (int i = 0; i < already_allocated && i < length; i++) {
@@ -1706,9 +1681,7 @@
RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
}
-inline int RepeatedPtrFieldBase::Capacity() const {
- return total_size_;
-}
+inline int RepeatedPtrFieldBase::Capacity() const { return total_size_; }
inline void* const* RepeatedPtrFieldBase::raw_data() const {
return rep_ ? rep_->elements : NULL;
@@ -1726,8 +1699,8 @@
}
template <typename TypeHandler>
-inline const typename TypeHandler::Type* const*
-RepeatedPtrFieldBase::data() const {
+inline const typename TypeHandler::Type* const* RepeatedPtrFieldBase::data()
+ const {
// TODO(kenton): Breaks C++ aliasing rules. We should probably remove this
// method entirely.
return reinterpret_cast<const typename TypeHandler::Type* const*>(raw_data());
@@ -1743,8 +1716,8 @@
size_t allocated_bytes = static_cast<size_t>(total_size_) * sizeof(void*);
if (rep_ != NULL) {
for (int i = 0; i < rep_->allocated_size; ++i) {
- allocated_bytes += TypeHandler::SpaceUsedLong(
- *cast<TypeHandler>(rep_->elements[i]));
+ allocated_bytes +=
+ TypeHandler::SpaceUsedLong(*cast<TypeHandler>(rep_->elements[i]));
}
allocated_bytes += kRepHeaderSize;
}
@@ -1763,13 +1736,11 @@
// AddAllocated version that implements arena-safe copying behavior.
template <typename TypeHandler>
void RepeatedPtrFieldBase::AddAllocatedInternal(
- typename TypeHandler::Type* value,
- std::true_type) {
- Arena* element_arena = reinterpret_cast<Arena*>(
- TypeHandler::GetMaybeArenaPointer(value));
+ typename TypeHandler::Type* value, std::true_type) {
+ Arena* element_arena =
+ reinterpret_cast<Arena*>(TypeHandler::GetMaybeArenaPointer(value));
Arena* arena = GetArenaNoVirtual();
- if (arena == element_arena && rep_ &&
- rep_->allocated_size < total_size_) {
+ if (arena == element_arena && rep_ && rep_->allocated_size < total_size_) {
// Fast path: underlying arena representation (tagged pointer) is equal to
// our arena pointer, and we can add to array without resizing it (at least
// one slot that is not allocated).
@@ -1783,13 +1754,13 @@
current_size_ = current_size_ + 1;
rep_->allocated_size = rep_->allocated_size + 1;
} else {
- AddAllocatedSlowWithCopy<TypeHandler>(
- value, TypeHandler::GetArena(value), arena);
+ AddAllocatedSlowWithCopy<TypeHandler>(value, TypeHandler::GetArena(value),
+ arena);
}
}
// Slowpath handles all cases, copying if necessary.
-template<typename TypeHandler>
+template <typename TypeHandler>
void RepeatedPtrFieldBase::AddAllocatedSlowWithCopy(
// Pass value_arena and my_arena to avoid duplicate virtual call (value) or
// load (mine).
@@ -1813,9 +1784,8 @@
// AddAllocated version that does not implement arena-safe copying behavior.
template <typename TypeHandler>
void RepeatedPtrFieldBase::AddAllocatedInternal(
- typename TypeHandler::Type* value,
- std::false_type) {
- if (rep_ && rep_->allocated_size < total_size_) {
+ typename TypeHandler::Type* value, std::false_type) {
+ if (rep_ && rep_->allocated_size < total_size_) {
// Fast path: underlying arena representation (tagged pointer) is equal to
// our arena pointer, and we can add to array without resizing it (at least
// one slot that is not allocated).
@@ -1846,8 +1816,8 @@
// cleared objects awaiting reuse. We don't want to grow the array in this
// case because otherwise a loop calling AddAllocated() followed by Clear()
// would leak memory.
- TypeHandler::Delete(
- cast<TypeHandler>(rep_->elements[current_size_]), arena_);
+ TypeHandler::Delete(cast<TypeHandler>(rep_->elements[current_size_]),
+ arena_);
} else if (current_size_ < rep_->allocated_size) {
// We have some cleared objects. We don't care about their order, so we
// can just move the first one to the end to make space.
@@ -1863,8 +1833,8 @@
// ReleaseLast() for types that implement merge/copy behavior.
template <typename TypeHandler>
-inline typename TypeHandler::Type*
-RepeatedPtrFieldBase::ReleaseLastInternal(std::true_type) {
+inline typename TypeHandler::Type* RepeatedPtrFieldBase::ReleaseLastInternal(
+ std::true_type) {
// First, release an element.
typename TypeHandler::Type* result = UnsafeArenaReleaseLast<TypeHandler>();
// Now perform a copy if we're on an arena.
@@ -1884,8 +1854,8 @@
// an arena, since the user really should implement the copy operation in this
// case.
template <typename TypeHandler>
-inline typename TypeHandler::Type*
-RepeatedPtrFieldBase::ReleaseLastInternal(std::false_type) {
+inline typename TypeHandler::Type* RepeatedPtrFieldBase::ReleaseLastInternal(
+ std::false_type) {
GOOGLE_DCHECK(GetArenaNoVirtual() == NULL)
<< "ReleaseLast() called on a RepeatedPtrField that is on an arena, "
<< "with a type that does not implement MergeFrom. This is unsafe; "
@@ -1895,7 +1865,7 @@
template <typename TypeHandler>
inline typename TypeHandler::Type*
- RepeatedPtrFieldBase::UnsafeArenaReleaseLast() {
+RepeatedPtrFieldBase::UnsafeArenaReleaseLast() {
GOOGLE_DCHECK_GT(current_size_, 0);
typename TypeHandler::Type* result =
cast<TypeHandler>(rep_->elements[--current_size_]);
@@ -1942,16 +1912,14 @@
template <typename Element>
class RepeatedPtrField<Element>::TypeHandler
- : public internal::GenericTypeHandler<Element> {
-};
+ : public internal::GenericTypeHandler<Element> {};
template <>
class RepeatedPtrField<std::string>::TypeHandler
: public internal::StringTypeHandler {};
template <typename Element>
-inline RepeatedPtrField<Element>::RepeatedPtrField()
- : RepeatedPtrFieldBase() {}
+inline RepeatedPtrField<Element>::RepeatedPtrField() : RepeatedPtrFieldBase() {}
template <typename Element>
inline RepeatedPtrField<Element>::RepeatedPtrField(Arena* arena)
@@ -1960,14 +1928,14 @@
template <typename Element>
inline RepeatedPtrField<Element>::RepeatedPtrField(
const RepeatedPtrField& other)
- : RepeatedPtrFieldBase() {
+ : RepeatedPtrFieldBase() {
MergeFrom(other);
}
template <typename Element>
template <typename Iter>
-inline RepeatedPtrField<Element>::RepeatedPtrField(
- Iter begin, const Iter& end) {
+inline RepeatedPtrField<Element>::RepeatedPtrField(Iter begin,
+ const Iter& end) {
int reserve = internal::CalculateReserve(begin, end);
if (reserve != -1) {
Reserve(reserve);
@@ -1985,8 +1953,7 @@
template <typename Element>
inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
const RepeatedPtrField& other) {
- if (this != &other)
- CopyFrom(other);
+ if (this != &other) CopyFrom(other);
return *this;
}
@@ -1995,7 +1962,8 @@
RepeatedPtrField&& other) noexcept
: RepeatedPtrField() {
// We don't just call Swap(&other) here because it would perform 3 copies if
- // the two fields are on different arenas.
+ // other is on an arena. This field can't be on an arena because arena
+ // construction always uses the Arena* accepting constructor.
if (other.GetArenaNoVirtual()) {
CopyFrom(other);
} else {
@@ -2076,8 +2044,8 @@
}
template <typename Element>
-inline void RepeatedPtrField<Element>::ExtractSubrange(
- int start, int num, Element** elements) {
+inline void RepeatedPtrField<Element>::ExtractSubrange(int start, int num,
+ Element** elements) {
typename internal::TypeImplementsMergeBehavior<
typename TypeHandler::Type>::type t;
ExtractSubrangeInternal(start, num, elements, t);
@@ -2099,8 +2067,8 @@
// If we're on an arena, we perform a copy for each element so that the
// returned elements are heap-allocated.
for (int i = 0; i < num; ++i) {
- Element* element = RepeatedPtrFieldBase::
- Mutable<TypeHandler>(i + start);
+ Element* element =
+ RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
typename TypeHandler::Type* new_value =
TypeHandler::NewFromPrototype(element, NULL);
TypeHandler::Merge(*element, new_value);
@@ -2118,7 +2086,7 @@
// ExtractSubrange() implementation for types that do not implement merge/copy
// behavior.
-template<typename Element>
+template <typename Element>
inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
int start, int num, Element** elements, std::false_type) {
// This case is identical to UnsafeArenaExtractSubrange(). However, since
@@ -2161,8 +2129,7 @@
}
template <typename Element>
-inline void RepeatedPtrField<Element>::CopyFrom(
- const RepeatedPtrField& other) {
+inline void RepeatedPtrField<Element>::CopyFrom(const RepeatedPtrField& other) {
RepeatedPtrFieldBase::CopyFrom<TypeHandler>(other);
}
@@ -2193,16 +2160,14 @@
template <typename Element>
inline void RepeatedPtrField<Element>::Swap(RepeatedPtrField* other) {
- if (this == other)
- return;
+ if (this == other) return;
RepeatedPtrFieldBase::Swap<TypeHandler>(other);
}
template <typename Element>
inline void RepeatedPtrField<Element>::UnsafeArenaSwap(
RepeatedPtrField* other) {
- if (this == other)
- return;
+ if (this == other) return;
RepeatedPtrFieldBase::InternalSwap(other);
}
@@ -2281,31 +2246,22 @@
//
// This code based on net/proto/proto-array-internal.h by Jeffrey Yasskin
// (jyasskin@google.com).
-template<typename Element>
-class RepeatedPtrIterator
- : public std::iterator<
- std::random_access_iterator_tag, Element> {
+template <typename Element>
+class RepeatedPtrIterator {
public:
- typedef RepeatedPtrIterator<Element> iterator;
- typedef std::iterator<
- std::random_access_iterator_tag, Element> superclass;
-
- // Shadow the value_type in std::iterator<> because const_iterator::value_type
- // needs to be T, not const T.
- typedef typename std::remove_const<Element>::type value_type;
-
- // Let the compiler know that these are type names, so we don't have to
- // write "typename" in front of them everywhere.
- typedef typename superclass::reference reference;
- typedef typename superclass::pointer pointer;
- typedef typename superclass::difference_type difference_type;
+ using iterator = RepeatedPtrIterator<Element>;
+ using iterator_category = std::random_access_iterator_tag;
+ using value_type = typename std::remove_const<Element>::type;
+ using difference_type = std::ptrdiff_t;
+ using pointer = Element*;
+ using reference = Element&;
RepeatedPtrIterator() : it_(NULL) {}
explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
// Allow "upcasting" from RepeatedPtrIterator<T**> to
// RepeatedPtrIterator<const T*const*>.
- template<typename OtherElement>
+ template <typename OtherElement>
RepeatedPtrIterator(const RepeatedPtrIterator<OtherElement>& other)
: it_(other.it_) {
// Force a compiler error if the other type is not convertible to ours.
@@ -2316,13 +2272,19 @@
// dereferenceable
reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
- pointer operator->() const { return &(operator*()); }
+ pointer operator->() const { return &(operator*()); }
// {inc,dec}rementable
- iterator& operator++() { ++it_; return *this; }
- iterator operator++(int) { return iterator(it_++); }
- iterator& operator--() { --it_; return *this; }
- iterator operator--(int) { return iterator(it_--); }
+ iterator& operator++() {
+ ++it_;
+ return *this;
+ }
+ iterator operator++(int) { return iterator(it_++); }
+ iterator& operator--() {
+ --it_;
+ return *this;
+ }
+ iterator operator--(int) { return iterator(it_--); }
// equality_comparable
bool operator==(const iterator& x) const { return it_ == x.it_; }
@@ -2363,7 +2325,7 @@
difference_type operator-(const iterator& x) const { return it_ - x.it_; }
private:
- template<typename OtherElement>
+ template <typename OtherElement>
friend class RepeatedPtrIterator;
// The internal iterator.
@@ -2378,34 +2340,33 @@
// referenced by the iterator. It should either be "void *" for a mutable
// iterator, or "const void* const" for a constant iterator.
template <typename Element, typename VoidPtr>
-class RepeatedPtrOverPtrsIterator
- : public std::iterator<std::random_access_iterator_tag, Element> {
+class RepeatedPtrOverPtrsIterator {
public:
- typedef RepeatedPtrOverPtrsIterator<Element, VoidPtr> iterator;
- typedef std::iterator<std::random_access_iterator_tag, Element> superclass;
-
- // Shadow the value_type in std::iterator<> because const_iterator::value_type
- // needs to be T, not const T.
- typedef typename std::remove_const<Element>::type value_type;
-
- // Let the compiler know that these are type names, so we don't have to
- // write "typename" in front of them everywhere.
- typedef typename superclass::reference reference;
- typedef typename superclass::pointer pointer;
- typedef typename superclass::difference_type difference_type;
+ using iterator = RepeatedPtrOverPtrsIterator<Element, VoidPtr>;
+ using iterator_category = std::random_access_iterator_tag;
+ using value_type = typename std::remove_const<Element>::type;
+ using difference_type = std::ptrdiff_t;
+ using pointer = Element*;
+ using reference = Element&;
RepeatedPtrOverPtrsIterator() : it_(NULL) {}
explicit RepeatedPtrOverPtrsIterator(VoidPtr* it) : it_(it) {}
// dereferenceable
reference operator*() const { return *reinterpret_cast<Element*>(it_); }
- pointer operator->() const { return &(operator*()); }
+ pointer operator->() const { return &(operator*()); }
// {inc,dec}rementable
- iterator& operator++() { ++it_; return *this; }
- iterator operator++(int) { return iterator(it_++); }
- iterator& operator--() { --it_; return *this; }
- iterator operator--(int) { return iterator(it_--); }
+ iterator& operator++() {
+ ++it_;
+ return *this;
+ }
+ iterator operator++(int) { return iterator(it_++); }
+ iterator& operator--() {
+ --it_;
+ return *this;
+ }
+ iterator operator--(int) { return iterator(it_--); }
// equality_comparable
bool operator==(const iterator& x) const { return it_ == x.it_; }
@@ -2446,7 +2407,7 @@
difference_type operator-(const iterator& x) const { return it_ - x.it_; }
private:
- template<typename OtherElement>
+ template <typename OtherElement>
friend class RepeatedPtrIterator;
// The internal iterator.
@@ -2528,23 +2489,19 @@
namespace internal {
// A back inserter for RepeatedField objects.
-template<typename T> class RepeatedFieldBackInsertIterator
+template <typename T>
+class RepeatedFieldBackInsertIterator
: public std::iterator<std::output_iterator_tag, T> {
public:
explicit RepeatedFieldBackInsertIterator(
RepeatedField<T>* const mutable_field)
- : field_(mutable_field) {
- }
+ : field_(mutable_field) {}
RepeatedFieldBackInsertIterator<T>& operator=(const T& value) {
field_->Add(value);
return *this;
}
- RepeatedFieldBackInsertIterator<T>& operator*() {
- return *this;
- }
- RepeatedFieldBackInsertIterator<T>& operator++() {
- return *this;
- }
+ RepeatedFieldBackInsertIterator<T>& operator*() { return *this; }
+ RepeatedFieldBackInsertIterator<T>& operator++() { return *this; }
RepeatedFieldBackInsertIterator<T>& operator++(int /* unused */) {
return *this;
}
@@ -2554,13 +2511,12 @@
};
// A back inserter for RepeatedPtrField objects.
-template<typename T> class RepeatedPtrFieldBackInsertIterator
+template <typename T>
+class RepeatedPtrFieldBackInsertIterator
: public std::iterator<std::output_iterator_tag, T> {
public:
- RepeatedPtrFieldBackInsertIterator(
- RepeatedPtrField<T>* const mutable_field)
- : field_(mutable_field) {
- }
+ RepeatedPtrFieldBackInsertIterator(RepeatedPtrField<T>* const mutable_field)
+ : field_(mutable_field) {}
RepeatedPtrFieldBackInsertIterator<T>& operator=(const T& value) {
*field_->Add() = value;
return *this;
@@ -2574,12 +2530,8 @@
*field_->Add() = std::move(value);
return *this;
}
- RepeatedPtrFieldBackInsertIterator<T>& operator*() {
- return *this;
- }
- RepeatedPtrFieldBackInsertIterator<T>& operator++() {
- return *this;
- }
+ RepeatedPtrFieldBackInsertIterator<T>& operator*() { return *this; }
+ RepeatedPtrFieldBackInsertIterator<T>& operator++() { return *this; }
RepeatedPtrFieldBackInsertIterator<T>& operator++(int /* unused */) {
return *this;
}
@@ -2590,26 +2542,21 @@
// A back inserter for RepeatedPtrFields that inserts by transferring ownership
// of a pointer.
-template<typename T> class AllocatedRepeatedPtrFieldBackInsertIterator
+template <typename T>
+class AllocatedRepeatedPtrFieldBackInsertIterator
: public std::iterator<std::output_iterator_tag, T> {
public:
explicit AllocatedRepeatedPtrFieldBackInsertIterator(
RepeatedPtrField<T>* const mutable_field)
- : field_(mutable_field) {
- }
+ : field_(mutable_field) {}
AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
T* const ptr_to_value) {
field_->AddAllocated(ptr_to_value);
return *this;
}
- AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*() {
- return *this;
- }
- AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++() {
- return *this;
- }
- AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(
- int /* unused */) {
+ AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*() { return *this; }
+ AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++() { return *this; }
+ AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(int /* unused */) {
return *this;
}
@@ -2619,7 +2566,7 @@
// Almost identical to AllocatedRepeatedPtrFieldBackInsertIterator. This one
// uses the UnsafeArenaAddAllocated instead.
-template<typename T>
+template <typename T>
class UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator
: public std::iterator<std::output_iterator_tag, T> {
public:
@@ -2627,7 +2574,7 @@
RepeatedPtrField<T>* const mutable_field)
: field_(mutable_field) {}
UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
- T const* const ptr_to_value) {
+ T const* const ptr_to_value) {
field_->UnsafeArenaAddAllocated(const_cast<T*>(ptr_to_value));
return *this;
}
@@ -2650,30 +2597,34 @@
// Provides a back insert iterator for RepeatedField instances,
// similar to std::back_inserter().
-template<typename T> internal::RepeatedFieldBackInsertIterator<T>
-RepeatedFieldBackInserter(RepeatedField<T>* const mutable_field) {
+template <typename T>
+internal::RepeatedFieldBackInsertIterator<T> RepeatedFieldBackInserter(
+ RepeatedField<T>* const mutable_field) {
return internal::RepeatedFieldBackInsertIterator<T>(mutable_field);
}
// Provides a back insert iterator for RepeatedPtrField instances,
// similar to std::back_inserter().
-template<typename T> internal::RepeatedPtrFieldBackInsertIterator<T>
-RepeatedPtrFieldBackInserter(RepeatedPtrField<T>* const mutable_field) {
+template <typename T>
+internal::RepeatedPtrFieldBackInsertIterator<T> RepeatedPtrFieldBackInserter(
+ RepeatedPtrField<T>* const mutable_field) {
return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
}
// Special back insert iterator for RepeatedPtrField instances, just in
// case someone wants to write generic template code that can access both
// RepeatedFields and RepeatedPtrFields using a common name.
-template<typename T> internal::RepeatedPtrFieldBackInsertIterator<T>
-RepeatedFieldBackInserter(RepeatedPtrField<T>* const mutable_field) {
+template <typename T>
+internal::RepeatedPtrFieldBackInsertIterator<T> RepeatedFieldBackInserter(
+ RepeatedPtrField<T>* const mutable_field) {
return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
}
// Provides a back insert iterator for RepeatedPtrField instances
// similar to std::back_inserter() which transfers the ownership while
// copying elements.
-template<typename T> internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>
+template <typename T>
+internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>
AllocatedRepeatedPtrFieldBackInserter(
RepeatedPtrField<T>* const mutable_field) {
return internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>(
diff --git a/src/google/protobuf/repeated_field_reflection_unittest.cc b/src/google/protobuf/repeated_field_reflection_unittest.cc
index 6ec428e..0499102 100644
--- a/src/google/protobuf/repeated_field_reflection_unittest.cc
+++ b/src/google/protobuf/repeated_field_reflection_unittest.cc
@@ -35,9 +35,9 @@
#include <google/protobuf/stubs/casts.h>
#include <google/protobuf/stubs/stringprintf.h>
-#include <google/protobuf/dynamic_message.h>
-#include <google/protobuf/unittest.pb.h>
#include <google/protobuf/test_util.h>
+#include <google/protobuf/unittest.pb.h>
+#include <google/protobuf/dynamic_message.h>
#include <google/protobuf/reflection.h>
#include <gtest/gtest.h>
@@ -45,14 +45,12 @@
namespace protobuf {
using unittest::ForeignMessage;
-using unittest::TestAllTypes;
using unittest::TestAllExtensions;
+using unittest::TestAllTypes;
namespace {
-static int Func(int i, int j) {
- return i * j;
-}
+static int Func(int i, int j) { return i * j; }
static std::string StrFunc(int i, int j) {
std::string str;
@@ -98,11 +96,10 @@
const RepeatedPtrField<std::string>& rpf_string =
refl->GetRepeatedPtrField<std::string>(message, fd_repeated_string);
const RepeatedPtrField<ForeignMessage>& rpf_foreign_message =
- refl->GetRepeatedPtrField<ForeignMessage>(
- message, fd_repeated_foreign_message);
+ refl->GetRepeatedPtrField<ForeignMessage>(message,
+ fd_repeated_foreign_message);
const RepeatedPtrField<Message>& rpf_message =
- refl->GetRepeatedPtrField<Message>(
- message, fd_repeated_foreign_message);
+ refl->GetRepeatedPtrField<Message>(message, fd_repeated_foreign_message);
// Get mutable RepeatedPtrField objects for all fields of interest.
RepeatedPtrField<std::string>* mrpf_string =
@@ -111,8 +108,8 @@
refl->MutableRepeatedPtrField<ForeignMessage>(
&message, fd_repeated_foreign_message);
RepeatedPtrField<Message>* mrpf_message =
- refl->MutableRepeatedPtrField<Message>(
- &message, fd_repeated_foreign_message);
+ refl->MutableRepeatedPtrField<Message>(&message,
+ fd_repeated_foreign_message);
// Make sure we can do gets and sets through the Repeated[Ptr]Field objects.
for (int i = 0; i < 10; ++i) {
@@ -149,12 +146,13 @@
// Make sure types are checked correctly at runtime.
const FieldDescriptor* fd_optional_int32 =
desc->FindFieldByName("optional_int32");
- EXPECT_DEATH(refl->GetRepeatedField<int32>(
- message, fd_optional_int32), "requires a repeated field");
- EXPECT_DEATH(refl->GetRepeatedField<double>(
- message, fd_repeated_int32), "not the right type");
+ EXPECT_DEATH(refl->GetRepeatedField<int32>(message, fd_optional_int32),
+ "requires a repeated field");
+ EXPECT_DEATH(refl->GetRepeatedField<double>(message, fd_repeated_int32),
+ "not the right type");
EXPECT_DEATH(refl->GetRepeatedPtrField<TestAllTypes>(
- message, fd_repeated_foreign_message), "wrong submessage type");
+ message, fd_repeated_foreign_message),
+ "wrong submessage type");
#endif // PROTOBUF_HAS_DEATH_TEST
}
@@ -165,8 +163,8 @@
const Descriptor* desc = extended_message.GetDescriptor();
for (int i = 0; i < 10; ++i) {
- extended_message.AddExtension(
- unittest::repeated_int64_extension, Func(i, 1));
+ extended_message.AddExtension(unittest::repeated_int64_extension,
+ Func(i, 1));
}
const FieldDescriptor* fd_repeated_int64_extension =
@@ -177,15 +175,14 @@
refl->GetRepeatedField<int64>(extended_message,
fd_repeated_int64_extension);
- RepeatedField<int64>* mrf_int64_extension =
- refl->MutableRepeatedField<int64>(&extended_message,
- fd_repeated_int64_extension);
+ RepeatedField<int64>* mrf_int64_extension = refl->MutableRepeatedField<int64>(
+ &extended_message, fd_repeated_int64_extension);
for (int i = 0; i < 10; ++i) {
EXPECT_EQ(Func(i, 1), rf_int64_extension.Get(i));
mrf_int64_extension->Set(i, Func(i, -1));
- EXPECT_EQ(Func(i, -1),
- extended_message.GetExtension(unittest::repeated_int64_extension, i));
+ EXPECT_EQ(Func(i, -1), extended_message.GetExtension(
+ unittest::repeated_int64_extension, i));
}
}
@@ -194,8 +191,8 @@
const Ref& handle, const MessageType& message,
ValueType (MessageType::*GetFunc)(int) const) {
int index = 0;
- for (typename Ref::const_iterator it = handle.begin();
- it != handle.end(); ++it) {
+ for (typename Ref::const_iterator it = handle.begin(); it != handle.end();
+ ++it) {
EXPECT_EQ((message.*GetFunc)(index), *it);
++index;
}
@@ -248,11 +245,10 @@
const RepeatedFieldRef<std::string> rf_string =
refl->GetRepeatedFieldRef<std::string>(message, fd_repeated_string);
const RepeatedFieldRef<ForeignMessage> rf_foreign_message =
- refl->GetRepeatedFieldRef<ForeignMessage>(
- message, fd_repeated_foreign_message);
+ refl->GetRepeatedFieldRef<ForeignMessage>(message,
+ fd_repeated_foreign_message);
const RepeatedFieldRef<Message> rf_message =
- refl->GetRepeatedFieldRef<Message>(
- message, fd_repeated_foreign_message);
+ refl->GetRepeatedFieldRef<Message>(message, fd_repeated_foreign_message);
// Get MutableRepeatedFieldRef objects for all fields of interest.
const MutableRepeatedFieldRef<int32> mrf_int32 =
@@ -266,8 +262,8 @@
refl->GetMutableRepeatedFieldRef<ForeignMessage>(
&message, fd_repeated_foreign_message);
const MutableRepeatedFieldRef<Message> mrf_message =
- refl->GetMutableRepeatedFieldRef<Message>(
- &message, fd_repeated_foreign_message);
+ refl->GetMutableRepeatedFieldRef<Message>(&message,
+ fd_repeated_foreign_message);
EXPECT_EQ(message.repeated_int32_size(), rf_int32.size());
EXPECT_EQ(message.repeated_int32_size(), mrf_int32.size());
@@ -275,8 +271,7 @@
EXPECT_EQ(message.repeated_double_size(), mrf_double.size());
EXPECT_EQ(message.repeated_string_size(), rf_string.size());
EXPECT_EQ(message.repeated_string_size(), mrf_string.size());
- EXPECT_EQ(message.repeated_foreign_message_size(),
- rf_foreign_message.size());
+ EXPECT_EQ(message.repeated_foreign_message_size(), rf_foreign_message.size());
EXPECT_EQ(message.repeated_foreign_message_size(),
mrf_foreign_message.size());
EXPECT_EQ(message.repeated_foreign_message_size(), rf_message.size());
@@ -301,16 +296,19 @@
EXPECT_EQ(rf_string.Get(i), StrFunc(i, 5));
ForeignMessage scratch_space;
EXPECT_EQ(rf_foreign_message.Get(i, &scratch_space).c(), Func(i, 6));
- EXPECT_EQ(down_cast<const ForeignMessage&>(
- rf_message.Get(i, &scratch_space)).c(), Func(i, 6));
+ EXPECT_EQ(
+ down_cast<const ForeignMessage&>(rf_message.Get(i, &scratch_space)).c(),
+ Func(i, 6));
// Check gets through mutable objects.
EXPECT_EQ(mrf_int32.Get(i), Func(i, 1));
EXPECT_EQ(mrf_double.Get(i), Func(i, 2));
EXPECT_EQ(mrf_string.Get(i), StrFunc(i, 5));
EXPECT_EQ(mrf_foreign_message.Get(i, &scratch_space).c(), Func(i, 6));
- EXPECT_EQ(down_cast<const ForeignMessage&>(
- mrf_message.Get(i, &scratch_space)).c(), Func(i, 6));
+ EXPECT_EQ(
+ down_cast<const ForeignMessage&>(mrf_message.Get(i, &scratch_space))
+ .c(),
+ Func(i, 6));
// Check sets through mutable objects.
mrf_int32.Set(i, Func(i, -1));
@@ -431,12 +429,13 @@
// Make sure types are checked correctly at runtime.
const FieldDescriptor* fd_optional_int32 =
desc->FindFieldByName("optional_int32");
- EXPECT_DEATH(refl->GetRepeatedFieldRef<int32>(
- message, fd_optional_int32), "");
- EXPECT_DEATH(refl->GetRepeatedFieldRef<double>(
- message, fd_repeated_int32), "");
+ EXPECT_DEATH(refl->GetRepeatedFieldRef<int32>(message, fd_optional_int32),
+ "");
+ EXPECT_DEATH(refl->GetRepeatedFieldRef<double>(message, fd_repeated_int32),
+ "");
EXPECT_DEATH(refl->GetRepeatedFieldRef<TestAllTypes>(
- message, fd_repeated_foreign_message), "");
+ message, fd_repeated_foreign_message),
+ "");
#endif // PROTOBUF_HAS_DEATH_TEST
}
@@ -455,16 +454,14 @@
const RepeatedFieldRef<TestAllTypes::NestedEnum> enum_ref =
refl->GetRepeatedFieldRef<TestAllTypes::NestedEnum>(
message, fd_repeated_nested_enum);
- const MutableRepeatedFieldRef<TestAllTypes::NestedEnum>
- mutable_enum_ref =
+ const MutableRepeatedFieldRef<TestAllTypes::NestedEnum> mutable_enum_ref =
refl->GetMutableRepeatedFieldRef<TestAllTypes::NestedEnum>(
&message, fd_repeated_nested_enum);
const RepeatedFieldRef<int32> int32_ref =
- refl->GetRepeatedFieldRef<int32>(
- message, fd_repeated_nested_enum);
+ refl->GetRepeatedFieldRef<int32>(message, fd_repeated_nested_enum);
const MutableRepeatedFieldRef<int32> mutable_int32_ref =
- refl->GetMutableRepeatedFieldRef<int32>(
- &message, fd_repeated_nested_enum);
+ refl->GetMutableRepeatedFieldRef<int32>(&message,
+ fd_repeated_nested_enum);
EXPECT_EQ(message.repeated_nested_enum_size(), enum_ref.size());
EXPECT_EQ(message.repeated_nested_enum_size(), mutable_enum_ref.size());
@@ -539,8 +536,8 @@
const Descriptor* desc = extended_message.GetDescriptor();
for (int i = 0; i < 10; ++i) {
- extended_message.AddExtension(
- unittest::repeated_int64_extension, Func(i, 1));
+ extended_message.AddExtension(unittest::repeated_int64_extension,
+ Func(i, 1));
}
const FieldDescriptor* fd_repeated_int64_extension =
@@ -549,17 +546,17 @@
const RepeatedFieldRef<int64> rf_int64_extension =
refl->GetRepeatedFieldRef<int64>(extended_message,
- fd_repeated_int64_extension);
+ fd_repeated_int64_extension);
const MutableRepeatedFieldRef<int64> mrf_int64_extension =
refl->GetMutableRepeatedFieldRef<int64>(&extended_message,
- fd_repeated_int64_extension);
+ fd_repeated_int64_extension);
for (int i = 0; i < 10; ++i) {
EXPECT_EQ(Func(i, 1), rf_int64_extension.Get(i));
mrf_int64_extension.Set(i, Func(i, -1));
- EXPECT_EQ(Func(i, -1),
- extended_message.GetExtension(unittest::repeated_int64_extension, i));
+ EXPECT_EQ(Func(i, -1), extended_message.GetExtension(
+ unittest::repeated_int64_extension, i));
}
}
@@ -610,24 +607,20 @@
const MutableRepeatedFieldRef<ForeignMessage> mrf_foreign_message =
refl->GetMutableRepeatedFieldRef<ForeignMessage>(
&m0, fd_repeated_foreign_message);
- const MutableRepeatedFieldRef<TestAllTypes::NestedEnum>
- mrf_nested_enum =
+ const MutableRepeatedFieldRef<TestAllTypes::NestedEnum> mrf_nested_enum =
refl->GetMutableRepeatedFieldRef<TestAllTypes::NestedEnum>(
&m0, fd_repeated_nested_enum);
// Test MutableRepeatedRef::CopyFrom
- mrf_int32.CopyFrom(
- refl->GetRepeatedFieldRef<int32>(m1, fd_repeated_int32));
+ mrf_int32.CopyFrom(refl->GetRepeatedFieldRef<int32>(m1, fd_repeated_int32));
mrf_double.CopyFrom(
refl->GetRepeatedFieldRef<double>(m1, fd_repeated_double));
mrf_string.CopyFrom(
refl->GetRepeatedFieldRef<std::string>(m1, fd_repeated_string));
- mrf_foreign_message.CopyFrom(
- refl->GetRepeatedFieldRef<ForeignMessage>(
- m1, fd_repeated_foreign_message));
- mrf_nested_enum.CopyFrom(
- refl->GetRepeatedFieldRef<TestAllTypes::NestedEnum>(
- m1, fd_repeated_nested_enum));
+ mrf_foreign_message.CopyFrom(refl->GetRepeatedFieldRef<ForeignMessage>(
+ m1, fd_repeated_foreign_message));
+ mrf_nested_enum.CopyFrom(refl->GetRepeatedFieldRef<TestAllTypes::NestedEnum>(
+ m1, fd_repeated_nested_enum));
for (int i = 0; i < 10; ++i) {
EXPECT_EQ(Func(i, 11), m0.repeated_int32(i));
EXPECT_EQ(Func(i, 12), m0.repeated_double(i));
@@ -637,18 +630,15 @@
}
// Test MutableRepeatedRef::MergeFrom
- mrf_int32.MergeFrom(
- refl->GetRepeatedFieldRef<int32>(m2, fd_repeated_int32));
+ mrf_int32.MergeFrom(refl->GetRepeatedFieldRef<int32>(m2, fd_repeated_int32));
mrf_double.MergeFrom(
refl->GetRepeatedFieldRef<double>(m2, fd_repeated_double));
mrf_string.MergeFrom(
refl->GetRepeatedFieldRef<std::string>(m2, fd_repeated_string));
- mrf_foreign_message.MergeFrom(
- refl->GetRepeatedFieldRef<ForeignMessage>(
- m2, fd_repeated_foreign_message));
- mrf_nested_enum.MergeFrom(
- refl->GetRepeatedFieldRef<TestAllTypes::NestedEnum>(
- m2, fd_repeated_nested_enum));
+ mrf_foreign_message.MergeFrom(refl->GetRepeatedFieldRef<ForeignMessage>(
+ m2, fd_repeated_foreign_message));
+ mrf_nested_enum.MergeFrom(refl->GetRepeatedFieldRef<TestAllTypes::NestedEnum>(
+ m2, fd_repeated_nested_enum));
for (int i = 0; i < 10; ++i) {
EXPECT_EQ(Func(i, 21), m0.repeated_int32(i + 10));
EXPECT_EQ(Func(i, 22), m0.repeated_double(i + 10));
@@ -665,9 +655,8 @@
refl->GetMutableRepeatedFieldRef<double>(&m2, fd_repeated_double));
mrf_string.Swap(
refl->GetMutableRepeatedFieldRef<std::string>(&m2, fd_repeated_string));
- mrf_foreign_message.Swap(
- refl->GetMutableRepeatedFieldRef<ForeignMessage>(
- &m2, fd_repeated_foreign_message));
+ mrf_foreign_message.Swap(refl->GetMutableRepeatedFieldRef<ForeignMessage>(
+ &m2, fd_repeated_foreign_message));
mrf_nested_enum.Swap(
refl->GetMutableRepeatedFieldRef<TestAllTypes::NestedEnum>(
&m2, fd_repeated_nested_enum));
@@ -710,12 +699,12 @@
const Reflection* refl = dynamic_message->GetReflection();
MutableRepeatedFieldRef<int32> rf_int32 =
- refl->GetMutableRepeatedFieldRef<int32>(
- dynamic_message.get(), fd_repeated_int32);
+ refl->GetMutableRepeatedFieldRef<int32>(dynamic_message.get(),
+ fd_repeated_int32);
rf_int32.Add(1234);
EXPECT_EQ(1, refl->FieldSize(*dynamic_message, fd_repeated_int32));
- EXPECT_EQ(1234, refl->GetRepeatedInt32(*dynamic_message,
- fd_repeated_int32, 0));
+ EXPECT_EQ(1234,
+ refl->GetRepeatedInt32(*dynamic_message, fd_repeated_int32, 0));
}
} // namespace
diff --git a/src/google/protobuf/repeated_field_unittest.cc b/src/google/protobuf/repeated_field_unittest.cc
index 25ee24c..610cb91 100644
--- a/src/google/protobuf/repeated_field_unittest.cc
+++ b/src/google/protobuf/repeated_field_unittest.cc
@@ -629,27 +629,23 @@
for (int start = 0; start < sz - num; ++start) {
// Create RepeatedField with sz elements having values 0 through sz-1.
RepeatedField<int32> field;
- for (int i = 0; i < sz; ++i)
- field.Add(i);
+ for (int i = 0; i < sz; ++i) field.Add(i);
EXPECT_EQ(field.size(), sz);
// Create a catcher array and call ExtractSubrange.
int32 catcher[10];
- for (int i = 0; i < 10; ++i)
- catcher[i] = -1;
+ for (int i = 0; i < 10; ++i) catcher[i] = -1;
field.ExtractSubrange(start, num, catcher);
// Does the resulting array have the right size?
EXPECT_EQ(field.size(), sz - num);
// Were the removed elements extracted into the catcher array?
- for (int i = 0; i < num; ++i)
- EXPECT_EQ(catcher[i], start + i);
+ for (int i = 0; i < num; ++i) EXPECT_EQ(catcher[i], start + i);
EXPECT_EQ(catcher[num], -1);
// Does the resulting array contain the right values?
- for (int i = 0; i < start; ++i)
- EXPECT_EQ(field.Get(i), i);
+ for (int i = 0; i < start; ++i) EXPECT_EQ(field.Get(i), i);
for (int i = start; i < field.size(); ++i)
EXPECT_EQ(field.Get(i), i + num);
}
@@ -1279,15 +1275,13 @@
field.AddAllocated(subject[i]);
}
EXPECT_EQ(field.size(), sz + extra);
- for (int i = 0; i < extra; ++i)
- field.RemoveLast();
+ for (int i = 0; i < extra; ++i) field.RemoveLast();
EXPECT_EQ(field.size(), sz);
EXPECT_EQ(field.ClearedCount(), extra);
// Create a catcher array and call ExtractSubrange.
std::string* catcher[10];
- for (int i = 0; i < 10; ++i)
- catcher[i] = NULL;
+ for (int i = 0; i < 10; ++i) catcher[i] = NULL;
field.ExtractSubrange(start, num, catcher);
// Does the resulting array have the right size?
@@ -1306,8 +1300,7 @@
// Reinstate the cleared elements.
EXPECT_EQ(field.ClearedCount(), extra);
- for (int i = 0; i < extra; ++i)
- field.Add();
+ for (int i = 0; i < extra; ++i) field.Add();
EXPECT_EQ(field.ClearedCount(), 0);
EXPECT_EQ(field.size(), sz - num + extra);
@@ -1315,15 +1308,13 @@
for (int i = sz; i < sz + extra; ++i) {
int count = 0;
for (int j = sz; j < sz + extra; ++j) {
- if (field.Mutable(j - num) == subject[i])
- count += 1;
+ if (field.Mutable(j - num) == subject[i]) count += 1;
}
EXPECT_EQ(count, 1);
}
// Release the caught elements.
- for (int i = 0; i < num; ++i)
- delete catcher[i];
+ for (int i = 0; i < num; ++i) delete catcher[i];
}
}
}
@@ -1719,7 +1710,6 @@
EXPECT_EQ("y", proto_array_.Get(9));
}
-
// -----------------------------------------------------------------------------
// Unit-tests for the insert iterators
// google::protobuf::RepeatedFieldBackInserter,
@@ -1785,8 +1775,7 @@
};
TEST_F(RepeatedFieldInsertionIteratorsTest, Fibonacci) {
- EXPECT_TRUE(std::equal(fibonacci.begin(),
- fibonacci.end(),
+ EXPECT_TRUE(std::equal(fibonacci.begin(), fibonacci.end(),
protobuffer.repeated_int32().begin()));
EXPECT_TRUE(std::equal(protobuffer.repeated_int32().begin(),
protobuffer.repeated_int32().end(),
@@ -1794,12 +1783,10 @@
}
TEST_F(RepeatedFieldInsertionIteratorsTest, Halves) {
- EXPECT_TRUE(std::equal(halves.begin(),
- halves.end(),
+ EXPECT_TRUE(std::equal(halves.begin(), halves.end(),
protobuffer.repeated_double().begin()));
EXPECT_TRUE(std::equal(protobuffer.repeated_double().begin(),
- protobuffer.repeated_double().end(),
- halves.begin()));
+ protobuffer.repeated_double().end(), halves.begin()));
}
TEST_F(RepeatedFieldInsertionIteratorsTest, Words) {
@@ -1817,8 +1804,9 @@
words.push_back("six");
words.push_back("pence");
protobuffer.mutable_repeated_string()->Clear();
- std::copy(words.begin(), words.end(), RepeatedPtrFieldBackInserter(
- protobuffer.mutable_repeated_string()));
+ std::copy(
+ words.begin(), words.end(),
+ RepeatedPtrFieldBackInserter(protobuffer.mutable_repeated_string()));
ASSERT_EQ(words.size(), protobuffer.repeated_string_size());
for (int i = 0; i < words.size(); ++i)
EXPECT_EQ(words.at(i), protobuffer.repeated_string(i));
@@ -1864,8 +1852,9 @@
*new_data = "name-" + StrCat(i);
}
TestAllTypes testproto;
- std::copy(data.begin(), data.end(), AllocatedRepeatedPtrFieldBackInserter(
- testproto.mutable_repeated_string()));
+ std::copy(data.begin(), data.end(),
+ AllocatedRepeatedPtrFieldBackInserter(
+ testproto.mutable_repeated_string()));
EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString());
}
diff --git a/src/google/protobuf/service.cc b/src/google/protobuf/service.cc
index a6616b4..5394568 100644
--- a/src/google/protobuf/service.cc
+++ b/src/google/protobuf/service.cc
@@ -43,4 +43,3 @@
} // namespace protobuf
} // namespace google
-
diff --git a/src/google/protobuf/service.h b/src/google/protobuf/service.h
index a9339eb..d6b4ab8 100644
--- a/src/google/protobuf/service.h
+++ b/src/google/protobuf/service.h
@@ -119,10 +119,10 @@
class RpcChannel;
// Defined in other files.
-class Descriptor; // descriptor.h
-class ServiceDescriptor; // descriptor.h
-class MethodDescriptor; // descriptor.h
-class Message; // message.h
+class Descriptor; // descriptor.h
+class ServiceDescriptor; // descriptor.h
+class MethodDescriptor; // descriptor.h
+class Message; // message.h
// Abstract base interface for protocol-buffer-based RPC services. Services
// themselves are abstract interfaces (implemented either by servers or as
@@ -137,10 +137,7 @@
// When constructing a stub, you may pass STUB_OWNS_CHANNEL as the second
// parameter to the constructor to tell it to delete its RpcChannel when
// destroyed.
- enum ChannelOwnership {
- STUB_OWNS_CHANNEL,
- STUB_DOESNT_OWN_CHANNEL
- };
+ enum ChannelOwnership { STUB_OWNS_CHANNEL, STUB_DOESNT_OWN_CHANNEL };
// Get the ServiceDescriptor describing this service and its methods.
virtual const ServiceDescriptor* GetDescriptor() = 0;
@@ -171,10 +168,8 @@
// RpcController can be queried to determine if an error occurred and
// possibly to get more information about the error.
virtual void CallMethod(const MethodDescriptor* method,
- RpcController* controller,
- const Message* request,
- Message* response,
- Closure* done) = 0;
+ RpcController* controller, const Message* request,
+ Message* response, Closure* done) = 0;
// CallMethod() requires that the request and response passed in are of a
// particular subclass of Message. GetRequestPrototype() and
@@ -190,9 +185,9 @@
// request->ParseFromString(input);
// service->CallMethod(method, *request, response, callback);
virtual const Message& GetRequestPrototype(
- const MethodDescriptor* method) const = 0;
+ const MethodDescriptor* method) const = 0;
virtual const Message& GetResponsePrototype(
- const MethodDescriptor* method) const = 0;
+ const MethodDescriptor* method) const = 0;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Service);
@@ -283,10 +278,8 @@
// need not be of any specific class as long as their descriptors are
// method->input_type() and method->output_type().
virtual void CallMethod(const MethodDescriptor* method,
- RpcController* controller,
- const Message* request,
- Message* response,
- Closure* done) = 0;
+ RpcController* controller, const Message* request,
+ Message* response, Closure* done) = 0;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RpcChannel);
diff --git a/src/google/protobuf/source_context.pb.cc b/src/google/protobuf/source_context.pb.cc
index 477091b..1f66be5 100644
--- a/src/google/protobuf/source_context.pb.cc
+++ b/src/google/protobuf/source_context.pb.cc
@@ -36,10 +36,6 @@
PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SourceContext_google_2fprotobuf_2fsource_5fcontext_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSourceContext_google_2fprotobuf_2fsource_5fcontext_2eproto}, {}};
-void InitDefaults_google_2fprotobuf_2fsource_5fcontext_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SourceContext_google_2fprotobuf_2fsource_5fcontext_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2fsource_5fcontext_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2fsource_5fcontext_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fsource_5fcontext_2eproto = nullptr;
@@ -76,8 +72,7 @@
"pesb\006proto3"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fsource_5fcontext_2eproto = {
- false, InitDefaults_google_2fprotobuf_2fsource_5fcontext_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2fsource_5fcontext_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2fsource_5fcontext_2eproto,
"google/protobuf/source_context.proto", &assign_descriptors_table_google_2fprotobuf_2fsource_5fcontext_2eproto, 251,
};
@@ -85,6 +80,7 @@
static constexpr ::PROTOBUF_NAMESPACE_ID::internal::InitFunc deps[1] =
{
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SourceContext_google_2fprotobuf_2fsource_5fcontext_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2fsource_5fcontext_2eproto, deps, 0);
}
@@ -156,31 +152,37 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* SourceContext::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// string file_name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_file_name(), ptr, ctx, "google.protobuf.SourceContext.file_name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool SourceContext::MergePartialFromCodedStream(
diff --git a/src/google/protobuf/struct.pb.cc b/src/google/protobuf/struct.pb.cc
index aed2db9..a34cac3 100644
--- a/src/google/protobuf/struct.pb.cc
+++ b/src/google/protobuf/struct.pb.cc
@@ -72,10 +72,6 @@
PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ListValue_google_2fprotobuf_2fstruct_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsListValue_google_2fprotobuf_2fstruct_2eproto}, {}};
-void InitDefaults_google_2fprotobuf_2fstruct_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ListValue_google_2fprotobuf_2fstruct_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2fstruct_2eproto[4];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2fstruct_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fstruct_2eproto = nullptr;
@@ -155,8 +151,7 @@
"3"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fstruct_2eproto = {
- false, InitDefaults_google_2fprotobuf_2fstruct_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2fstruct_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2fstruct_2eproto,
"google/protobuf/struct.proto", &assign_descriptors_table_google_2fprotobuf_2fstruct_2eproto, 641,
};
@@ -164,6 +159,7 @@
static constexpr ::PROTOBUF_NAMESPACE_ID::internal::InitFunc deps[1] =
{
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ListValue_google_2fprotobuf_2fstruct_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2fstruct_2eproto, deps, 0);
}
@@ -276,35 +272,43 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// map<string, .google.protobuf.Value> fields = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(&fields_, ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 10 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 10) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Struct::MergePartialFromCodedStream(
@@ -776,17 +780,18 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Value::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// .google.protobuf.NullValue null_value = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
set_null_value(static_cast<PROTOBUF_NAMESPACE_ID::NullValue>(val));
break;
}
@@ -801,43 +806,48 @@
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_string_value(), ptr, ctx, "google.protobuf.Value.string_value");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// bool bool_value = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 32) goto handle_unusual;
set_bool_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// .google.protobuf.Struct struct_value = 5;
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 42) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_struct_value(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// .google.protobuf.ListValue list_value = 6;
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 50) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_list_value(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Value::MergePartialFromCodedStream(
@@ -1293,35 +1303,43 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* ListValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// repeated .google.protobuf.Value values = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_values(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 10 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 10) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool ListValue::MergePartialFromCodedStream(
diff --git a/src/google/protobuf/struct.pb.h b/src/google/protobuf/struct.pb.h
index c4979a7..ca8c534 100644
--- a/src/google/protobuf/struct.pb.h
+++ b/src/google/protobuf/struct.pb.h
@@ -79,7 +79,7 @@
PROTOBUF_NAMESPACE_CLOSE
PROTOBUF_NAMESPACE_OPEN
-enum NullValue {
+enum NullValue : int {
NULL_VALUE = 0,
NullValue_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
NullValue_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
@@ -90,9 +90,13 @@
constexpr int NullValue_ARRAYSIZE = NullValue_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NullValue_descriptor();
-inline const std::string& NullValue_Name(NullValue value) {
+template<typename T>
+inline const std::string& NullValue_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, NullValue>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function NullValue_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
- NullValue_descriptor(), value);
+ NullValue_descriptor(), enum_t_value);
}
inline bool NullValue_Parse(
const std::string& name, NullValue* value) {
@@ -116,10 +120,10 @@
Struct_FieldsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
void MergeFrom(const Struct_FieldsEntry_DoNotUse& other);
static const Struct_FieldsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Struct_FieldsEntry_DoNotUse*>(&_Struct_FieldsEntry_DoNotUse_default_instance_); }
- bool ValidateKey() const {
- return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(key().data(), key().size(), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.protobuf.Struct.FieldsEntry.key");
+ static bool ValidateKey(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), s->size(), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.protobuf.Struct.FieldsEntry.key");
}
- bool ValidateValue() const { return true; }
+ static bool ValidateValue(void*) { return true; }
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const;
};
diff --git a/src/google/protobuf/struct.proto b/src/google/protobuf/struct.proto
index 7d7808e..ed990e3 100644
--- a/src/google/protobuf/struct.proto
+++ b/src/google/protobuf/struct.proto
@@ -40,7 +40,6 @@
option java_multiple_files = true;
option objc_class_prefix = "GPB";
-
// `Struct` represents a structured data value, consisting of fields
// which map to dynamically typed values. In some languages, `Struct`
// might be supported by a native representation. For example, in
diff --git a/src/google/protobuf/test_util.inc b/src/google/protobuf/test_util.inc
index ab80b69..7c1bfc1 100644
--- a/src/google/protobuf/test_util.inc
+++ b/src/google/protobuf/test_util.inc
@@ -41,7 +41,6 @@
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/message.h>
-#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
namespace google {
diff --git a/src/google/protobuf/test_util_lite.cc b/src/google/protobuf/test_util_lite.cc
index 81728df..a83d109 100644
--- a/src/google/protobuf/test_util_lite.cc
+++ b/src/google/protobuf/test_util_lite.cc
@@ -42,112 +42,112 @@
namespace protobuf {
void TestUtilLite::SetAllFields(unittest::TestAllTypesLite* message) {
- message->set_optional_int32 (101);
- message->set_optional_int64 (102);
- message->set_optional_uint32 (103);
- message->set_optional_uint64 (104);
- message->set_optional_sint32 (105);
- message->set_optional_sint64 (106);
- message->set_optional_fixed32 (107);
- message->set_optional_fixed64 (108);
+ message->set_optional_int32(101);
+ message->set_optional_int64(102);
+ message->set_optional_uint32(103);
+ message->set_optional_uint64(104);
+ message->set_optional_sint32(105);
+ message->set_optional_sint64(106);
+ message->set_optional_fixed32(107);
+ message->set_optional_fixed64(108);
message->set_optional_sfixed32(109);
message->set_optional_sfixed64(110);
- message->set_optional_float (111);
- message->set_optional_double (112);
- message->set_optional_bool (true);
- message->set_optional_string ("115");
- message->set_optional_bytes ("116");
+ message->set_optional_float(111);
+ message->set_optional_double(112);
+ message->set_optional_bool(true);
+ message->set_optional_string("115");
+ message->set_optional_bytes("116");
- message->mutable_optionalgroup ()->set_a(117);
- message->mutable_optional_nested_message ()->set_bb(118);
- message->mutable_optional_foreign_message ()->set_c(119);
- message->mutable_optional_import_message ()->set_d(120);
+ message->mutable_optionalgroup()->set_a(117);
+ message->mutable_optional_nested_message()->set_bb(118);
+ message->mutable_optional_foreign_message()->set_c(119);
+ message->mutable_optional_import_message()->set_d(120);
message->mutable_optional_public_import_message()->set_e(126);
- message->mutable_optional_lazy_message ()->set_bb(127);
+ message->mutable_optional_lazy_message()->set_bb(127);
- message->set_optional_nested_enum (unittest::TestAllTypesLite::BAZ );
- message->set_optional_foreign_enum(unittest::FOREIGN_LITE_BAZ );
- message->set_optional_import_enum (unittest_import::IMPORT_LITE_BAZ);
+ message->set_optional_nested_enum(unittest::TestAllTypesLite::BAZ);
+ message->set_optional_foreign_enum(unittest::FOREIGN_LITE_BAZ);
+ message->set_optional_import_enum(unittest_import::IMPORT_LITE_BAZ);
// -----------------------------------------------------------------
- message->add_repeated_int32 (201);
- message->add_repeated_int64 (202);
- message->add_repeated_uint32 (203);
- message->add_repeated_uint64 (204);
- message->add_repeated_sint32 (205);
- message->add_repeated_sint64 (206);
- message->add_repeated_fixed32 (207);
- message->add_repeated_fixed64 (208);
+ message->add_repeated_int32(201);
+ message->add_repeated_int64(202);
+ message->add_repeated_uint32(203);
+ message->add_repeated_uint64(204);
+ message->add_repeated_sint32(205);
+ message->add_repeated_sint64(206);
+ message->add_repeated_fixed32(207);
+ message->add_repeated_fixed64(208);
message->add_repeated_sfixed32(209);
message->add_repeated_sfixed64(210);
- message->add_repeated_float (211);
- message->add_repeated_double (212);
- message->add_repeated_bool (true);
- message->add_repeated_string ("215");
- message->add_repeated_bytes ("216");
+ message->add_repeated_float(211);
+ message->add_repeated_double(212);
+ message->add_repeated_bool(true);
+ message->add_repeated_string("215");
+ message->add_repeated_bytes("216");
- message->add_repeatedgroup ()->set_a(217);
- message->add_repeated_nested_message ()->set_bb(218);
+ message->add_repeatedgroup()->set_a(217);
+ message->add_repeated_nested_message()->set_bb(218);
message->add_repeated_foreign_message()->set_c(219);
- message->add_repeated_import_message ()->set_d(220);
- message->add_repeated_lazy_message ()->set_bb(227);
+ message->add_repeated_import_message()->set_d(220);
+ message->add_repeated_lazy_message()->set_bb(227);
- message->add_repeated_nested_enum (unittest::TestAllTypesLite::BAR );
- message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAR );
- message->add_repeated_import_enum (unittest_import::IMPORT_LITE_BAR);
+ message->add_repeated_nested_enum(unittest::TestAllTypesLite::BAR);
+ message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAR);
+ message->add_repeated_import_enum(unittest_import::IMPORT_LITE_BAR);
// Add a second one of each field.
- message->add_repeated_int32 (301);
- message->add_repeated_int64 (302);
- message->add_repeated_uint32 (303);
- message->add_repeated_uint64 (304);
- message->add_repeated_sint32 (305);
- message->add_repeated_sint64 (306);
- message->add_repeated_fixed32 (307);
- message->add_repeated_fixed64 (308);
+ message->add_repeated_int32(301);
+ message->add_repeated_int64(302);
+ message->add_repeated_uint32(303);
+ message->add_repeated_uint64(304);
+ message->add_repeated_sint32(305);
+ message->add_repeated_sint64(306);
+ message->add_repeated_fixed32(307);
+ message->add_repeated_fixed64(308);
message->add_repeated_sfixed32(309);
message->add_repeated_sfixed64(310);
- message->add_repeated_float (311);
- message->add_repeated_double (312);
- message->add_repeated_bool (false);
- message->add_repeated_string ("315");
- message->add_repeated_bytes ("316");
+ message->add_repeated_float(311);
+ message->add_repeated_double(312);
+ message->add_repeated_bool(false);
+ message->add_repeated_string("315");
+ message->add_repeated_bytes("316");
- message->add_repeatedgroup ()->set_a(317);
- message->add_repeated_nested_message ()->set_bb(318);
+ message->add_repeatedgroup()->set_a(317);
+ message->add_repeated_nested_message()->set_bb(318);
message->add_repeated_foreign_message()->set_c(319);
- message->add_repeated_import_message ()->set_d(320);
- message->add_repeated_lazy_message ()->set_bb(327);
+ message->add_repeated_import_message()->set_d(320);
+ message->add_repeated_lazy_message()->set_bb(327);
- message->add_repeated_nested_enum (unittest::TestAllTypesLite::BAZ );
- message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAZ );
- message->add_repeated_import_enum (unittest_import::IMPORT_LITE_BAZ);
+ message->add_repeated_nested_enum(unittest::TestAllTypesLite::BAZ);
+ message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAZ);
+ message->add_repeated_import_enum(unittest_import::IMPORT_LITE_BAZ);
// -----------------------------------------------------------------
- message->set_default_int32 (401);
- message->set_default_int64 (402);
- message->set_default_uint32 (403);
- message->set_default_uint64 (404);
- message->set_default_sint32 (405);
- message->set_default_sint64 (406);
- message->set_default_fixed32 (407);
- message->set_default_fixed64 (408);
+ message->set_default_int32(401);
+ message->set_default_int64(402);
+ message->set_default_uint32(403);
+ message->set_default_uint64(404);
+ message->set_default_sint32(405);
+ message->set_default_sint64(406);
+ message->set_default_fixed32(407);
+ message->set_default_fixed64(408);
message->set_default_sfixed32(409);
message->set_default_sfixed64(410);
- message->set_default_float (411);
- message->set_default_double (412);
- message->set_default_bool (false);
- message->set_default_string ("415");
- message->set_default_bytes ("416");
+ message->set_default_float(411);
+ message->set_default_double(412);
+ message->set_default_bool(false);
+ message->set_default_string("415");
+ message->set_default_bytes("416");
- message->set_default_nested_enum (unittest::TestAllTypesLite::FOO );
- message->set_default_foreign_enum(unittest::FOREIGN_LITE_FOO );
- message->set_default_import_enum (unittest_import::IMPORT_LITE_FOO);
+ message->set_default_nested_enum(unittest::TestAllTypesLite::FOO);
+ message->set_default_foreign_enum(unittest::FOREIGN_LITE_FOO);
+ message->set_default_import_enum(unittest_import::IMPORT_LITE_FOO);
message->set_oneof_uint32(601);
@@ -159,31 +159,31 @@
// -------------------------------------------------------------------
void TestUtilLite::ModifyRepeatedFields(unittest::TestAllTypesLite* message) {
- message->set_repeated_int32 (1, 501);
- message->set_repeated_int64 (1, 502);
- message->set_repeated_uint32 (1, 503);
- message->set_repeated_uint64 (1, 504);
- message->set_repeated_sint32 (1, 505);
- message->set_repeated_sint64 (1, 506);
- message->set_repeated_fixed32 (1, 507);
- message->set_repeated_fixed64 (1, 508);
+ message->set_repeated_int32(1, 501);
+ message->set_repeated_int64(1, 502);
+ message->set_repeated_uint32(1, 503);
+ message->set_repeated_uint64(1, 504);
+ message->set_repeated_sint32(1, 505);
+ message->set_repeated_sint64(1, 506);
+ message->set_repeated_fixed32(1, 507);
+ message->set_repeated_fixed64(1, 508);
message->set_repeated_sfixed32(1, 509);
message->set_repeated_sfixed64(1, 510);
- message->set_repeated_float (1, 511);
- message->set_repeated_double (1, 512);
- message->set_repeated_bool (1, true);
- message->set_repeated_string (1, "515");
- message->set_repeated_bytes (1, "516");
+ message->set_repeated_float(1, 511);
+ message->set_repeated_double(1, 512);
+ message->set_repeated_bool(1, true);
+ message->set_repeated_string(1, "515");
+ message->set_repeated_bytes(1, "516");
- message->mutable_repeatedgroup (1)->set_a(517);
- message->mutable_repeated_nested_message (1)->set_bb(518);
+ message->mutable_repeatedgroup(1)->set_a(517);
+ message->mutable_repeated_nested_message(1)->set_bb(518);
message->mutable_repeated_foreign_message(1)->set_c(519);
- message->mutable_repeated_import_message (1)->set_d(520);
- message->mutable_repeated_lazy_message (1)->set_bb(527);
+ message->mutable_repeated_import_message(1)->set_d(520);
+ message->mutable_repeated_lazy_message(1)->set_bb(527);
- message->set_repeated_nested_enum (1, unittest::TestAllTypesLite::FOO );
- message->set_repeated_foreign_enum(1, unittest::FOREIGN_LITE_FOO );
- message->set_repeated_import_enum (1, unittest_import::IMPORT_LITE_FOO);
+ message->set_repeated_nested_enum(1, unittest::TestAllTypesLite::FOO);
+ message->set_repeated_foreign_enum(1, unittest::FOREIGN_LITE_FOO);
+ message->set_repeated_import_enum(1, unittest_import::IMPORT_LITE_FOO);
}
@@ -191,199 +191,199 @@
void TestUtilLite::ExpectAllFieldsSet(
const unittest::TestAllTypesLite& message) {
- EXPECT_TRUE(message.has_optional_int32 ());
- EXPECT_TRUE(message.has_optional_int64 ());
- EXPECT_TRUE(message.has_optional_uint32 ());
- EXPECT_TRUE(message.has_optional_uint64 ());
- EXPECT_TRUE(message.has_optional_sint32 ());
- EXPECT_TRUE(message.has_optional_sint64 ());
- EXPECT_TRUE(message.has_optional_fixed32 ());
- EXPECT_TRUE(message.has_optional_fixed64 ());
+ EXPECT_TRUE(message.has_optional_int32());
+ EXPECT_TRUE(message.has_optional_int64());
+ EXPECT_TRUE(message.has_optional_uint32());
+ EXPECT_TRUE(message.has_optional_uint64());
+ EXPECT_TRUE(message.has_optional_sint32());
+ EXPECT_TRUE(message.has_optional_sint64());
+ EXPECT_TRUE(message.has_optional_fixed32());
+ EXPECT_TRUE(message.has_optional_fixed64());
EXPECT_TRUE(message.has_optional_sfixed32());
EXPECT_TRUE(message.has_optional_sfixed64());
- EXPECT_TRUE(message.has_optional_float ());
- EXPECT_TRUE(message.has_optional_double ());
- EXPECT_TRUE(message.has_optional_bool ());
- EXPECT_TRUE(message.has_optional_string ());
- EXPECT_TRUE(message.has_optional_bytes ());
+ EXPECT_TRUE(message.has_optional_float());
+ EXPECT_TRUE(message.has_optional_double());
+ EXPECT_TRUE(message.has_optional_bool());
+ EXPECT_TRUE(message.has_optional_string());
+ EXPECT_TRUE(message.has_optional_bytes());
- EXPECT_TRUE(message.has_optionalgroup ());
- EXPECT_TRUE(message.has_optional_nested_message ());
- EXPECT_TRUE(message.has_optional_foreign_message ());
- EXPECT_TRUE(message.has_optional_import_message ());
+ EXPECT_TRUE(message.has_optionalgroup());
+ EXPECT_TRUE(message.has_optional_nested_message());
+ EXPECT_TRUE(message.has_optional_foreign_message());
+ EXPECT_TRUE(message.has_optional_import_message());
EXPECT_TRUE(message.has_optional_public_import_message());
- EXPECT_TRUE(message.has_optional_lazy_message ());
+ EXPECT_TRUE(message.has_optional_lazy_message());
- EXPECT_TRUE(message.optionalgroup ().has_a());
- EXPECT_TRUE(message.optional_nested_message ().has_bb());
- EXPECT_TRUE(message.optional_foreign_message ().has_c());
- EXPECT_TRUE(message.optional_import_message ().has_d());
+ EXPECT_TRUE(message.optionalgroup().has_a());
+ EXPECT_TRUE(message.optional_nested_message().has_bb());
+ EXPECT_TRUE(message.optional_foreign_message().has_c());
+ EXPECT_TRUE(message.optional_import_message().has_d());
EXPECT_TRUE(message.optional_public_import_message().has_e());
- EXPECT_TRUE(message.optional_lazy_message ().has_bb());
+ EXPECT_TRUE(message.optional_lazy_message().has_bb());
- EXPECT_TRUE(message.has_optional_nested_enum ());
+ EXPECT_TRUE(message.has_optional_nested_enum());
EXPECT_TRUE(message.has_optional_foreign_enum());
- EXPECT_TRUE(message.has_optional_import_enum ());
+ EXPECT_TRUE(message.has_optional_import_enum());
- EXPECT_EQ(101 , message.optional_int32 ());
- EXPECT_EQ(102 , message.optional_int64 ());
- EXPECT_EQ(103 , message.optional_uint32 ());
- EXPECT_EQ(104 , message.optional_uint64 ());
- EXPECT_EQ(105 , message.optional_sint32 ());
- EXPECT_EQ(106 , message.optional_sint64 ());
- EXPECT_EQ(107 , message.optional_fixed32 ());
- EXPECT_EQ(108 , message.optional_fixed64 ());
- EXPECT_EQ(109 , message.optional_sfixed32());
- EXPECT_EQ(110 , message.optional_sfixed64());
- EXPECT_EQ(111 , message.optional_float ());
- EXPECT_EQ(112 , message.optional_double ());
- EXPECT_EQ(true , message.optional_bool ());
- EXPECT_EQ("115", message.optional_string ());
- EXPECT_EQ("116", message.optional_bytes ());
+ EXPECT_EQ(101, message.optional_int32());
+ EXPECT_EQ(102, message.optional_int64());
+ EXPECT_EQ(103, message.optional_uint32());
+ EXPECT_EQ(104, message.optional_uint64());
+ EXPECT_EQ(105, message.optional_sint32());
+ EXPECT_EQ(106, message.optional_sint64());
+ EXPECT_EQ(107, message.optional_fixed32());
+ EXPECT_EQ(108, message.optional_fixed64());
+ EXPECT_EQ(109, message.optional_sfixed32());
+ EXPECT_EQ(110, message.optional_sfixed64());
+ EXPECT_EQ(111, message.optional_float());
+ EXPECT_EQ(112, message.optional_double());
+ EXPECT_EQ(true, message.optional_bool());
+ EXPECT_EQ("115", message.optional_string());
+ EXPECT_EQ("116", message.optional_bytes());
- EXPECT_EQ(117, message.optionalgroup ().a());
- EXPECT_EQ(118, message.optional_nested_message ().bb());
- EXPECT_EQ(119, message.optional_foreign_message ().c());
- EXPECT_EQ(120, message.optional_import_message ().d());
+ EXPECT_EQ(117, message.optionalgroup().a());
+ EXPECT_EQ(118, message.optional_nested_message().bb());
+ EXPECT_EQ(119, message.optional_foreign_message().c());
+ EXPECT_EQ(120, message.optional_import_message().d());
EXPECT_EQ(126, message.optional_public_import_message().e());
- EXPECT_EQ(127, message.optional_lazy_message ().bb());
+ EXPECT_EQ(127, message.optional_lazy_message().bb());
- EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.optional_nested_enum ());
- EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.optional_foreign_enum());
- EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.optional_import_enum ());
+ EXPECT_EQ(unittest::TestAllTypesLite::BAZ, message.optional_nested_enum());
+ EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, message.optional_foreign_enum());
+ EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.optional_import_enum());
// -----------------------------------------------------------------
- ASSERT_EQ(2, message.repeated_int32_size ());
- ASSERT_EQ(2, message.repeated_int64_size ());
- ASSERT_EQ(2, message.repeated_uint32_size ());
- ASSERT_EQ(2, message.repeated_uint64_size ());
- ASSERT_EQ(2, message.repeated_sint32_size ());
- ASSERT_EQ(2, message.repeated_sint64_size ());
- ASSERT_EQ(2, message.repeated_fixed32_size ());
- ASSERT_EQ(2, message.repeated_fixed64_size ());
+ ASSERT_EQ(2, message.repeated_int32_size());
+ ASSERT_EQ(2, message.repeated_int64_size());
+ ASSERT_EQ(2, message.repeated_uint32_size());
+ ASSERT_EQ(2, message.repeated_uint64_size());
+ ASSERT_EQ(2, message.repeated_sint32_size());
+ ASSERT_EQ(2, message.repeated_sint64_size());
+ ASSERT_EQ(2, message.repeated_fixed32_size());
+ ASSERT_EQ(2, message.repeated_fixed64_size());
ASSERT_EQ(2, message.repeated_sfixed32_size());
ASSERT_EQ(2, message.repeated_sfixed64_size());
- ASSERT_EQ(2, message.repeated_float_size ());
- ASSERT_EQ(2, message.repeated_double_size ());
- ASSERT_EQ(2, message.repeated_bool_size ());
- ASSERT_EQ(2, message.repeated_string_size ());
- ASSERT_EQ(2, message.repeated_bytes_size ());
+ ASSERT_EQ(2, message.repeated_float_size());
+ ASSERT_EQ(2, message.repeated_double_size());
+ ASSERT_EQ(2, message.repeated_bool_size());
+ ASSERT_EQ(2, message.repeated_string_size());
+ ASSERT_EQ(2, message.repeated_bytes_size());
- ASSERT_EQ(2, message.repeatedgroup_size ());
- ASSERT_EQ(2, message.repeated_nested_message_size ());
+ ASSERT_EQ(2, message.repeatedgroup_size());
+ ASSERT_EQ(2, message.repeated_nested_message_size());
ASSERT_EQ(2, message.repeated_foreign_message_size());
- ASSERT_EQ(2, message.repeated_import_message_size ());
- ASSERT_EQ(2, message.repeated_lazy_message_size ());
- ASSERT_EQ(2, message.repeated_nested_enum_size ());
- ASSERT_EQ(2, message.repeated_foreign_enum_size ());
- ASSERT_EQ(2, message.repeated_import_enum_size ());
+ ASSERT_EQ(2, message.repeated_import_message_size());
+ ASSERT_EQ(2, message.repeated_lazy_message_size());
+ ASSERT_EQ(2, message.repeated_nested_enum_size());
+ ASSERT_EQ(2, message.repeated_foreign_enum_size());
+ ASSERT_EQ(2, message.repeated_import_enum_size());
- EXPECT_EQ(201 , message.repeated_int32 (0));
- EXPECT_EQ(202 , message.repeated_int64 (0));
- EXPECT_EQ(203 , message.repeated_uint32 (0));
- EXPECT_EQ(204 , message.repeated_uint64 (0));
- EXPECT_EQ(205 , message.repeated_sint32 (0));
- EXPECT_EQ(206 , message.repeated_sint64 (0));
- EXPECT_EQ(207 , message.repeated_fixed32 (0));
- EXPECT_EQ(208 , message.repeated_fixed64 (0));
- EXPECT_EQ(209 , message.repeated_sfixed32(0));
- EXPECT_EQ(210 , message.repeated_sfixed64(0));
- EXPECT_EQ(211 , message.repeated_float (0));
- EXPECT_EQ(212 , message.repeated_double (0));
- EXPECT_EQ(true , message.repeated_bool (0));
- EXPECT_EQ("215", message.repeated_string (0));
- EXPECT_EQ("216", message.repeated_bytes (0));
+ EXPECT_EQ(201, message.repeated_int32(0));
+ EXPECT_EQ(202, message.repeated_int64(0));
+ EXPECT_EQ(203, message.repeated_uint32(0));
+ EXPECT_EQ(204, message.repeated_uint64(0));
+ EXPECT_EQ(205, message.repeated_sint32(0));
+ EXPECT_EQ(206, message.repeated_sint64(0));
+ EXPECT_EQ(207, message.repeated_fixed32(0));
+ EXPECT_EQ(208, message.repeated_fixed64(0));
+ EXPECT_EQ(209, message.repeated_sfixed32(0));
+ EXPECT_EQ(210, message.repeated_sfixed64(0));
+ EXPECT_EQ(211, message.repeated_float(0));
+ EXPECT_EQ(212, message.repeated_double(0));
+ EXPECT_EQ(true, message.repeated_bool(0));
+ EXPECT_EQ("215", message.repeated_string(0));
+ EXPECT_EQ("216", message.repeated_bytes(0));
- EXPECT_EQ(217, message.repeatedgroup (0).a());
- EXPECT_EQ(218, message.repeated_nested_message (0).bb());
+ EXPECT_EQ(217, message.repeatedgroup(0).a());
+ EXPECT_EQ(218, message.repeated_nested_message(0).bb());
EXPECT_EQ(219, message.repeated_foreign_message(0).c());
- EXPECT_EQ(220, message.repeated_import_message (0).d());
- EXPECT_EQ(227, message.repeated_lazy_message (0).bb());
+ EXPECT_EQ(220, message.repeated_import_message(0).d());
+ EXPECT_EQ(227, message.repeated_lazy_message(0).bb());
- EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0));
- EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.repeated_foreign_enum(0));
- EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0));
+ EXPECT_EQ(unittest::TestAllTypesLite::BAR, message.repeated_nested_enum(0));
+ EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.repeated_foreign_enum(0));
+ EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum(0));
- EXPECT_EQ(301 , message.repeated_int32 (1));
- EXPECT_EQ(302 , message.repeated_int64 (1));
- EXPECT_EQ(303 , message.repeated_uint32 (1));
- EXPECT_EQ(304 , message.repeated_uint64 (1));
- EXPECT_EQ(305 , message.repeated_sint32 (1));
- EXPECT_EQ(306 , message.repeated_sint64 (1));
- EXPECT_EQ(307 , message.repeated_fixed32 (1));
- EXPECT_EQ(308 , message.repeated_fixed64 (1));
- EXPECT_EQ(309 , message.repeated_sfixed32(1));
- EXPECT_EQ(310 , message.repeated_sfixed64(1));
- EXPECT_EQ(311 , message.repeated_float (1));
- EXPECT_EQ(312 , message.repeated_double (1));
- EXPECT_EQ(false, message.repeated_bool (1));
- EXPECT_EQ("315", message.repeated_string (1));
- EXPECT_EQ("316", message.repeated_bytes (1));
+ EXPECT_EQ(301, message.repeated_int32(1));
+ EXPECT_EQ(302, message.repeated_int64(1));
+ EXPECT_EQ(303, message.repeated_uint32(1));
+ EXPECT_EQ(304, message.repeated_uint64(1));
+ EXPECT_EQ(305, message.repeated_sint32(1));
+ EXPECT_EQ(306, message.repeated_sint64(1));
+ EXPECT_EQ(307, message.repeated_fixed32(1));
+ EXPECT_EQ(308, message.repeated_fixed64(1));
+ EXPECT_EQ(309, message.repeated_sfixed32(1));
+ EXPECT_EQ(310, message.repeated_sfixed64(1));
+ EXPECT_EQ(311, message.repeated_float(1));
+ EXPECT_EQ(312, message.repeated_double(1));
+ EXPECT_EQ(false, message.repeated_bool(1));
+ EXPECT_EQ("315", message.repeated_string(1));
+ EXPECT_EQ("316", message.repeated_bytes(1));
- EXPECT_EQ(317, message.repeatedgroup (1).a());
- EXPECT_EQ(318, message.repeated_nested_message (1).bb());
+ EXPECT_EQ(317, message.repeatedgroup(1).a());
+ EXPECT_EQ(318, message.repeated_nested_message(1).bb());
EXPECT_EQ(319, message.repeated_foreign_message(1).c());
- EXPECT_EQ(320, message.repeated_import_message (1).d());
- EXPECT_EQ(327, message.repeated_lazy_message (1).bb());
+ EXPECT_EQ(320, message.repeated_import_message(1).d());
+ EXPECT_EQ(327, message.repeated_lazy_message(1).bb());
- EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.repeated_nested_enum (1));
- EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.repeated_foreign_enum(1));
- EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.repeated_import_enum (1));
+ EXPECT_EQ(unittest::TestAllTypesLite::BAZ, message.repeated_nested_enum(1));
+ EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, message.repeated_foreign_enum(1));
+ EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.repeated_import_enum(1));
// -----------------------------------------------------------------
- EXPECT_TRUE(message.has_default_int32 ());
- EXPECT_TRUE(message.has_default_int64 ());
- EXPECT_TRUE(message.has_default_uint32 ());
- EXPECT_TRUE(message.has_default_uint64 ());
- EXPECT_TRUE(message.has_default_sint32 ());
- EXPECT_TRUE(message.has_default_sint64 ());
- EXPECT_TRUE(message.has_default_fixed32 ());
- EXPECT_TRUE(message.has_default_fixed64 ());
+ EXPECT_TRUE(message.has_default_int32());
+ EXPECT_TRUE(message.has_default_int64());
+ EXPECT_TRUE(message.has_default_uint32());
+ EXPECT_TRUE(message.has_default_uint64());
+ EXPECT_TRUE(message.has_default_sint32());
+ EXPECT_TRUE(message.has_default_sint64());
+ EXPECT_TRUE(message.has_default_fixed32());
+ EXPECT_TRUE(message.has_default_fixed64());
EXPECT_TRUE(message.has_default_sfixed32());
EXPECT_TRUE(message.has_default_sfixed64());
- EXPECT_TRUE(message.has_default_float ());
- EXPECT_TRUE(message.has_default_double ());
- EXPECT_TRUE(message.has_default_bool ());
- EXPECT_TRUE(message.has_default_string ());
- EXPECT_TRUE(message.has_default_bytes ());
+ EXPECT_TRUE(message.has_default_float());
+ EXPECT_TRUE(message.has_default_double());
+ EXPECT_TRUE(message.has_default_bool());
+ EXPECT_TRUE(message.has_default_string());
+ EXPECT_TRUE(message.has_default_bytes());
- EXPECT_TRUE(message.has_default_nested_enum ());
+ EXPECT_TRUE(message.has_default_nested_enum());
EXPECT_TRUE(message.has_default_foreign_enum());
- EXPECT_TRUE(message.has_default_import_enum ());
+ EXPECT_TRUE(message.has_default_import_enum());
- EXPECT_EQ(401 , message.default_int32 ());
- EXPECT_EQ(402 , message.default_int64 ());
- EXPECT_EQ(403 , message.default_uint32 ());
- EXPECT_EQ(404 , message.default_uint64 ());
- EXPECT_EQ(405 , message.default_sint32 ());
- EXPECT_EQ(406 , message.default_sint64 ());
- EXPECT_EQ(407 , message.default_fixed32 ());
- EXPECT_EQ(408 , message.default_fixed64 ());
- EXPECT_EQ(409 , message.default_sfixed32());
- EXPECT_EQ(410 , message.default_sfixed64());
- EXPECT_EQ(411 , message.default_float ());
- EXPECT_EQ(412 , message.default_double ());
- EXPECT_EQ(false, message.default_bool ());
- EXPECT_EQ("415", message.default_string ());
- EXPECT_EQ("416", message.default_bytes ());
+ EXPECT_EQ(401, message.default_int32());
+ EXPECT_EQ(402, message.default_int64());
+ EXPECT_EQ(403, message.default_uint32());
+ EXPECT_EQ(404, message.default_uint64());
+ EXPECT_EQ(405, message.default_sint32());
+ EXPECT_EQ(406, message.default_sint64());
+ EXPECT_EQ(407, message.default_fixed32());
+ EXPECT_EQ(408, message.default_fixed64());
+ EXPECT_EQ(409, message.default_sfixed32());
+ EXPECT_EQ(410, message.default_sfixed64());
+ EXPECT_EQ(411, message.default_float());
+ EXPECT_EQ(412, message.default_double());
+ EXPECT_EQ(false, message.default_bool());
+ EXPECT_EQ("415", message.default_string());
+ EXPECT_EQ("416", message.default_bytes());
- EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.default_nested_enum ());
- EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.default_foreign_enum());
- EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.default_import_enum ());
+ EXPECT_EQ(unittest::TestAllTypesLite::FOO, message.default_nested_enum());
+ EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.default_foreign_enum());
+ EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.default_import_enum());
- EXPECT_FALSE(message.has_oneof_uint32 ());
+ EXPECT_FALSE(message.has_oneof_uint32());
EXPECT_FALSE(message.has_oneof_nested_message());
- EXPECT_FALSE(message.has_oneof_string ());
- EXPECT_TRUE(message.has_oneof_bytes ());
+ EXPECT_FALSE(message.has_oneof_string());
+ EXPECT_TRUE(message.has_oneof_bytes());
EXPECT_EQ("604", message.oneof_bytes());
}
@@ -392,145 +392,145 @@
void TestUtilLite::ExpectClear(const unittest::TestAllTypesLite& message) {
// has_blah() should initially be false for all optional fields.
- EXPECT_FALSE(message.has_optional_int32 ());
- EXPECT_FALSE(message.has_optional_int64 ());
- EXPECT_FALSE(message.has_optional_uint32 ());
- EXPECT_FALSE(message.has_optional_uint64 ());
- EXPECT_FALSE(message.has_optional_sint32 ());
- EXPECT_FALSE(message.has_optional_sint64 ());
- EXPECT_FALSE(message.has_optional_fixed32 ());
- EXPECT_FALSE(message.has_optional_fixed64 ());
+ EXPECT_FALSE(message.has_optional_int32());
+ EXPECT_FALSE(message.has_optional_int64());
+ EXPECT_FALSE(message.has_optional_uint32());
+ EXPECT_FALSE(message.has_optional_uint64());
+ EXPECT_FALSE(message.has_optional_sint32());
+ EXPECT_FALSE(message.has_optional_sint64());
+ EXPECT_FALSE(message.has_optional_fixed32());
+ EXPECT_FALSE(message.has_optional_fixed64());
EXPECT_FALSE(message.has_optional_sfixed32());
EXPECT_FALSE(message.has_optional_sfixed64());
- EXPECT_FALSE(message.has_optional_float ());
- EXPECT_FALSE(message.has_optional_double ());
- EXPECT_FALSE(message.has_optional_bool ());
- EXPECT_FALSE(message.has_optional_string ());
- EXPECT_FALSE(message.has_optional_bytes ());
+ EXPECT_FALSE(message.has_optional_float());
+ EXPECT_FALSE(message.has_optional_double());
+ EXPECT_FALSE(message.has_optional_bool());
+ EXPECT_FALSE(message.has_optional_string());
+ EXPECT_FALSE(message.has_optional_bytes());
- EXPECT_FALSE(message.has_optionalgroup ());
- EXPECT_FALSE(message.has_optional_nested_message ());
- EXPECT_FALSE(message.has_optional_foreign_message ());
- EXPECT_FALSE(message.has_optional_import_message ());
+ EXPECT_FALSE(message.has_optionalgroup());
+ EXPECT_FALSE(message.has_optional_nested_message());
+ EXPECT_FALSE(message.has_optional_foreign_message());
+ EXPECT_FALSE(message.has_optional_import_message());
EXPECT_FALSE(message.has_optional_public_import_message());
- EXPECT_FALSE(message.has_optional_lazy_message ());
+ EXPECT_FALSE(message.has_optional_lazy_message());
- EXPECT_FALSE(message.has_optional_nested_enum ());
+ EXPECT_FALSE(message.has_optional_nested_enum());
EXPECT_FALSE(message.has_optional_foreign_enum());
- EXPECT_FALSE(message.has_optional_import_enum ());
+ EXPECT_FALSE(message.has_optional_import_enum());
// Optional fields without defaults are set to zero or something like it.
- EXPECT_EQ(0 , message.optional_int32 ());
- EXPECT_EQ(0 , message.optional_int64 ());
- EXPECT_EQ(0 , message.optional_uint32 ());
- EXPECT_EQ(0 , message.optional_uint64 ());
- EXPECT_EQ(0 , message.optional_sint32 ());
- EXPECT_EQ(0 , message.optional_sint64 ());
- EXPECT_EQ(0 , message.optional_fixed32 ());
- EXPECT_EQ(0 , message.optional_fixed64 ());
- EXPECT_EQ(0 , message.optional_sfixed32());
- EXPECT_EQ(0 , message.optional_sfixed64());
- EXPECT_EQ(0 , message.optional_float ());
- EXPECT_EQ(0 , message.optional_double ());
- EXPECT_EQ(false, message.optional_bool ());
- EXPECT_EQ("" , message.optional_string ());
- EXPECT_EQ("" , message.optional_bytes ());
+ EXPECT_EQ(0, message.optional_int32());
+ EXPECT_EQ(0, message.optional_int64());
+ EXPECT_EQ(0, message.optional_uint32());
+ EXPECT_EQ(0, message.optional_uint64());
+ EXPECT_EQ(0, message.optional_sint32());
+ EXPECT_EQ(0, message.optional_sint64());
+ EXPECT_EQ(0, message.optional_fixed32());
+ EXPECT_EQ(0, message.optional_fixed64());
+ EXPECT_EQ(0, message.optional_sfixed32());
+ EXPECT_EQ(0, message.optional_sfixed64());
+ EXPECT_EQ(0, message.optional_float());
+ EXPECT_EQ(0, message.optional_double());
+ EXPECT_EQ(false, message.optional_bool());
+ EXPECT_EQ("", message.optional_string());
+ EXPECT_EQ("", message.optional_bytes());
// Embedded messages should also be clear.
- EXPECT_FALSE(message.optionalgroup ().has_a());
- EXPECT_FALSE(message.optional_nested_message ().has_bb());
- EXPECT_FALSE(message.optional_foreign_message ().has_c());
- EXPECT_FALSE(message.optional_import_message ().has_d());
+ EXPECT_FALSE(message.optionalgroup().has_a());
+ EXPECT_FALSE(message.optional_nested_message().has_bb());
+ EXPECT_FALSE(message.optional_foreign_message().has_c());
+ EXPECT_FALSE(message.optional_import_message().has_d());
EXPECT_FALSE(message.optional_public_import_message().has_e());
- EXPECT_FALSE(message.optional_lazy_message ().has_bb());
+ EXPECT_FALSE(message.optional_lazy_message().has_bb());
- EXPECT_EQ(0, message.optionalgroup ().a());
- EXPECT_EQ(0, message.optional_nested_message ().bb());
+ EXPECT_EQ(0, message.optionalgroup().a());
+ EXPECT_EQ(0, message.optional_nested_message().bb());
EXPECT_EQ(0, message.optional_foreign_message().c());
- EXPECT_EQ(0, message.optional_import_message ().d());
+ EXPECT_EQ(0, message.optional_import_message().d());
// Enums without defaults are set to the first value in the enum.
- EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.optional_nested_enum ());
- EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.optional_foreign_enum());
- EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.optional_import_enum ());
+ EXPECT_EQ(unittest::TestAllTypesLite::FOO, message.optional_nested_enum());
+ EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.optional_foreign_enum());
+ EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.optional_import_enum());
// Repeated fields are empty.
- EXPECT_EQ(0, message.repeated_int32_size ());
- EXPECT_EQ(0, message.repeated_int64_size ());
- EXPECT_EQ(0, message.repeated_uint32_size ());
- EXPECT_EQ(0, message.repeated_uint64_size ());
- EXPECT_EQ(0, message.repeated_sint32_size ());
- EXPECT_EQ(0, message.repeated_sint64_size ());
- EXPECT_EQ(0, message.repeated_fixed32_size ());
- EXPECT_EQ(0, message.repeated_fixed64_size ());
+ EXPECT_EQ(0, message.repeated_int32_size());
+ EXPECT_EQ(0, message.repeated_int64_size());
+ EXPECT_EQ(0, message.repeated_uint32_size());
+ EXPECT_EQ(0, message.repeated_uint64_size());
+ EXPECT_EQ(0, message.repeated_sint32_size());
+ EXPECT_EQ(0, message.repeated_sint64_size());
+ EXPECT_EQ(0, message.repeated_fixed32_size());
+ EXPECT_EQ(0, message.repeated_fixed64_size());
EXPECT_EQ(0, message.repeated_sfixed32_size());
EXPECT_EQ(0, message.repeated_sfixed64_size());
- EXPECT_EQ(0, message.repeated_float_size ());
- EXPECT_EQ(0, message.repeated_double_size ());
- EXPECT_EQ(0, message.repeated_bool_size ());
- EXPECT_EQ(0, message.repeated_string_size ());
- EXPECT_EQ(0, message.repeated_bytes_size ());
+ EXPECT_EQ(0, message.repeated_float_size());
+ EXPECT_EQ(0, message.repeated_double_size());
+ EXPECT_EQ(0, message.repeated_bool_size());
+ EXPECT_EQ(0, message.repeated_string_size());
+ EXPECT_EQ(0, message.repeated_bytes_size());
- EXPECT_EQ(0, message.repeatedgroup_size ());
- EXPECT_EQ(0, message.repeated_nested_message_size ());
+ EXPECT_EQ(0, message.repeatedgroup_size());
+ EXPECT_EQ(0, message.repeated_nested_message_size());
EXPECT_EQ(0, message.repeated_foreign_message_size());
- EXPECT_EQ(0, message.repeated_import_message_size ());
- EXPECT_EQ(0, message.repeated_lazy_message_size ());
- EXPECT_EQ(0, message.repeated_nested_enum_size ());
- EXPECT_EQ(0, message.repeated_foreign_enum_size ());
- EXPECT_EQ(0, message.repeated_import_enum_size ());
+ EXPECT_EQ(0, message.repeated_import_message_size());
+ EXPECT_EQ(0, message.repeated_lazy_message_size());
+ EXPECT_EQ(0, message.repeated_nested_enum_size());
+ EXPECT_EQ(0, message.repeated_foreign_enum_size());
+ EXPECT_EQ(0, message.repeated_import_enum_size());
// has_blah() should also be false for all default fields.
- EXPECT_FALSE(message.has_default_int32 ());
- EXPECT_FALSE(message.has_default_int64 ());
- EXPECT_FALSE(message.has_default_uint32 ());
- EXPECT_FALSE(message.has_default_uint64 ());
- EXPECT_FALSE(message.has_default_sint32 ());
- EXPECT_FALSE(message.has_default_sint64 ());
- EXPECT_FALSE(message.has_default_fixed32 ());
- EXPECT_FALSE(message.has_default_fixed64 ());
+ EXPECT_FALSE(message.has_default_int32());
+ EXPECT_FALSE(message.has_default_int64());
+ EXPECT_FALSE(message.has_default_uint32());
+ EXPECT_FALSE(message.has_default_uint64());
+ EXPECT_FALSE(message.has_default_sint32());
+ EXPECT_FALSE(message.has_default_sint64());
+ EXPECT_FALSE(message.has_default_fixed32());
+ EXPECT_FALSE(message.has_default_fixed64());
EXPECT_FALSE(message.has_default_sfixed32());
EXPECT_FALSE(message.has_default_sfixed64());
- EXPECT_FALSE(message.has_default_float ());
- EXPECT_FALSE(message.has_default_double ());
- EXPECT_FALSE(message.has_default_bool ());
- EXPECT_FALSE(message.has_default_string ());
- EXPECT_FALSE(message.has_default_bytes ());
+ EXPECT_FALSE(message.has_default_float());
+ EXPECT_FALSE(message.has_default_double());
+ EXPECT_FALSE(message.has_default_bool());
+ EXPECT_FALSE(message.has_default_string());
+ EXPECT_FALSE(message.has_default_bytes());
- EXPECT_FALSE(message.has_default_nested_enum ());
+ EXPECT_FALSE(message.has_default_nested_enum());
EXPECT_FALSE(message.has_default_foreign_enum());
- EXPECT_FALSE(message.has_default_import_enum ());
+ EXPECT_FALSE(message.has_default_import_enum());
// Fields with defaults have their default values (duh).
- EXPECT_EQ( 41 , message.default_int32 ());
- EXPECT_EQ( 42 , message.default_int64 ());
- EXPECT_EQ( 43 , message.default_uint32 ());
- EXPECT_EQ( 44 , message.default_uint64 ());
- EXPECT_EQ(-45 , message.default_sint32 ());
- EXPECT_EQ( 46 , message.default_sint64 ());
- EXPECT_EQ( 47 , message.default_fixed32 ());
- EXPECT_EQ( 48 , message.default_fixed64 ());
- EXPECT_EQ( 49 , message.default_sfixed32());
- EXPECT_EQ(-50 , message.default_sfixed64());
- EXPECT_EQ( 51.5 , message.default_float ());
- EXPECT_EQ( 52e3 , message.default_double ());
- EXPECT_EQ(true , message.default_bool ());
- EXPECT_EQ("hello", message.default_string ());
- EXPECT_EQ("world", message.default_bytes ());
+ EXPECT_EQ(41, message.default_int32());
+ EXPECT_EQ(42, message.default_int64());
+ EXPECT_EQ(43, message.default_uint32());
+ EXPECT_EQ(44, message.default_uint64());
+ EXPECT_EQ(-45, message.default_sint32());
+ EXPECT_EQ(46, message.default_sint64());
+ EXPECT_EQ(47, message.default_fixed32());
+ EXPECT_EQ(48, message.default_fixed64());
+ EXPECT_EQ(49, message.default_sfixed32());
+ EXPECT_EQ(-50, message.default_sfixed64());
+ EXPECT_EQ(51.5, message.default_float());
+ EXPECT_EQ(52e3, message.default_double());
+ EXPECT_EQ(true, message.default_bool());
+ EXPECT_EQ("hello", message.default_string());
+ EXPECT_EQ("world", message.default_bytes());
- EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.default_nested_enum ());
- EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.default_foreign_enum());
- EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.default_import_enum ());
+ EXPECT_EQ(unittest::TestAllTypesLite::BAR, message.default_nested_enum());
+ EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.default_foreign_enum());
+ EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.default_import_enum());
- EXPECT_FALSE(message.has_oneof_uint32 ());
+ EXPECT_FALSE(message.has_oneof_uint32());
EXPECT_FALSE(message.has_oneof_nested_message());
- EXPECT_FALSE(message.has_oneof_string ());
- EXPECT_FALSE(message.has_oneof_bytes ());
+ EXPECT_FALSE(message.has_oneof_string());
+ EXPECT_FALSE(message.has_oneof_bytes());
}
// -------------------------------------------------------------------
@@ -540,188 +540,188 @@
// ModifyRepeatedFields only sets the second repeated element of each
// field. In addition to verifying this, we also verify that the first
// element and size were *not* modified.
- ASSERT_EQ(2, message.repeated_int32_size ());
- ASSERT_EQ(2, message.repeated_int64_size ());
- ASSERT_EQ(2, message.repeated_uint32_size ());
- ASSERT_EQ(2, message.repeated_uint64_size ());
- ASSERT_EQ(2, message.repeated_sint32_size ());
- ASSERT_EQ(2, message.repeated_sint64_size ());
- ASSERT_EQ(2, message.repeated_fixed32_size ());
- ASSERT_EQ(2, message.repeated_fixed64_size ());
+ ASSERT_EQ(2, message.repeated_int32_size());
+ ASSERT_EQ(2, message.repeated_int64_size());
+ ASSERT_EQ(2, message.repeated_uint32_size());
+ ASSERT_EQ(2, message.repeated_uint64_size());
+ ASSERT_EQ(2, message.repeated_sint32_size());
+ ASSERT_EQ(2, message.repeated_sint64_size());
+ ASSERT_EQ(2, message.repeated_fixed32_size());
+ ASSERT_EQ(2, message.repeated_fixed64_size());
ASSERT_EQ(2, message.repeated_sfixed32_size());
ASSERT_EQ(2, message.repeated_sfixed64_size());
- ASSERT_EQ(2, message.repeated_float_size ());
- ASSERT_EQ(2, message.repeated_double_size ());
- ASSERT_EQ(2, message.repeated_bool_size ());
- ASSERT_EQ(2, message.repeated_string_size ());
- ASSERT_EQ(2, message.repeated_bytes_size ());
+ ASSERT_EQ(2, message.repeated_float_size());
+ ASSERT_EQ(2, message.repeated_double_size());
+ ASSERT_EQ(2, message.repeated_bool_size());
+ ASSERT_EQ(2, message.repeated_string_size());
+ ASSERT_EQ(2, message.repeated_bytes_size());
- ASSERT_EQ(2, message.repeatedgroup_size ());
- ASSERT_EQ(2, message.repeated_nested_message_size ());
+ ASSERT_EQ(2, message.repeatedgroup_size());
+ ASSERT_EQ(2, message.repeated_nested_message_size());
ASSERT_EQ(2, message.repeated_foreign_message_size());
- ASSERT_EQ(2, message.repeated_import_message_size ());
- ASSERT_EQ(2, message.repeated_lazy_message_size ());
- ASSERT_EQ(2, message.repeated_nested_enum_size ());
- ASSERT_EQ(2, message.repeated_foreign_enum_size ());
- ASSERT_EQ(2, message.repeated_import_enum_size ());
+ ASSERT_EQ(2, message.repeated_import_message_size());
+ ASSERT_EQ(2, message.repeated_lazy_message_size());
+ ASSERT_EQ(2, message.repeated_nested_enum_size());
+ ASSERT_EQ(2, message.repeated_foreign_enum_size());
+ ASSERT_EQ(2, message.repeated_import_enum_size());
- EXPECT_EQ(201 , message.repeated_int32 (0));
- EXPECT_EQ(202 , message.repeated_int64 (0));
- EXPECT_EQ(203 , message.repeated_uint32 (0));
- EXPECT_EQ(204 , message.repeated_uint64 (0));
- EXPECT_EQ(205 , message.repeated_sint32 (0));
- EXPECT_EQ(206 , message.repeated_sint64 (0));
- EXPECT_EQ(207 , message.repeated_fixed32 (0));
- EXPECT_EQ(208 , message.repeated_fixed64 (0));
- EXPECT_EQ(209 , message.repeated_sfixed32(0));
- EXPECT_EQ(210 , message.repeated_sfixed64(0));
- EXPECT_EQ(211 , message.repeated_float (0));
- EXPECT_EQ(212 , message.repeated_double (0));
- EXPECT_EQ(true , message.repeated_bool (0));
- EXPECT_EQ("215", message.repeated_string (0));
- EXPECT_EQ("216", message.repeated_bytes (0));
+ EXPECT_EQ(201, message.repeated_int32(0));
+ EXPECT_EQ(202, message.repeated_int64(0));
+ EXPECT_EQ(203, message.repeated_uint32(0));
+ EXPECT_EQ(204, message.repeated_uint64(0));
+ EXPECT_EQ(205, message.repeated_sint32(0));
+ EXPECT_EQ(206, message.repeated_sint64(0));
+ EXPECT_EQ(207, message.repeated_fixed32(0));
+ EXPECT_EQ(208, message.repeated_fixed64(0));
+ EXPECT_EQ(209, message.repeated_sfixed32(0));
+ EXPECT_EQ(210, message.repeated_sfixed64(0));
+ EXPECT_EQ(211, message.repeated_float(0));
+ EXPECT_EQ(212, message.repeated_double(0));
+ EXPECT_EQ(true, message.repeated_bool(0));
+ EXPECT_EQ("215", message.repeated_string(0));
+ EXPECT_EQ("216", message.repeated_bytes(0));
- EXPECT_EQ(217, message.repeatedgroup (0).a());
- EXPECT_EQ(218, message.repeated_nested_message (0).bb());
+ EXPECT_EQ(217, message.repeatedgroup(0).a());
+ EXPECT_EQ(218, message.repeated_nested_message(0).bb());
EXPECT_EQ(219, message.repeated_foreign_message(0).c());
- EXPECT_EQ(220, message.repeated_import_message (0).d());
- EXPECT_EQ(227, message.repeated_lazy_message (0).bb());
+ EXPECT_EQ(220, message.repeated_import_message(0).d());
+ EXPECT_EQ(227, message.repeated_lazy_message(0).bb());
- EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0));
- EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.repeated_foreign_enum(0));
- EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0));
+ EXPECT_EQ(unittest::TestAllTypesLite::BAR, message.repeated_nested_enum(0));
+ EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.repeated_foreign_enum(0));
+ EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum(0));
// Actually verify the second (modified) elements now.
- EXPECT_EQ(501 , message.repeated_int32 (1));
- EXPECT_EQ(502 , message.repeated_int64 (1));
- EXPECT_EQ(503 , message.repeated_uint32 (1));
- EXPECT_EQ(504 , message.repeated_uint64 (1));
- EXPECT_EQ(505 , message.repeated_sint32 (1));
- EXPECT_EQ(506 , message.repeated_sint64 (1));
- EXPECT_EQ(507 , message.repeated_fixed32 (1));
- EXPECT_EQ(508 , message.repeated_fixed64 (1));
- EXPECT_EQ(509 , message.repeated_sfixed32(1));
- EXPECT_EQ(510 , message.repeated_sfixed64(1));
- EXPECT_EQ(511 , message.repeated_float (1));
- EXPECT_EQ(512 , message.repeated_double (1));
- EXPECT_EQ(true , message.repeated_bool (1));
- EXPECT_EQ("515", message.repeated_string (1));
- EXPECT_EQ("516", message.repeated_bytes (1));
+ EXPECT_EQ(501, message.repeated_int32(1));
+ EXPECT_EQ(502, message.repeated_int64(1));
+ EXPECT_EQ(503, message.repeated_uint32(1));
+ EXPECT_EQ(504, message.repeated_uint64(1));
+ EXPECT_EQ(505, message.repeated_sint32(1));
+ EXPECT_EQ(506, message.repeated_sint64(1));
+ EXPECT_EQ(507, message.repeated_fixed32(1));
+ EXPECT_EQ(508, message.repeated_fixed64(1));
+ EXPECT_EQ(509, message.repeated_sfixed32(1));
+ EXPECT_EQ(510, message.repeated_sfixed64(1));
+ EXPECT_EQ(511, message.repeated_float(1));
+ EXPECT_EQ(512, message.repeated_double(1));
+ EXPECT_EQ(true, message.repeated_bool(1));
+ EXPECT_EQ("515", message.repeated_string(1));
+ EXPECT_EQ("516", message.repeated_bytes(1));
- EXPECT_EQ(517, message.repeatedgroup (1).a());
- EXPECT_EQ(518, message.repeated_nested_message (1).bb());
+ EXPECT_EQ(517, message.repeatedgroup(1).a());
+ EXPECT_EQ(518, message.repeated_nested_message(1).bb());
EXPECT_EQ(519, message.repeated_foreign_message(1).c());
- EXPECT_EQ(520, message.repeated_import_message (1).d());
- EXPECT_EQ(527, message.repeated_lazy_message (1).bb());
+ EXPECT_EQ(520, message.repeated_import_message(1).d());
+ EXPECT_EQ(527, message.repeated_lazy_message(1).bb());
- EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.repeated_nested_enum (1));
- EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.repeated_foreign_enum(1));
- EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.repeated_import_enum (1));
+ EXPECT_EQ(unittest::TestAllTypesLite::FOO, message.repeated_nested_enum(1));
+ EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.repeated_foreign_enum(1));
+ EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.repeated_import_enum(1));
}
// -------------------------------------------------------------------
void TestUtilLite::SetPackedFields(unittest::TestPackedTypesLite* message) {
- message->add_packed_int32 (601);
- message->add_packed_int64 (602);
- message->add_packed_uint32 (603);
- message->add_packed_uint64 (604);
- message->add_packed_sint32 (605);
- message->add_packed_sint64 (606);
- message->add_packed_fixed32 (607);
- message->add_packed_fixed64 (608);
+ message->add_packed_int32(601);
+ message->add_packed_int64(602);
+ message->add_packed_uint32(603);
+ message->add_packed_uint64(604);
+ message->add_packed_sint32(605);
+ message->add_packed_sint64(606);
+ message->add_packed_fixed32(607);
+ message->add_packed_fixed64(608);
message->add_packed_sfixed32(609);
message->add_packed_sfixed64(610);
- message->add_packed_float (611);
- message->add_packed_double (612);
- message->add_packed_bool (true);
- message->add_packed_enum (unittest::FOREIGN_LITE_BAR);
+ message->add_packed_float(611);
+ message->add_packed_double(612);
+ message->add_packed_bool(true);
+ message->add_packed_enum(unittest::FOREIGN_LITE_BAR);
// add a second one of each field
- message->add_packed_int32 (701);
- message->add_packed_int64 (702);
- message->add_packed_uint32 (703);
- message->add_packed_uint64 (704);
- message->add_packed_sint32 (705);
- message->add_packed_sint64 (706);
- message->add_packed_fixed32 (707);
- message->add_packed_fixed64 (708);
+ message->add_packed_int32(701);
+ message->add_packed_int64(702);
+ message->add_packed_uint32(703);
+ message->add_packed_uint64(704);
+ message->add_packed_sint32(705);
+ message->add_packed_sint64(706);
+ message->add_packed_fixed32(707);
+ message->add_packed_fixed64(708);
message->add_packed_sfixed32(709);
message->add_packed_sfixed64(710);
- message->add_packed_float (711);
- message->add_packed_double (712);
- message->add_packed_bool (false);
- message->add_packed_enum (unittest::FOREIGN_LITE_BAZ);
+ message->add_packed_float(711);
+ message->add_packed_double(712);
+ message->add_packed_bool(false);
+ message->add_packed_enum(unittest::FOREIGN_LITE_BAZ);
}
// -------------------------------------------------------------------
void TestUtilLite::ModifyPackedFields(unittest::TestPackedTypesLite* message) {
- message->set_packed_int32 (1, 801);
- message->set_packed_int64 (1, 802);
- message->set_packed_uint32 (1, 803);
- message->set_packed_uint64 (1, 804);
- message->set_packed_sint32 (1, 805);
- message->set_packed_sint64 (1, 806);
- message->set_packed_fixed32 (1, 807);
- message->set_packed_fixed64 (1, 808);
+ message->set_packed_int32(1, 801);
+ message->set_packed_int64(1, 802);
+ message->set_packed_uint32(1, 803);
+ message->set_packed_uint64(1, 804);
+ message->set_packed_sint32(1, 805);
+ message->set_packed_sint64(1, 806);
+ message->set_packed_fixed32(1, 807);
+ message->set_packed_fixed64(1, 808);
message->set_packed_sfixed32(1, 809);
message->set_packed_sfixed64(1, 810);
- message->set_packed_float (1, 811);
- message->set_packed_double (1, 812);
- message->set_packed_bool (1, true);
- message->set_packed_enum (1, unittest::FOREIGN_LITE_FOO);
+ message->set_packed_float(1, 811);
+ message->set_packed_double(1, 812);
+ message->set_packed_bool(1, true);
+ message->set_packed_enum(1, unittest::FOREIGN_LITE_FOO);
}
// -------------------------------------------------------------------
void TestUtilLite::ExpectPackedFieldsSet(
const unittest::TestPackedTypesLite& message) {
- ASSERT_EQ(2, message.packed_int32_size ());
- ASSERT_EQ(2, message.packed_int64_size ());
- ASSERT_EQ(2, message.packed_uint32_size ());
- ASSERT_EQ(2, message.packed_uint64_size ());
- ASSERT_EQ(2, message.packed_sint32_size ());
- ASSERT_EQ(2, message.packed_sint64_size ());
- ASSERT_EQ(2, message.packed_fixed32_size ());
- ASSERT_EQ(2, message.packed_fixed64_size ());
+ ASSERT_EQ(2, message.packed_int32_size());
+ ASSERT_EQ(2, message.packed_int64_size());
+ ASSERT_EQ(2, message.packed_uint32_size());
+ ASSERT_EQ(2, message.packed_uint64_size());
+ ASSERT_EQ(2, message.packed_sint32_size());
+ ASSERT_EQ(2, message.packed_sint64_size());
+ ASSERT_EQ(2, message.packed_fixed32_size());
+ ASSERT_EQ(2, message.packed_fixed64_size());
ASSERT_EQ(2, message.packed_sfixed32_size());
ASSERT_EQ(2, message.packed_sfixed64_size());
- ASSERT_EQ(2, message.packed_float_size ());
- ASSERT_EQ(2, message.packed_double_size ());
- ASSERT_EQ(2, message.packed_bool_size ());
- ASSERT_EQ(2, message.packed_enum_size ());
+ ASSERT_EQ(2, message.packed_float_size());
+ ASSERT_EQ(2, message.packed_double_size());
+ ASSERT_EQ(2, message.packed_bool_size());
+ ASSERT_EQ(2, message.packed_enum_size());
- EXPECT_EQ(601 , message.packed_int32 (0));
- EXPECT_EQ(602 , message.packed_int64 (0));
- EXPECT_EQ(603 , message.packed_uint32 (0));
- EXPECT_EQ(604 , message.packed_uint64 (0));
- EXPECT_EQ(605 , message.packed_sint32 (0));
- EXPECT_EQ(606 , message.packed_sint64 (0));
- EXPECT_EQ(607 , message.packed_fixed32 (0));
- EXPECT_EQ(608 , message.packed_fixed64 (0));
- EXPECT_EQ(609 , message.packed_sfixed32(0));
- EXPECT_EQ(610 , message.packed_sfixed64(0));
- EXPECT_EQ(611 , message.packed_float (0));
- EXPECT_EQ(612 , message.packed_double (0));
- EXPECT_EQ(true , message.packed_bool (0));
+ EXPECT_EQ(601, message.packed_int32(0));
+ EXPECT_EQ(602, message.packed_int64(0));
+ EXPECT_EQ(603, message.packed_uint32(0));
+ EXPECT_EQ(604, message.packed_uint64(0));
+ EXPECT_EQ(605, message.packed_sint32(0));
+ EXPECT_EQ(606, message.packed_sint64(0));
+ EXPECT_EQ(607, message.packed_fixed32(0));
+ EXPECT_EQ(608, message.packed_fixed64(0));
+ EXPECT_EQ(609, message.packed_sfixed32(0));
+ EXPECT_EQ(610, message.packed_sfixed64(0));
+ EXPECT_EQ(611, message.packed_float(0));
+ EXPECT_EQ(612, message.packed_double(0));
+ EXPECT_EQ(true, message.packed_bool(0));
EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));
- EXPECT_EQ(701 , message.packed_int32 (1));
- EXPECT_EQ(702 , message.packed_int64 (1));
- EXPECT_EQ(703 , message.packed_uint32 (1));
- EXPECT_EQ(704 , message.packed_uint64 (1));
- EXPECT_EQ(705 , message.packed_sint32 (1));
- EXPECT_EQ(706 , message.packed_sint64 (1));
- EXPECT_EQ(707 , message.packed_fixed32 (1));
- EXPECT_EQ(708 , message.packed_fixed64 (1));
- EXPECT_EQ(709 , message.packed_sfixed32(1));
- EXPECT_EQ(710 , message.packed_sfixed64(1));
- EXPECT_EQ(711 , message.packed_float (1));
- EXPECT_EQ(712 , message.packed_double (1));
- EXPECT_EQ(false, message.packed_bool (1));
+ EXPECT_EQ(701, message.packed_int32(1));
+ EXPECT_EQ(702, message.packed_int64(1));
+ EXPECT_EQ(703, message.packed_uint32(1));
+ EXPECT_EQ(704, message.packed_uint64(1));
+ EXPECT_EQ(705, message.packed_sint32(1));
+ EXPECT_EQ(706, message.packed_sint64(1));
+ EXPECT_EQ(707, message.packed_fixed32(1));
+ EXPECT_EQ(708, message.packed_fixed64(1));
+ EXPECT_EQ(709, message.packed_sfixed32(1));
+ EXPECT_EQ(710, message.packed_sfixed64(1));
+ EXPECT_EQ(711, message.packed_float(1));
+ EXPECT_EQ(712, message.packed_double(1));
+ EXPECT_EQ(false, message.packed_bool(1));
EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, message.packed_enum(1));
}
@@ -730,20 +730,20 @@
void TestUtilLite::ExpectPackedClear(
const unittest::TestPackedTypesLite& message) {
// Packed repeated fields are empty.
- EXPECT_EQ(0, message.packed_int32_size ());
- EXPECT_EQ(0, message.packed_int64_size ());
- EXPECT_EQ(0, message.packed_uint32_size ());
- EXPECT_EQ(0, message.packed_uint64_size ());
- EXPECT_EQ(0, message.packed_sint32_size ());
- EXPECT_EQ(0, message.packed_sint64_size ());
- EXPECT_EQ(0, message.packed_fixed32_size ());
- EXPECT_EQ(0, message.packed_fixed64_size ());
+ EXPECT_EQ(0, message.packed_int32_size());
+ EXPECT_EQ(0, message.packed_int64_size());
+ EXPECT_EQ(0, message.packed_uint32_size());
+ EXPECT_EQ(0, message.packed_uint64_size());
+ EXPECT_EQ(0, message.packed_sint32_size());
+ EXPECT_EQ(0, message.packed_sint64_size());
+ EXPECT_EQ(0, message.packed_fixed32_size());
+ EXPECT_EQ(0, message.packed_fixed64_size());
EXPECT_EQ(0, message.packed_sfixed32_size());
EXPECT_EQ(0, message.packed_sfixed64_size());
- EXPECT_EQ(0, message.packed_float_size ());
- EXPECT_EQ(0, message.packed_double_size ());
- EXPECT_EQ(0, message.packed_bool_size ());
- EXPECT_EQ(0, message.packed_enum_size ());
+ EXPECT_EQ(0, message.packed_float_size());
+ EXPECT_EQ(0, message.packed_double_size());
+ EXPECT_EQ(0, message.packed_bool_size());
+ EXPECT_EQ(0, message.packed_enum_size());
}
// -------------------------------------------------------------------
@@ -751,49 +751,49 @@
void TestUtilLite::ExpectPackedFieldsModified(
const unittest::TestPackedTypesLite& message) {
// Do the same for packed repeated fields.
- ASSERT_EQ(2, message.packed_int32_size ());
- ASSERT_EQ(2, message.packed_int64_size ());
- ASSERT_EQ(2, message.packed_uint32_size ());
- ASSERT_EQ(2, message.packed_uint64_size ());
- ASSERT_EQ(2, message.packed_sint32_size ());
- ASSERT_EQ(2, message.packed_sint64_size ());
- ASSERT_EQ(2, message.packed_fixed32_size ());
- ASSERT_EQ(2, message.packed_fixed64_size ());
+ ASSERT_EQ(2, message.packed_int32_size());
+ ASSERT_EQ(2, message.packed_int64_size());
+ ASSERT_EQ(2, message.packed_uint32_size());
+ ASSERT_EQ(2, message.packed_uint64_size());
+ ASSERT_EQ(2, message.packed_sint32_size());
+ ASSERT_EQ(2, message.packed_sint64_size());
+ ASSERT_EQ(2, message.packed_fixed32_size());
+ ASSERT_EQ(2, message.packed_fixed64_size());
ASSERT_EQ(2, message.packed_sfixed32_size());
ASSERT_EQ(2, message.packed_sfixed64_size());
- ASSERT_EQ(2, message.packed_float_size ());
- ASSERT_EQ(2, message.packed_double_size ());
- ASSERT_EQ(2, message.packed_bool_size ());
- ASSERT_EQ(2, message.packed_enum_size ());
+ ASSERT_EQ(2, message.packed_float_size());
+ ASSERT_EQ(2, message.packed_double_size());
+ ASSERT_EQ(2, message.packed_bool_size());
+ ASSERT_EQ(2, message.packed_enum_size());
- EXPECT_EQ(601 , message.packed_int32 (0));
- EXPECT_EQ(602 , message.packed_int64 (0));
- EXPECT_EQ(603 , message.packed_uint32 (0));
- EXPECT_EQ(604 , message.packed_uint64 (0));
- EXPECT_EQ(605 , message.packed_sint32 (0));
- EXPECT_EQ(606 , message.packed_sint64 (0));
- EXPECT_EQ(607 , message.packed_fixed32 (0));
- EXPECT_EQ(608 , message.packed_fixed64 (0));
- EXPECT_EQ(609 , message.packed_sfixed32(0));
- EXPECT_EQ(610 , message.packed_sfixed64(0));
- EXPECT_EQ(611 , message.packed_float (0));
- EXPECT_EQ(612 , message.packed_double (0));
- EXPECT_EQ(true , message.packed_bool (0));
+ EXPECT_EQ(601, message.packed_int32(0));
+ EXPECT_EQ(602, message.packed_int64(0));
+ EXPECT_EQ(603, message.packed_uint32(0));
+ EXPECT_EQ(604, message.packed_uint64(0));
+ EXPECT_EQ(605, message.packed_sint32(0));
+ EXPECT_EQ(606, message.packed_sint64(0));
+ EXPECT_EQ(607, message.packed_fixed32(0));
+ EXPECT_EQ(608, message.packed_fixed64(0));
+ EXPECT_EQ(609, message.packed_sfixed32(0));
+ EXPECT_EQ(610, message.packed_sfixed64(0));
+ EXPECT_EQ(611, message.packed_float(0));
+ EXPECT_EQ(612, message.packed_double(0));
+ EXPECT_EQ(true, message.packed_bool(0));
EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));
// Actually verify the second (modified) elements now.
- EXPECT_EQ(801 , message.packed_int32 (1));
- EXPECT_EQ(802 , message.packed_int64 (1));
- EXPECT_EQ(803 , message.packed_uint32 (1));
- EXPECT_EQ(804 , message.packed_uint64 (1));
- EXPECT_EQ(805 , message.packed_sint32 (1));
- EXPECT_EQ(806 , message.packed_sint64 (1));
- EXPECT_EQ(807 , message.packed_fixed32 (1));
- EXPECT_EQ(808 , message.packed_fixed64 (1));
- EXPECT_EQ(809 , message.packed_sfixed32(1));
- EXPECT_EQ(810 , message.packed_sfixed64(1));
- EXPECT_EQ(811 , message.packed_float (1));
- EXPECT_EQ(812 , message.packed_double (1));
- EXPECT_EQ(true , message.packed_bool (1));
+ EXPECT_EQ(801, message.packed_int32(1));
+ EXPECT_EQ(802, message.packed_int64(1));
+ EXPECT_EQ(803, message.packed_uint32(1));
+ EXPECT_EQ(804, message.packed_uint64(1));
+ EXPECT_EQ(805, message.packed_sint32(1));
+ EXPECT_EQ(806, message.packed_sint64(1));
+ EXPECT_EQ(807, message.packed_fixed32(1));
+ EXPECT_EQ(808, message.packed_fixed64(1));
+ EXPECT_EQ(809, message.packed_sfixed32(1));
+ EXPECT_EQ(810, message.packed_sfixed64(1));
+ EXPECT_EQ(811, message.packed_float(1));
+ EXPECT_EQ(812, message.packed_double(1));
+ EXPECT_EQ(true, message.packed_bool(1));
EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.packed_enum(1));
}
@@ -806,116 +806,145 @@
// I gave up on the 80-char limit here. Sorry.
void TestUtilLite::SetAllExtensions(unittest::TestAllExtensionsLite* message) {
- message->SetExtension(unittest::optional_int32_extension_lite , 101);
- message->SetExtension(unittest::optional_int64_extension_lite , 102);
- message->SetExtension(unittest::optional_uint32_extension_lite , 103);
- message->SetExtension(unittest::optional_uint64_extension_lite , 104);
- message->SetExtension(unittest::optional_sint32_extension_lite , 105);
- message->SetExtension(unittest::optional_sint64_extension_lite , 106);
- message->SetExtension(unittest::optional_fixed32_extension_lite , 107);
- message->SetExtension(unittest::optional_fixed64_extension_lite , 108);
+ message->SetExtension(unittest::optional_int32_extension_lite, 101);
+ message->SetExtension(unittest::optional_int64_extension_lite, 102);
+ message->SetExtension(unittest::optional_uint32_extension_lite, 103);
+ message->SetExtension(unittest::optional_uint64_extension_lite, 104);
+ message->SetExtension(unittest::optional_sint32_extension_lite, 105);
+ message->SetExtension(unittest::optional_sint64_extension_lite, 106);
+ message->SetExtension(unittest::optional_fixed32_extension_lite, 107);
+ message->SetExtension(unittest::optional_fixed64_extension_lite, 108);
message->SetExtension(unittest::optional_sfixed32_extension_lite, 109);
message->SetExtension(unittest::optional_sfixed64_extension_lite, 110);
- message->SetExtension(unittest::optional_float_extension_lite , 111);
- message->SetExtension(unittest::optional_double_extension_lite , 112);
- message->SetExtension(unittest::optional_bool_extension_lite , true);
- message->SetExtension(unittest::optional_string_extension_lite , "115");
- message->SetExtension(unittest::optional_bytes_extension_lite , "116");
+ message->SetExtension(unittest::optional_float_extension_lite, 111);
+ message->SetExtension(unittest::optional_double_extension_lite, 112);
+ message->SetExtension(unittest::optional_bool_extension_lite, true);
+ message->SetExtension(unittest::optional_string_extension_lite, "115");
+ message->SetExtension(unittest::optional_bytes_extension_lite, "116");
- message->MutableExtension(unittest::optionalgroup_extension_lite )->set_a(117);
- message->MutableExtension(unittest::optional_nested_message_extension_lite )->set_bb(118);
- message->MutableExtension(unittest::optional_foreign_message_extension_lite )->set_c(119);
- message->MutableExtension(unittest::optional_import_message_extension_lite )->set_d(120);
- message->MutableExtension(unittest::optional_public_import_message_extension_lite)->set_e(126);
- message->MutableExtension(unittest::optional_lazy_message_extension_lite )->set_bb(127);
+ message->MutableExtension(unittest::optionalgroup_extension_lite)->set_a(117);
+ message->MutableExtension(unittest::optional_nested_message_extension_lite)
+ ->set_bb(118);
+ message->MutableExtension(unittest::optional_foreign_message_extension_lite)
+ ->set_c(119);
+ message->MutableExtension(unittest::optional_import_message_extension_lite)
+ ->set_d(120);
+ message
+ ->MutableExtension(
+ unittest::optional_public_import_message_extension_lite)
+ ->set_e(126);
+ message->MutableExtension(unittest::optional_lazy_message_extension_lite)
+ ->set_bb(127);
- message->SetExtension(unittest::optional_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ );
- message->SetExtension(unittest::optional_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ );
- message->SetExtension(unittest::optional_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ);
+ message->SetExtension(unittest::optional_nested_enum_extension_lite,
+ unittest::TestAllTypesLite::BAZ);
+ message->SetExtension(unittest::optional_foreign_enum_extension_lite,
+ unittest::FOREIGN_LITE_BAZ);
+ message->SetExtension(unittest::optional_import_enum_extension_lite,
+ unittest_import::IMPORT_LITE_BAZ);
// -----------------------------------------------------------------
- message->AddExtension(unittest::repeated_int32_extension_lite , 201);
- message->AddExtension(unittest::repeated_int64_extension_lite , 202);
- message->AddExtension(unittest::repeated_uint32_extension_lite , 203);
- message->AddExtension(unittest::repeated_uint64_extension_lite , 204);
- message->AddExtension(unittest::repeated_sint32_extension_lite , 205);
- message->AddExtension(unittest::repeated_sint64_extension_lite , 206);
- message->AddExtension(unittest::repeated_fixed32_extension_lite , 207);
- message->AddExtension(unittest::repeated_fixed64_extension_lite , 208);
+ message->AddExtension(unittest::repeated_int32_extension_lite, 201);
+ message->AddExtension(unittest::repeated_int64_extension_lite, 202);
+ message->AddExtension(unittest::repeated_uint32_extension_lite, 203);
+ message->AddExtension(unittest::repeated_uint64_extension_lite, 204);
+ message->AddExtension(unittest::repeated_sint32_extension_lite, 205);
+ message->AddExtension(unittest::repeated_sint64_extension_lite, 206);
+ message->AddExtension(unittest::repeated_fixed32_extension_lite, 207);
+ message->AddExtension(unittest::repeated_fixed64_extension_lite, 208);
message->AddExtension(unittest::repeated_sfixed32_extension_lite, 209);
message->AddExtension(unittest::repeated_sfixed64_extension_lite, 210);
- message->AddExtension(unittest::repeated_float_extension_lite , 211);
- message->AddExtension(unittest::repeated_double_extension_lite , 212);
- message->AddExtension(unittest::repeated_bool_extension_lite , true);
- message->AddExtension(unittest::repeated_string_extension_lite , "215");
- message->AddExtension(unittest::repeated_bytes_extension_lite , "216");
+ message->AddExtension(unittest::repeated_float_extension_lite, 211);
+ message->AddExtension(unittest::repeated_double_extension_lite, 212);
+ message->AddExtension(unittest::repeated_bool_extension_lite, true);
+ message->AddExtension(unittest::repeated_string_extension_lite, "215");
+ message->AddExtension(unittest::repeated_bytes_extension_lite, "216");
- message->AddExtension(unittest::repeatedgroup_extension_lite )->set_a(217);
- message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(218);
- message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(219);
- message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(220);
- message->AddExtension(unittest::repeated_lazy_message_extension_lite )->set_bb(227);
+ message->AddExtension(unittest::repeatedgroup_extension_lite)->set_a(217);
+ message->AddExtension(unittest::repeated_nested_message_extension_lite)
+ ->set_bb(218);
+ message->AddExtension(unittest::repeated_foreign_message_extension_lite)
+ ->set_c(219);
+ message->AddExtension(unittest::repeated_import_message_extension_lite)
+ ->set_d(220);
+ message->AddExtension(unittest::repeated_lazy_message_extension_lite)
+ ->set_bb(227);
- message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAR );
- message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAR );
- message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAR);
+ message->AddExtension(unittest::repeated_nested_enum_extension_lite,
+ unittest::TestAllTypesLite::BAR);
+ message->AddExtension(unittest::repeated_foreign_enum_extension_lite,
+ unittest::FOREIGN_LITE_BAR);
+ message->AddExtension(unittest::repeated_import_enum_extension_lite,
+ unittest_import::IMPORT_LITE_BAR);
// Add a second one of each field.
- message->AddExtension(unittest::repeated_int32_extension_lite , 301);
- message->AddExtension(unittest::repeated_int64_extension_lite , 302);
- message->AddExtension(unittest::repeated_uint32_extension_lite , 303);
- message->AddExtension(unittest::repeated_uint64_extension_lite , 304);
- message->AddExtension(unittest::repeated_sint32_extension_lite , 305);
- message->AddExtension(unittest::repeated_sint64_extension_lite , 306);
- message->AddExtension(unittest::repeated_fixed32_extension_lite , 307);
- message->AddExtension(unittest::repeated_fixed64_extension_lite , 308);
+ message->AddExtension(unittest::repeated_int32_extension_lite, 301);
+ message->AddExtension(unittest::repeated_int64_extension_lite, 302);
+ message->AddExtension(unittest::repeated_uint32_extension_lite, 303);
+ message->AddExtension(unittest::repeated_uint64_extension_lite, 304);
+ message->AddExtension(unittest::repeated_sint32_extension_lite, 305);
+ message->AddExtension(unittest::repeated_sint64_extension_lite, 306);
+ message->AddExtension(unittest::repeated_fixed32_extension_lite, 307);
+ message->AddExtension(unittest::repeated_fixed64_extension_lite, 308);
message->AddExtension(unittest::repeated_sfixed32_extension_lite, 309);
message->AddExtension(unittest::repeated_sfixed64_extension_lite, 310);
- message->AddExtension(unittest::repeated_float_extension_lite , 311);
- message->AddExtension(unittest::repeated_double_extension_lite , 312);
- message->AddExtension(unittest::repeated_bool_extension_lite , false);
- message->AddExtension(unittest::repeated_string_extension_lite , "315");
- message->AddExtension(unittest::repeated_bytes_extension_lite , "316");
+ message->AddExtension(unittest::repeated_float_extension_lite, 311);
+ message->AddExtension(unittest::repeated_double_extension_lite, 312);
+ message->AddExtension(unittest::repeated_bool_extension_lite, false);
+ message->AddExtension(unittest::repeated_string_extension_lite, "315");
+ message->AddExtension(unittest::repeated_bytes_extension_lite, "316");
- message->AddExtension(unittest::repeatedgroup_extension_lite )->set_a(317);
- message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(318);
- message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(319);
- message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(320);
- message->AddExtension(unittest::repeated_lazy_message_extension_lite )->set_bb(327);
+ message->AddExtension(unittest::repeatedgroup_extension_lite)->set_a(317);
+ message->AddExtension(unittest::repeated_nested_message_extension_lite)
+ ->set_bb(318);
+ message->AddExtension(unittest::repeated_foreign_message_extension_lite)
+ ->set_c(319);
+ message->AddExtension(unittest::repeated_import_message_extension_lite)
+ ->set_d(320);
+ message->AddExtension(unittest::repeated_lazy_message_extension_lite)
+ ->set_bb(327);
- message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ );
- message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ );
- message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ);
+ message->AddExtension(unittest::repeated_nested_enum_extension_lite,
+ unittest::TestAllTypesLite::BAZ);
+ message->AddExtension(unittest::repeated_foreign_enum_extension_lite,
+ unittest::FOREIGN_LITE_BAZ);
+ message->AddExtension(unittest::repeated_import_enum_extension_lite,
+ unittest_import::IMPORT_LITE_BAZ);
// -----------------------------------------------------------------
- message->SetExtension(unittest::default_int32_extension_lite , 401);
- message->SetExtension(unittest::default_int64_extension_lite , 402);
- message->SetExtension(unittest::default_uint32_extension_lite , 403);
- message->SetExtension(unittest::default_uint64_extension_lite , 404);
- message->SetExtension(unittest::default_sint32_extension_lite , 405);
- message->SetExtension(unittest::default_sint64_extension_lite , 406);
- message->SetExtension(unittest::default_fixed32_extension_lite , 407);
- message->SetExtension(unittest::default_fixed64_extension_lite , 408);
+ message->SetExtension(unittest::default_int32_extension_lite, 401);
+ message->SetExtension(unittest::default_int64_extension_lite, 402);
+ message->SetExtension(unittest::default_uint32_extension_lite, 403);
+ message->SetExtension(unittest::default_uint64_extension_lite, 404);
+ message->SetExtension(unittest::default_sint32_extension_lite, 405);
+ message->SetExtension(unittest::default_sint64_extension_lite, 406);
+ message->SetExtension(unittest::default_fixed32_extension_lite, 407);
+ message->SetExtension(unittest::default_fixed64_extension_lite, 408);
message->SetExtension(unittest::default_sfixed32_extension_lite, 409);
message->SetExtension(unittest::default_sfixed64_extension_lite, 410);
- message->SetExtension(unittest::default_float_extension_lite , 411);
- message->SetExtension(unittest::default_double_extension_lite , 412);
- message->SetExtension(unittest::default_bool_extension_lite , false);
- message->SetExtension(unittest::default_string_extension_lite , "415");
- message->SetExtension(unittest::default_bytes_extension_lite , "416");
+ message->SetExtension(unittest::default_float_extension_lite, 411);
+ message->SetExtension(unittest::default_double_extension_lite, 412);
+ message->SetExtension(unittest::default_bool_extension_lite, false);
+ message->SetExtension(unittest::default_string_extension_lite, "415");
+ message->SetExtension(unittest::default_bytes_extension_lite, "416");
- message->SetExtension(unittest::default_nested_enum_extension_lite , unittest::TestAllTypesLite::FOO );
- message->SetExtension(unittest::default_foreign_enum_extension_lite, unittest::FOREIGN_LITE_FOO );
- message->SetExtension(unittest::default_import_enum_extension_lite , unittest_import::IMPORT_LITE_FOO);
+ message->SetExtension(unittest::default_nested_enum_extension_lite,
+ unittest::TestAllTypesLite::FOO);
+ message->SetExtension(unittest::default_foreign_enum_extension_lite,
+ unittest::FOREIGN_LITE_FOO);
+ message->SetExtension(unittest::default_import_enum_extension_lite,
+ unittest_import::IMPORT_LITE_FOO);
message->SetExtension(unittest::oneof_uint32_extension_lite, 601);
- message->MutableExtension(unittest::oneof_nested_message_extension_lite)->set_bb(602);;
+ message->MutableExtension(unittest::oneof_nested_message_extension_lite)
+ ->set_bb(602);
+ ;
message->SetExtension(unittest::oneof_string_extension_lite, "603");
message->SetExtension(unittest::oneof_bytes_extension_lite, "604");
}
@@ -924,31 +953,40 @@
void TestUtilLite::ModifyRepeatedExtensions(
unittest::TestAllExtensionsLite* message) {
- message->SetExtension(unittest::repeated_int32_extension_lite , 1, 501);
- message->SetExtension(unittest::repeated_int64_extension_lite , 1, 502);
- message->SetExtension(unittest::repeated_uint32_extension_lite , 1, 503);
- message->SetExtension(unittest::repeated_uint64_extension_lite , 1, 504);
- message->SetExtension(unittest::repeated_sint32_extension_lite , 1, 505);
- message->SetExtension(unittest::repeated_sint64_extension_lite , 1, 506);
- message->SetExtension(unittest::repeated_fixed32_extension_lite , 1, 507);
- message->SetExtension(unittest::repeated_fixed64_extension_lite , 1, 508);
+ message->SetExtension(unittest::repeated_int32_extension_lite, 1, 501);
+ message->SetExtension(unittest::repeated_int64_extension_lite, 1, 502);
+ message->SetExtension(unittest::repeated_uint32_extension_lite, 1, 503);
+ message->SetExtension(unittest::repeated_uint64_extension_lite, 1, 504);
+ message->SetExtension(unittest::repeated_sint32_extension_lite, 1, 505);
+ message->SetExtension(unittest::repeated_sint64_extension_lite, 1, 506);
+ message->SetExtension(unittest::repeated_fixed32_extension_lite, 1, 507);
+ message->SetExtension(unittest::repeated_fixed64_extension_lite, 1, 508);
message->SetExtension(unittest::repeated_sfixed32_extension_lite, 1, 509);
message->SetExtension(unittest::repeated_sfixed64_extension_lite, 1, 510);
- message->SetExtension(unittest::repeated_float_extension_lite , 1, 511);
- message->SetExtension(unittest::repeated_double_extension_lite , 1, 512);
- message->SetExtension(unittest::repeated_bool_extension_lite , 1, true);
- message->SetExtension(unittest::repeated_string_extension_lite , 1, "515");
- message->SetExtension(unittest::repeated_bytes_extension_lite , 1, "516");
+ message->SetExtension(unittest::repeated_float_extension_lite, 1, 511);
+ message->SetExtension(unittest::repeated_double_extension_lite, 1, 512);
+ message->SetExtension(unittest::repeated_bool_extension_lite, 1, true);
+ message->SetExtension(unittest::repeated_string_extension_lite, 1, "515");
+ message->SetExtension(unittest::repeated_bytes_extension_lite, 1, "516");
- message->MutableExtension(unittest::repeatedgroup_extension_lite , 1)->set_a(517);
- message->MutableExtension(unittest::repeated_nested_message_extension_lite , 1)->set_bb(518);
- message->MutableExtension(unittest::repeated_foreign_message_extension_lite, 1)->set_c(519);
- message->MutableExtension(unittest::repeated_import_message_extension_lite , 1)->set_d(520);
- message->MutableExtension(unittest::repeated_lazy_message_extension_lite , 1)->set_bb(527);
+ message->MutableExtension(unittest::repeatedgroup_extension_lite, 1)
+ ->set_a(517);
+ message->MutableExtension(unittest::repeated_nested_message_extension_lite, 1)
+ ->set_bb(518);
+ message
+ ->MutableExtension(unittest::repeated_foreign_message_extension_lite, 1)
+ ->set_c(519);
+ message->MutableExtension(unittest::repeated_import_message_extension_lite, 1)
+ ->set_d(520);
+ message->MutableExtension(unittest::repeated_lazy_message_extension_lite, 1)
+ ->set_bb(527);
- message->SetExtension(unittest::repeated_nested_enum_extension_lite , 1, unittest::TestAllTypesLite::FOO );
- message->SetExtension(unittest::repeated_foreign_enum_extension_lite, 1, unittest::FOREIGN_LITE_FOO );
- message->SetExtension(unittest::repeated_import_enum_extension_lite , 1, unittest_import::IMPORT_LITE_FOO);
+ message->SetExtension(unittest::repeated_nested_enum_extension_lite, 1,
+ unittest::TestAllTypesLite::FOO);
+ message->SetExtension(unittest::repeated_foreign_enum_extension_lite, 1,
+ unittest::FOREIGN_LITE_FOO);
+ message->SetExtension(unittest::repeated_import_enum_extension_lite, 1,
+ unittest_import::IMPORT_LITE_FOO);
}
@@ -956,202 +994,351 @@
void TestUtilLite::ExpectAllExtensionsSet(
const unittest::TestAllExtensionsLite& message) {
- EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_int64_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_uint64_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_sint32_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_sint64_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_fixed32_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_fixed64_extension_lite ));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_int64_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_uint64_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_sint32_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_sint64_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_fixed32_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_fixed64_extension_lite));
EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed32_extension_lite));
EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed64_extension_lite));
- EXPECT_TRUE(message.HasExtension(unittest::optional_float_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_double_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_bool_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension_lite ));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_float_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_double_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_bool_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension_lite));
- EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_nested_message_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_message_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_import_message_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_public_import_message_extension_lite));
- EXPECT_TRUE(message.HasExtension(unittest::optional_lazy_message_extension_lite ));
+ EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension_lite));
+ EXPECT_TRUE(
+ message.HasExtension(unittest::optional_nested_message_extension_lite));
+ EXPECT_TRUE(
+ message.HasExtension(unittest::optional_foreign_message_extension_lite));
+ EXPECT_TRUE(
+ message.HasExtension(unittest::optional_import_message_extension_lite));
+ EXPECT_TRUE(message.HasExtension(
+ unittest::optional_public_import_message_extension_lite));
+ EXPECT_TRUE(
+ message.HasExtension(unittest::optional_lazy_message_extension_lite));
- EXPECT_TRUE(message.GetExtension(unittest::optionalgroup_extension_lite ).has_a());
- EXPECT_TRUE(message.GetExtension(unittest::optional_nested_message_extension_lite ).has_bb());
- EXPECT_TRUE(message.GetExtension(unittest::optional_foreign_message_extension_lite ).has_c());
- EXPECT_TRUE(message.GetExtension(unittest::optional_import_message_extension_lite ).has_d());
- EXPECT_TRUE(message.GetExtension(unittest::optional_public_import_message_extension_lite).has_e());
- EXPECT_TRUE(message.GetExtension(unittest::optional_lazy_message_extension_lite ).has_bb());
+ EXPECT_TRUE(
+ message.GetExtension(unittest::optionalgroup_extension_lite).has_a());
+ EXPECT_TRUE(
+ message.GetExtension(unittest::optional_nested_message_extension_lite)
+ .has_bb());
+ EXPECT_TRUE(
+ message.GetExtension(unittest::optional_foreign_message_extension_lite)
+ .has_c());
+ EXPECT_TRUE(
+ message.GetExtension(unittest::optional_import_message_extension_lite)
+ .has_d());
+ EXPECT_TRUE(
+ message
+ .GetExtension(unittest::optional_public_import_message_extension_lite)
+ .has_e());
+ EXPECT_TRUE(
+ message.GetExtension(unittest::optional_lazy_message_extension_lite)
+ .has_bb());
- EXPECT_TRUE(message.HasExtension(unittest::optional_nested_enum_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_enum_extension_lite));
- EXPECT_TRUE(message.HasExtension(unittest::optional_import_enum_extension_lite ));
+ EXPECT_TRUE(
+ message.HasExtension(unittest::optional_nested_enum_extension_lite));
+ EXPECT_TRUE(
+ message.HasExtension(unittest::optional_foreign_enum_extension_lite));
+ EXPECT_TRUE(
+ message.HasExtension(unittest::optional_import_enum_extension_lite));
- EXPECT_EQ(101 , message.GetExtension(unittest::optional_int32_extension_lite ));
- EXPECT_EQ(102 , message.GetExtension(unittest::optional_int64_extension_lite ));
- EXPECT_EQ(103 , message.GetExtension(unittest::optional_uint32_extension_lite ));
- EXPECT_EQ(104 , message.GetExtension(unittest::optional_uint64_extension_lite ));
- EXPECT_EQ(105 , message.GetExtension(unittest::optional_sint32_extension_lite ));
- EXPECT_EQ(106 , message.GetExtension(unittest::optional_sint64_extension_lite ));
- EXPECT_EQ(107 , message.GetExtension(unittest::optional_fixed32_extension_lite ));
- EXPECT_EQ(108 , message.GetExtension(unittest::optional_fixed64_extension_lite ));
- EXPECT_EQ(109 , message.GetExtension(unittest::optional_sfixed32_extension_lite));
- EXPECT_EQ(110 , message.GetExtension(unittest::optional_sfixed64_extension_lite));
- EXPECT_EQ(111 , message.GetExtension(unittest::optional_float_extension_lite ));
- EXPECT_EQ(112 , message.GetExtension(unittest::optional_double_extension_lite ));
- EXPECT_EQ(true , message.GetExtension(unittest::optional_bool_extension_lite ));
- EXPECT_EQ("115", message.GetExtension(unittest::optional_string_extension_lite ));
- EXPECT_EQ("116", message.GetExtension(unittest::optional_bytes_extension_lite ));
+ EXPECT_EQ(101, message.GetExtension(unittest::optional_int32_extension_lite));
+ EXPECT_EQ(102, message.GetExtension(unittest::optional_int64_extension_lite));
+ EXPECT_EQ(103,
+ message.GetExtension(unittest::optional_uint32_extension_lite));
+ EXPECT_EQ(104,
+ message.GetExtension(unittest::optional_uint64_extension_lite));
+ EXPECT_EQ(105,
+ message.GetExtension(unittest::optional_sint32_extension_lite));
+ EXPECT_EQ(106,
+ message.GetExtension(unittest::optional_sint64_extension_lite));
+ EXPECT_EQ(107,
+ message.GetExtension(unittest::optional_fixed32_extension_lite));
+ EXPECT_EQ(108,
+ message.GetExtension(unittest::optional_fixed64_extension_lite));
+ EXPECT_EQ(109,
+ message.GetExtension(unittest::optional_sfixed32_extension_lite));
+ EXPECT_EQ(110,
+ message.GetExtension(unittest::optional_sfixed64_extension_lite));
+ EXPECT_EQ(111, message.GetExtension(unittest::optional_float_extension_lite));
+ EXPECT_EQ(112,
+ message.GetExtension(unittest::optional_double_extension_lite));
+ EXPECT_EQ(true, message.GetExtension(unittest::optional_bool_extension_lite));
+ EXPECT_EQ("115",
+ message.GetExtension(unittest::optional_string_extension_lite));
+ EXPECT_EQ("116",
+ message.GetExtension(unittest::optional_bytes_extension_lite));
- EXPECT_EQ(117, message.GetExtension(unittest::optionalgroup_extension_lite ).a());
- EXPECT_EQ(118, message.GetExtension(unittest::optional_nested_message_extension_lite ).bb());
- EXPECT_EQ(119, message.GetExtension(unittest::optional_foreign_message_extension_lite ).c());
- EXPECT_EQ(120, message.GetExtension(unittest::optional_import_message_extension_lite ).d());
- EXPECT_EQ(126, message.GetExtension(unittest::optional_public_import_message_extension_lite).e());
- EXPECT_EQ(127, message.GetExtension(unittest::optional_lazy_message_extension_lite ).bb());
+ EXPECT_EQ(117,
+ message.GetExtension(unittest::optionalgroup_extension_lite).a());
+ EXPECT_EQ(
+ 118,
+ message.GetExtension(unittest::optional_nested_message_extension_lite)
+ .bb());
+ EXPECT_EQ(
+ 119,
+ message.GetExtension(unittest::optional_foreign_message_extension_lite)
+ .c());
+ EXPECT_EQ(
+ 120,
+ message.GetExtension(unittest::optional_import_message_extension_lite)
+ .d());
+ EXPECT_EQ(
+ 126,
+ message
+ .GetExtension(unittest::optional_public_import_message_extension_lite)
+ .e());
+ EXPECT_EQ(127,
+ message.GetExtension(unittest::optional_lazy_message_extension_lite)
+ .bb());
- EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::optional_nested_enum_extension_lite ));
- EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.GetExtension(unittest::optional_foreign_enum_extension_lite));
- EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::optional_import_enum_extension_lite ));
+ EXPECT_EQ(
+ unittest::TestAllTypesLite::BAZ,
+ message.GetExtension(unittest::optional_nested_enum_extension_lite));
+ EXPECT_EQ(
+ unittest::FOREIGN_LITE_BAZ,
+ message.GetExtension(unittest::optional_foreign_enum_extension_lite));
+ EXPECT_EQ(
+ unittest_import::IMPORT_LITE_BAZ,
+ message.GetExtension(unittest::optional_import_enum_extension_lite));
// -----------------------------------------------------------------
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite ));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite));
+ ASSERT_EQ(2,
+ message.ExtensionSize(unittest::repeated_fixed32_extension_lite));
+ ASSERT_EQ(2,
+ message.ExtensionSize(unittest::repeated_fixed64_extension_lite));
+ ASSERT_EQ(2,
+ message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
+ ASSERT_EQ(2,
+ message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite ));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(
+ unittest::repeated_nested_message_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(
+ unittest::repeated_foreign_message_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(
+ unittest::repeated_import_message_extension_lite));
+ ASSERT_EQ(
+ 2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite));
+ ASSERT_EQ(
+ 2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite));
+ ASSERT_EQ(
+ 2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite));
+ ASSERT_EQ(
+ 2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite));
- EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension_lite , 0));
- EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension_lite , 0));
- EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension_lite , 0));
- EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension_lite , 0));
- EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension_lite , 0));
- EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension_lite , 0));
- EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0));
- EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0));
- EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
- EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
- EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension_lite , 0));
- EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension_lite , 0));
- EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite , 0));
- EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite , 0));
- EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite , 0));
+ EXPECT_EQ(201,
+ message.GetExtension(unittest::repeated_int32_extension_lite, 0));
+ EXPECT_EQ(202,
+ message.GetExtension(unittest::repeated_int64_extension_lite, 0));
+ EXPECT_EQ(203,
+ message.GetExtension(unittest::repeated_uint32_extension_lite, 0));
+ EXPECT_EQ(204,
+ message.GetExtension(unittest::repeated_uint64_extension_lite, 0));
+ EXPECT_EQ(205,
+ message.GetExtension(unittest::repeated_sint32_extension_lite, 0));
+ EXPECT_EQ(206,
+ message.GetExtension(unittest::repeated_sint64_extension_lite, 0));
+ EXPECT_EQ(207,
+ message.GetExtension(unittest::repeated_fixed32_extension_lite, 0));
+ EXPECT_EQ(208,
+ message.GetExtension(unittest::repeated_fixed64_extension_lite, 0));
+ EXPECT_EQ(
+ 209, message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
+ EXPECT_EQ(
+ 210, message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
+ EXPECT_EQ(211,
+ message.GetExtension(unittest::repeated_float_extension_lite, 0));
+ EXPECT_EQ(212,
+ message.GetExtension(unittest::repeated_double_extension_lite, 0));
+ EXPECT_EQ(true,
+ message.GetExtension(unittest::repeated_bool_extension_lite, 0));
+ EXPECT_EQ("215",
+ message.GetExtension(unittest::repeated_string_extension_lite, 0));
+ EXPECT_EQ("216",
+ message.GetExtension(unittest::repeated_bytes_extension_lite, 0));
- EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite , 0).a());
- EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb());
- EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c());
- EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d());
- EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 0).bb());
+ EXPECT_EQ(
+ 217, message.GetExtension(unittest::repeatedgroup_extension_lite, 0).a());
+ EXPECT_EQ(
+ 218,
+ message.GetExtension(unittest::repeated_nested_message_extension_lite, 0)
+ .bb());
+ EXPECT_EQ(
+ 219,
+ message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0)
+ .c());
+ EXPECT_EQ(
+ 220,
+ message.GetExtension(unittest::repeated_import_message_extension_lite, 0)
+ .d());
+ EXPECT_EQ(
+ 227,
+ message.GetExtension(unittest::repeated_lazy_message_extension_lite, 0)
+ .bb());
- EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0));
- EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
- EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0));
+ EXPECT_EQ(
+ unittest::TestAllTypesLite::BAR,
+ message.GetExtension(unittest::repeated_nested_enum_extension_lite, 0));
+ EXPECT_EQ(
+ unittest::FOREIGN_LITE_BAR,
+ message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
+ EXPECT_EQ(
+ unittest_import::IMPORT_LITE_BAR,
+ message.GetExtension(unittest::repeated_import_enum_extension_lite, 0));
- EXPECT_EQ(301 , message.GetExtension(unittest::repeated_int32_extension_lite , 1));
- EXPECT_EQ(302 , message.GetExtension(unittest::repeated_int64_extension_lite , 1));
- EXPECT_EQ(303 , message.GetExtension(unittest::repeated_uint32_extension_lite , 1));
- EXPECT_EQ(304 , message.GetExtension(unittest::repeated_uint64_extension_lite , 1));
- EXPECT_EQ(305 , message.GetExtension(unittest::repeated_sint32_extension_lite , 1));
- EXPECT_EQ(306 , message.GetExtension(unittest::repeated_sint64_extension_lite , 1));
- EXPECT_EQ(307 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1));
- EXPECT_EQ(308 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1));
- EXPECT_EQ(309 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
- EXPECT_EQ(310 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
- EXPECT_EQ(311 , message.GetExtension(unittest::repeated_float_extension_lite , 1));
- EXPECT_EQ(312 , message.GetExtension(unittest::repeated_double_extension_lite , 1));
- EXPECT_EQ(false, message.GetExtension(unittest::repeated_bool_extension_lite , 1));
- EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension_lite , 1));
- EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension_lite , 1));
+ EXPECT_EQ(301,
+ message.GetExtension(unittest::repeated_int32_extension_lite, 1));
+ EXPECT_EQ(302,
+ message.GetExtension(unittest::repeated_int64_extension_lite, 1));
+ EXPECT_EQ(303,
+ message.GetExtension(unittest::repeated_uint32_extension_lite, 1));
+ EXPECT_EQ(304,
+ message.GetExtension(unittest::repeated_uint64_extension_lite, 1));
+ EXPECT_EQ(305,
+ message.GetExtension(unittest::repeated_sint32_extension_lite, 1));
+ EXPECT_EQ(306,
+ message.GetExtension(unittest::repeated_sint64_extension_lite, 1));
+ EXPECT_EQ(307,
+ message.GetExtension(unittest::repeated_fixed32_extension_lite, 1));
+ EXPECT_EQ(308,
+ message.GetExtension(unittest::repeated_fixed64_extension_lite, 1));
+ EXPECT_EQ(
+ 309, message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
+ EXPECT_EQ(
+ 310, message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
+ EXPECT_EQ(311,
+ message.GetExtension(unittest::repeated_float_extension_lite, 1));
+ EXPECT_EQ(312,
+ message.GetExtension(unittest::repeated_double_extension_lite, 1));
+ EXPECT_EQ(false,
+ message.GetExtension(unittest::repeated_bool_extension_lite, 1));
+ EXPECT_EQ("315",
+ message.GetExtension(unittest::repeated_string_extension_lite, 1));
+ EXPECT_EQ("316",
+ message.GetExtension(unittest::repeated_bytes_extension_lite, 1));
- EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension_lite , 1).a());
- EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb());
- EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c());
- EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d());
- EXPECT_EQ(327, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 1).bb());
+ EXPECT_EQ(
+ 317, message.GetExtension(unittest::repeatedgroup_extension_lite, 1).a());
+ EXPECT_EQ(
+ 318,
+ message.GetExtension(unittest::repeated_nested_message_extension_lite, 1)
+ .bb());
+ EXPECT_EQ(
+ 319,
+ message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1)
+ .c());
+ EXPECT_EQ(
+ 320,
+ message.GetExtension(unittest::repeated_import_message_extension_lite, 1)
+ .d());
+ EXPECT_EQ(
+ 327,
+ message.GetExtension(unittest::repeated_lazy_message_extension_lite, 1)
+ .bb());
- EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1));
- EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
- EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1));
+ EXPECT_EQ(
+ unittest::TestAllTypesLite::BAZ,
+ message.GetExtension(unittest::repeated_nested_enum_extension_lite, 1));
+ EXPECT_EQ(
+ unittest::FOREIGN_LITE_BAZ,
+ message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
+ EXPECT_EQ(
+ unittest_import::IMPORT_LITE_BAZ,
+ message.GetExtension(unittest::repeated_import_enum_extension_lite, 1));
// -----------------------------------------------------------------
- EXPECT_TRUE(message.HasExtension(unittest::default_int32_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_int64_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_uint32_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_uint64_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_sint32_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_sint64_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_fixed32_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_fixed64_extension_lite ));
+ EXPECT_TRUE(message.HasExtension(unittest::default_int32_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::default_int64_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::default_uint32_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::default_uint64_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::default_sint32_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::default_sint64_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::default_fixed32_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::default_fixed64_extension_lite));
EXPECT_TRUE(message.HasExtension(unittest::default_sfixed32_extension_lite));
EXPECT_TRUE(message.HasExtension(unittest::default_sfixed64_extension_lite));
- EXPECT_TRUE(message.HasExtension(unittest::default_float_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_double_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_bool_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_string_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_bytes_extension_lite ));
+ EXPECT_TRUE(message.HasExtension(unittest::default_float_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::default_double_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::default_bool_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::default_string_extension_lite));
+ EXPECT_TRUE(message.HasExtension(unittest::default_bytes_extension_lite));
- EXPECT_TRUE(message.HasExtension(unittest::default_nested_enum_extension_lite ));
- EXPECT_TRUE(message.HasExtension(unittest::default_foreign_enum_extension_lite));
- EXPECT_TRUE(message.HasExtension(unittest::default_import_enum_extension_lite ));
+ EXPECT_TRUE(
+ message.HasExtension(unittest::default_nested_enum_extension_lite));
+ EXPECT_TRUE(
+ message.HasExtension(unittest::default_foreign_enum_extension_lite));
+ EXPECT_TRUE(
+ message.HasExtension(unittest::default_import_enum_extension_lite));
- EXPECT_EQ(401 , message.GetExtension(unittest::default_int32_extension_lite ));
- EXPECT_EQ(402 , message.GetExtension(unittest::default_int64_extension_lite ));
- EXPECT_EQ(403 , message.GetExtension(unittest::default_uint32_extension_lite ));
- EXPECT_EQ(404 , message.GetExtension(unittest::default_uint64_extension_lite ));
- EXPECT_EQ(405 , message.GetExtension(unittest::default_sint32_extension_lite ));
- EXPECT_EQ(406 , message.GetExtension(unittest::default_sint64_extension_lite ));
- EXPECT_EQ(407 , message.GetExtension(unittest::default_fixed32_extension_lite ));
- EXPECT_EQ(408 , message.GetExtension(unittest::default_fixed64_extension_lite ));
- EXPECT_EQ(409 , message.GetExtension(unittest::default_sfixed32_extension_lite));
- EXPECT_EQ(410 , message.GetExtension(unittest::default_sfixed64_extension_lite));
- EXPECT_EQ(411 , message.GetExtension(unittest::default_float_extension_lite ));
- EXPECT_EQ(412 , message.GetExtension(unittest::default_double_extension_lite ));
- EXPECT_EQ(false, message.GetExtension(unittest::default_bool_extension_lite ));
- EXPECT_EQ("415", message.GetExtension(unittest::default_string_extension_lite ));
- EXPECT_EQ("416", message.GetExtension(unittest::default_bytes_extension_lite ));
+ EXPECT_EQ(401, message.GetExtension(unittest::default_int32_extension_lite));
+ EXPECT_EQ(402, message.GetExtension(unittest::default_int64_extension_lite));
+ EXPECT_EQ(403, message.GetExtension(unittest::default_uint32_extension_lite));
+ EXPECT_EQ(404, message.GetExtension(unittest::default_uint64_extension_lite));
+ EXPECT_EQ(405, message.GetExtension(unittest::default_sint32_extension_lite));
+ EXPECT_EQ(406, message.GetExtension(unittest::default_sint64_extension_lite));
+ EXPECT_EQ(407,
+ message.GetExtension(unittest::default_fixed32_extension_lite));
+ EXPECT_EQ(408,
+ message.GetExtension(unittest::default_fixed64_extension_lite));
+ EXPECT_EQ(409,
+ message.GetExtension(unittest::default_sfixed32_extension_lite));
+ EXPECT_EQ(410,
+ message.GetExtension(unittest::default_sfixed64_extension_lite));
+ EXPECT_EQ(411, message.GetExtension(unittest::default_float_extension_lite));
+ EXPECT_EQ(412, message.GetExtension(unittest::default_double_extension_lite));
+ EXPECT_EQ(false, message.GetExtension(unittest::default_bool_extension_lite));
+ EXPECT_EQ("415",
+ message.GetExtension(unittest::default_string_extension_lite));
+ EXPECT_EQ("416",
+ message.GetExtension(unittest::default_bytes_extension_lite));
- EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::default_nested_enum_extension_lite ));
- EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.GetExtension(unittest::default_foreign_enum_extension_lite));
- EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::default_import_enum_extension_lite ));
+ EXPECT_EQ(unittest::TestAllTypesLite::FOO,
+ message.GetExtension(unittest::default_nested_enum_extension_lite));
+ EXPECT_EQ(
+ unittest::FOREIGN_LITE_FOO,
+ message.GetExtension(unittest::default_foreign_enum_extension_lite));
+ EXPECT_EQ(unittest_import::IMPORT_LITE_FOO,
+ message.GetExtension(unittest::default_import_enum_extension_lite));
EXPECT_TRUE(message.HasExtension(unittest::oneof_uint32_extension_lite));
- EXPECT_TRUE(message.GetExtension(unittest::oneof_nested_message_extension_lite).has_bb());
+ EXPECT_TRUE(
+ message.GetExtension(unittest::oneof_nested_message_extension_lite)
+ .has_bb());
EXPECT_TRUE(message.HasExtension(unittest::oneof_string_extension_lite));
EXPECT_TRUE(message.HasExtension(unittest::oneof_bytes_extension_lite));
EXPECT_EQ(601, message.GetExtension(unittest::oneof_uint32_extension_lite));
- EXPECT_EQ(602, message.GetExtension(unittest::oneof_nested_message_extension_lite).bb());
+ EXPECT_EQ(
+ 602,
+ message.GetExtension(unittest::oneof_nested_message_extension_lite).bb());
EXPECT_EQ("603", message.GetExtension(unittest::oneof_string_extension_lite));
EXPECT_EQ("604", message.GetExtension(unittest::oneof_bytes_extension_lite));
}
@@ -1166,145 +1353,213 @@
EXPECT_EQ(0, message.ByteSize());
// has_blah() should initially be false for all optional fields.
- EXPECT_FALSE(message.HasExtension(unittest::optional_int32_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_uint32_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_uint64_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_sint32_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_sint64_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_fixed32_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_fixed64_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed32_extension_lite));
- EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed64_extension_lite));
- EXPECT_FALSE(message.HasExtension(unittest::optional_float_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_double_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_bool_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension_lite ));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_int32_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_uint32_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_uint64_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_sint32_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_sint64_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_fixed32_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_fixed64_extension_lite));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_sfixed32_extension_lite));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_sfixed64_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_float_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_double_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_bool_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension_lite));
- EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_nested_message_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_message_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_import_message_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_public_import_message_extension_lite));
- EXPECT_FALSE(message.HasExtension(unittest::optional_lazy_message_extension_lite ));
+ EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension_lite));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_nested_message_extension_lite));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_foreign_message_extension_lite));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_import_message_extension_lite));
+ EXPECT_FALSE(message.HasExtension(
+ unittest::optional_public_import_message_extension_lite));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_lazy_message_extension_lite));
- EXPECT_FALSE(message.HasExtension(unittest::optional_nested_enum_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_enum_extension_lite));
- EXPECT_FALSE(message.HasExtension(unittest::optional_import_enum_extension_lite ));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_nested_enum_extension_lite));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_foreign_enum_extension_lite));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::optional_import_enum_extension_lite));
// Optional fields without defaults are set to zero or something like it.
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_int32_extension_lite ));
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_int64_extension_lite ));
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint32_extension_lite ));
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint64_extension_lite ));
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint32_extension_lite ));
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint64_extension_lite ));
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed32_extension_lite ));
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed64_extension_lite ));
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed32_extension_lite));
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed64_extension_lite));
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_float_extension_lite ));
- EXPECT_EQ(0 , message.GetExtension(unittest::optional_double_extension_lite ));
- EXPECT_EQ(false, message.GetExtension(unittest::optional_bool_extension_lite ));
- EXPECT_EQ("" , message.GetExtension(unittest::optional_string_extension_lite ));
- EXPECT_EQ("" , message.GetExtension(unittest::optional_bytes_extension_lite ));
+ EXPECT_EQ(0, message.GetExtension(unittest::optional_int32_extension_lite));
+ EXPECT_EQ(0, message.GetExtension(unittest::optional_int64_extension_lite));
+ EXPECT_EQ(0, message.GetExtension(unittest::optional_uint32_extension_lite));
+ EXPECT_EQ(0, message.GetExtension(unittest::optional_uint64_extension_lite));
+ EXPECT_EQ(0, message.GetExtension(unittest::optional_sint32_extension_lite));
+ EXPECT_EQ(0, message.GetExtension(unittest::optional_sint64_extension_lite));
+ EXPECT_EQ(0, message.GetExtension(unittest::optional_fixed32_extension_lite));
+ EXPECT_EQ(0, message.GetExtension(unittest::optional_fixed64_extension_lite));
+ EXPECT_EQ(0,
+ message.GetExtension(unittest::optional_sfixed32_extension_lite));
+ EXPECT_EQ(0,
+ message.GetExtension(unittest::optional_sfixed64_extension_lite));
+ EXPECT_EQ(0, message.GetExtension(unittest::optional_float_extension_lite));
+ EXPECT_EQ(0, message.GetExtension(unittest::optional_double_extension_lite));
+ EXPECT_EQ(false,
+ message.GetExtension(unittest::optional_bool_extension_lite));
+ EXPECT_EQ("", message.GetExtension(unittest::optional_string_extension_lite));
+ EXPECT_EQ("", message.GetExtension(unittest::optional_bytes_extension_lite));
// Embedded messages should also be clear.
- EXPECT_FALSE(message.GetExtension(unittest::optionalgroup_extension_lite ).has_a());
- EXPECT_FALSE(message.GetExtension(unittest::optional_nested_message_extension_lite ).has_bb());
- EXPECT_FALSE(message.GetExtension(unittest::optional_foreign_message_extension_lite ).has_c());
- EXPECT_FALSE(message.GetExtension(unittest::optional_import_message_extension_lite ).has_d());
- EXPECT_FALSE(message.GetExtension(unittest::optional_public_import_message_extension_lite).has_e());
- EXPECT_FALSE(message.GetExtension(unittest::optional_lazy_message_extension_lite ).has_bb());
+ EXPECT_FALSE(
+ message.GetExtension(unittest::optionalgroup_extension_lite).has_a());
+ EXPECT_FALSE(
+ message.GetExtension(unittest::optional_nested_message_extension_lite)
+ .has_bb());
+ EXPECT_FALSE(
+ message.GetExtension(unittest::optional_foreign_message_extension_lite)
+ .has_c());
+ EXPECT_FALSE(
+ message.GetExtension(unittest::optional_import_message_extension_lite)
+ .has_d());
+ EXPECT_FALSE(
+ message
+ .GetExtension(unittest::optional_public_import_message_extension_lite)
+ .has_e());
+ EXPECT_FALSE(
+ message.GetExtension(unittest::optional_lazy_message_extension_lite)
+ .has_bb());
- EXPECT_EQ(0, message.GetExtension(unittest::optionalgroup_extension_lite ).a());
- EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension_lite ).bb());
- EXPECT_EQ(0, message.GetExtension(unittest::optional_foreign_message_extension_lite ).c());
- EXPECT_EQ(0, message.GetExtension(unittest::optional_import_message_extension_lite ).d());
- EXPECT_EQ(0, message.GetExtension(unittest::optional_public_import_message_extension_lite).e());
- EXPECT_EQ(0, message.GetExtension(unittest::optional_lazy_message_extension_lite ).bb());
+ EXPECT_EQ(0,
+ message.GetExtension(unittest::optionalgroup_extension_lite).a());
+ EXPECT_EQ(
+ 0, message.GetExtension(unittest::optional_nested_message_extension_lite)
+ .bb());
+ EXPECT_EQ(
+ 0, message.GetExtension(unittest::optional_foreign_message_extension_lite)
+ .c());
+ EXPECT_EQ(
+ 0, message.GetExtension(unittest::optional_import_message_extension_lite)
+ .d());
+ EXPECT_EQ(0, message
+ .GetExtension(
+ unittest::optional_public_import_message_extension_lite)
+ .e());
+ EXPECT_EQ(0,
+ message.GetExtension(unittest::optional_lazy_message_extension_lite)
+ .bb());
// Enums without defaults are set to the first value in the enum.
- EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::optional_nested_enum_extension_lite ));
- EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.GetExtension(unittest::optional_foreign_enum_extension_lite));
- EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::optional_import_enum_extension_lite ));
+ EXPECT_EQ(
+ unittest::TestAllTypesLite::FOO,
+ message.GetExtension(unittest::optional_nested_enum_extension_lite));
+ EXPECT_EQ(
+ unittest::FOREIGN_LITE_FOO,
+ message.GetExtension(unittest::optional_foreign_enum_extension_lite));
+ EXPECT_EQ(
+ unittest_import::IMPORT_LITE_FOO,
+ message.GetExtension(unittest::optional_import_enum_extension_lite));
// Repeated fields are empty.
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int32_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int64_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint32_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint64_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint32_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint64_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_float_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_double_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bool_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bytes_extension_lite ));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int32_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int64_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint32_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint64_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint32_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint64_extension_lite));
+ EXPECT_EQ(0,
+ message.ExtensionSize(unittest::repeated_fixed32_extension_lite));
+ EXPECT_EQ(0,
+ message.ExtensionSize(unittest::repeated_fixed64_extension_lite));
+ EXPECT_EQ(0,
+ message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
+ EXPECT_EQ(0,
+ message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_float_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_double_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bool_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bytes_extension_lite));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeatedgroup_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_enum_extension_lite ));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::repeatedgroup_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(
+ unittest::repeated_nested_message_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(
+ unittest::repeated_foreign_message_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(
+ unittest::repeated_import_message_extension_lite));
+ EXPECT_EQ(
+ 0, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite));
+ EXPECT_EQ(
+ 0, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite));
+ EXPECT_EQ(
+ 0, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite));
+ EXPECT_EQ(
+ 0, message.ExtensionSize(unittest::repeated_import_enum_extension_lite));
// has_blah() should also be false for all default fields.
- EXPECT_FALSE(message.HasExtension(unittest::default_int32_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_int64_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_uint32_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_uint64_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_sint32_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_sint64_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_fixed32_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_fixed64_extension_lite ));
+ EXPECT_FALSE(message.HasExtension(unittest::default_int32_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::default_int64_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::default_uint32_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::default_uint64_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::default_sint32_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::default_sint64_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::default_fixed32_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::default_fixed64_extension_lite));
EXPECT_FALSE(message.HasExtension(unittest::default_sfixed32_extension_lite));
EXPECT_FALSE(message.HasExtension(unittest::default_sfixed64_extension_lite));
- EXPECT_FALSE(message.HasExtension(unittest::default_float_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_double_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_bool_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_string_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_bytes_extension_lite ));
+ EXPECT_FALSE(message.HasExtension(unittest::default_float_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::default_double_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::default_bool_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::default_string_extension_lite));
+ EXPECT_FALSE(message.HasExtension(unittest::default_bytes_extension_lite));
- EXPECT_FALSE(message.HasExtension(unittest::default_nested_enum_extension_lite ));
- EXPECT_FALSE(message.HasExtension(unittest::default_foreign_enum_extension_lite));
- EXPECT_FALSE(message.HasExtension(unittest::default_import_enum_extension_lite ));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::default_nested_enum_extension_lite));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::default_foreign_enum_extension_lite));
+ EXPECT_FALSE(
+ message.HasExtension(unittest::default_import_enum_extension_lite));
// Fields with defaults have their default values (duh).
- EXPECT_EQ( 41 , message.GetExtension(unittest::default_int32_extension_lite ));
- EXPECT_EQ( 42 , message.GetExtension(unittest::default_int64_extension_lite ));
- EXPECT_EQ( 43 , message.GetExtension(unittest::default_uint32_extension_lite ));
- EXPECT_EQ( 44 , message.GetExtension(unittest::default_uint64_extension_lite ));
- EXPECT_EQ(-45 , message.GetExtension(unittest::default_sint32_extension_lite ));
- EXPECT_EQ( 46 , message.GetExtension(unittest::default_sint64_extension_lite ));
- EXPECT_EQ( 47 , message.GetExtension(unittest::default_fixed32_extension_lite ));
- EXPECT_EQ( 48 , message.GetExtension(unittest::default_fixed64_extension_lite ));
- EXPECT_EQ( 49 , message.GetExtension(unittest::default_sfixed32_extension_lite));
- EXPECT_EQ(-50 , message.GetExtension(unittest::default_sfixed64_extension_lite));
- EXPECT_EQ( 51.5 , message.GetExtension(unittest::default_float_extension_lite ));
- EXPECT_EQ( 52e3 , message.GetExtension(unittest::default_double_extension_lite ));
- EXPECT_EQ(true , message.GetExtension(unittest::default_bool_extension_lite ));
- EXPECT_EQ("hello", message.GetExtension(unittest::default_string_extension_lite ));
- EXPECT_EQ("world", message.GetExtension(unittest::default_bytes_extension_lite ));
+ EXPECT_EQ(41, message.GetExtension(unittest::default_int32_extension_lite));
+ EXPECT_EQ(42, message.GetExtension(unittest::default_int64_extension_lite));
+ EXPECT_EQ(43, message.GetExtension(unittest::default_uint32_extension_lite));
+ EXPECT_EQ(44, message.GetExtension(unittest::default_uint64_extension_lite));
+ EXPECT_EQ(-45, message.GetExtension(unittest::default_sint32_extension_lite));
+ EXPECT_EQ(46, message.GetExtension(unittest::default_sint64_extension_lite));
+ EXPECT_EQ(47, message.GetExtension(unittest::default_fixed32_extension_lite));
+ EXPECT_EQ(48, message.GetExtension(unittest::default_fixed64_extension_lite));
+ EXPECT_EQ(49,
+ message.GetExtension(unittest::default_sfixed32_extension_lite));
+ EXPECT_EQ(-50,
+ message.GetExtension(unittest::default_sfixed64_extension_lite));
+ EXPECT_EQ(51.5, message.GetExtension(unittest::default_float_extension_lite));
+ EXPECT_EQ(52e3,
+ message.GetExtension(unittest::default_double_extension_lite));
+ EXPECT_EQ(true, message.GetExtension(unittest::default_bool_extension_lite));
+ EXPECT_EQ("hello",
+ message.GetExtension(unittest::default_string_extension_lite));
+ EXPECT_EQ("world",
+ message.GetExtension(unittest::default_bytes_extension_lite));
- EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::default_nested_enum_extension_lite ));
- EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.GetExtension(unittest::default_foreign_enum_extension_lite));
- EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::default_import_enum_extension_lite ));
+ EXPECT_EQ(unittest::TestAllTypesLite::BAR,
+ message.GetExtension(unittest::default_nested_enum_extension_lite));
+ EXPECT_EQ(
+ unittest::FOREIGN_LITE_BAR,
+ message.GetExtension(unittest::default_foreign_enum_extension_lite));
+ EXPECT_EQ(unittest_import::IMPORT_LITE_BAR,
+ message.GetExtension(unittest::default_import_enum_extension_lite));
EXPECT_FALSE(message.HasExtension(unittest::oneof_uint32_extension_lite));
- EXPECT_FALSE(message.GetExtension(unittest::oneof_nested_message_extension_lite).has_bb());
+ EXPECT_FALSE(
+ message.GetExtension(unittest::oneof_nested_message_extension_lite)
+ .has_bb());
EXPECT_FALSE(message.HasExtension(unittest::oneof_string_extension_lite));
EXPECT_FALSE(message.HasExtension(unittest::oneof_bytes_extension_lite));
}
@@ -1316,85 +1571,164 @@
// ModifyRepeatedFields only sets the second repeated element of each
// field. In addition to verifying this, we also verify that the first
// element and size were *not* modified.
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite ));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite));
+ ASSERT_EQ(2,
+ message.ExtensionSize(unittest::repeated_fixed32_extension_lite));
+ ASSERT_EQ(2,
+ message.ExtensionSize(unittest::repeated_fixed64_extension_lite));
+ ASSERT_EQ(2,
+ message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
+ ASSERT_EQ(2,
+ message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite ));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(
+ unittest::repeated_nested_message_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(
+ unittest::repeated_foreign_message_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(
+ unittest::repeated_import_message_extension_lite));
+ ASSERT_EQ(
+ 2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite));
+ ASSERT_EQ(
+ 2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite));
+ ASSERT_EQ(
+ 2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite));
+ ASSERT_EQ(
+ 2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite));
- EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension_lite , 0));
- EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension_lite , 0));
- EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension_lite , 0));
- EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension_lite , 0));
- EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension_lite , 0));
- EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension_lite , 0));
- EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0));
- EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0));
- EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
- EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
- EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension_lite , 0));
- EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension_lite , 0));
- EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite , 0));
- EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite , 0));
- EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite , 0));
+ EXPECT_EQ(201,
+ message.GetExtension(unittest::repeated_int32_extension_lite, 0));
+ EXPECT_EQ(202,
+ message.GetExtension(unittest::repeated_int64_extension_lite, 0));
+ EXPECT_EQ(203,
+ message.GetExtension(unittest::repeated_uint32_extension_lite, 0));
+ EXPECT_EQ(204,
+ message.GetExtension(unittest::repeated_uint64_extension_lite, 0));
+ EXPECT_EQ(205,
+ message.GetExtension(unittest::repeated_sint32_extension_lite, 0));
+ EXPECT_EQ(206,
+ message.GetExtension(unittest::repeated_sint64_extension_lite, 0));
+ EXPECT_EQ(207,
+ message.GetExtension(unittest::repeated_fixed32_extension_lite, 0));
+ EXPECT_EQ(208,
+ message.GetExtension(unittest::repeated_fixed64_extension_lite, 0));
+ EXPECT_EQ(
+ 209, message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
+ EXPECT_EQ(
+ 210, message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
+ EXPECT_EQ(211,
+ message.GetExtension(unittest::repeated_float_extension_lite, 0));
+ EXPECT_EQ(212,
+ message.GetExtension(unittest::repeated_double_extension_lite, 0));
+ EXPECT_EQ(true,
+ message.GetExtension(unittest::repeated_bool_extension_lite, 0));
+ EXPECT_EQ("215",
+ message.GetExtension(unittest::repeated_string_extension_lite, 0));
+ EXPECT_EQ("216",
+ message.GetExtension(unittest::repeated_bytes_extension_lite, 0));
- EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite , 0).a());
- EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb());
- EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c());
- EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d());
- EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 0).bb());
+ EXPECT_EQ(
+ 217, message.GetExtension(unittest::repeatedgroup_extension_lite, 0).a());
+ EXPECT_EQ(
+ 218,
+ message.GetExtension(unittest::repeated_nested_message_extension_lite, 0)
+ .bb());
+ EXPECT_EQ(
+ 219,
+ message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0)
+ .c());
+ EXPECT_EQ(
+ 220,
+ message.GetExtension(unittest::repeated_import_message_extension_lite, 0)
+ .d());
+ EXPECT_EQ(
+ 227,
+ message.GetExtension(unittest::repeated_lazy_message_extension_lite, 0)
+ .bb());
- EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0));
- EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
- EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0));
+ EXPECT_EQ(
+ unittest::TestAllTypesLite::BAR,
+ message.GetExtension(unittest::repeated_nested_enum_extension_lite, 0));
+ EXPECT_EQ(
+ unittest::FOREIGN_LITE_BAR,
+ message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
+ EXPECT_EQ(
+ unittest_import::IMPORT_LITE_BAR,
+ message.GetExtension(unittest::repeated_import_enum_extension_lite, 0));
// Actually verify the second (modified) elements now.
- EXPECT_EQ(501 , message.GetExtension(unittest::repeated_int32_extension_lite , 1));
- EXPECT_EQ(502 , message.GetExtension(unittest::repeated_int64_extension_lite , 1));
- EXPECT_EQ(503 , message.GetExtension(unittest::repeated_uint32_extension_lite , 1));
- EXPECT_EQ(504 , message.GetExtension(unittest::repeated_uint64_extension_lite , 1));
- EXPECT_EQ(505 , message.GetExtension(unittest::repeated_sint32_extension_lite , 1));
- EXPECT_EQ(506 , message.GetExtension(unittest::repeated_sint64_extension_lite , 1));
- EXPECT_EQ(507 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1));
- EXPECT_EQ(508 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1));
- EXPECT_EQ(509 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
- EXPECT_EQ(510 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
- EXPECT_EQ(511 , message.GetExtension(unittest::repeated_float_extension_lite , 1));
- EXPECT_EQ(512 , message.GetExtension(unittest::repeated_double_extension_lite , 1));
- EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite , 1));
- EXPECT_EQ("515", message.GetExtension(unittest::repeated_string_extension_lite , 1));
- EXPECT_EQ("516", message.GetExtension(unittest::repeated_bytes_extension_lite , 1));
+ EXPECT_EQ(501,
+ message.GetExtension(unittest::repeated_int32_extension_lite, 1));
+ EXPECT_EQ(502,
+ message.GetExtension(unittest::repeated_int64_extension_lite, 1));
+ EXPECT_EQ(503,
+ message.GetExtension(unittest::repeated_uint32_extension_lite, 1));
+ EXPECT_EQ(504,
+ message.GetExtension(unittest::repeated_uint64_extension_lite, 1));
+ EXPECT_EQ(505,
+ message.GetExtension(unittest::repeated_sint32_extension_lite, 1));
+ EXPECT_EQ(506,
+ message.GetExtension(unittest::repeated_sint64_extension_lite, 1));
+ EXPECT_EQ(507,
+ message.GetExtension(unittest::repeated_fixed32_extension_lite, 1));
+ EXPECT_EQ(508,
+ message.GetExtension(unittest::repeated_fixed64_extension_lite, 1));
+ EXPECT_EQ(
+ 509, message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
+ EXPECT_EQ(
+ 510, message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
+ EXPECT_EQ(511,
+ message.GetExtension(unittest::repeated_float_extension_lite, 1));
+ EXPECT_EQ(512,
+ message.GetExtension(unittest::repeated_double_extension_lite, 1));
+ EXPECT_EQ(true,
+ message.GetExtension(unittest::repeated_bool_extension_lite, 1));
+ EXPECT_EQ("515",
+ message.GetExtension(unittest::repeated_string_extension_lite, 1));
+ EXPECT_EQ("516",
+ message.GetExtension(unittest::repeated_bytes_extension_lite, 1));
- EXPECT_EQ(517, message.GetExtension(unittest::repeatedgroup_extension_lite , 1).a());
- EXPECT_EQ(518, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb());
- EXPECT_EQ(519, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c());
- EXPECT_EQ(520, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d());
- EXPECT_EQ(527, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 1).bb());
+ EXPECT_EQ(
+ 517, message.GetExtension(unittest::repeatedgroup_extension_lite, 1).a());
+ EXPECT_EQ(
+ 518,
+ message.GetExtension(unittest::repeated_nested_message_extension_lite, 1)
+ .bb());
+ EXPECT_EQ(
+ 519,
+ message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1)
+ .c());
+ EXPECT_EQ(
+ 520,
+ message.GetExtension(unittest::repeated_import_message_extension_lite, 1)
+ .d());
+ EXPECT_EQ(
+ 527,
+ message.GetExtension(unittest::repeated_lazy_message_extension_lite, 1)
+ .bb());
- EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1));
- EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
- EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1));
+ EXPECT_EQ(
+ unittest::TestAllTypesLite::FOO,
+ message.GetExtension(unittest::repeated_nested_enum_extension_lite, 1));
+ EXPECT_EQ(
+ unittest::FOREIGN_LITE_FOO,
+ message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
+ EXPECT_EQ(
+ unittest_import::IMPORT_LITE_FOO,
+ message.GetExtension(unittest::repeated_import_enum_extension_lite, 1));
}
@@ -1402,55 +1736,57 @@
void TestUtilLite::SetPackedExtensions(
unittest::TestPackedExtensionsLite* message) {
- message->AddExtension(unittest::packed_int32_extension_lite , 601);
- message->AddExtension(unittest::packed_int64_extension_lite , 602);
- message->AddExtension(unittest::packed_uint32_extension_lite , 603);
- message->AddExtension(unittest::packed_uint64_extension_lite , 604);
- message->AddExtension(unittest::packed_sint32_extension_lite , 605);
- message->AddExtension(unittest::packed_sint64_extension_lite , 606);
- message->AddExtension(unittest::packed_fixed32_extension_lite , 607);
- message->AddExtension(unittest::packed_fixed64_extension_lite , 608);
+ message->AddExtension(unittest::packed_int32_extension_lite, 601);
+ message->AddExtension(unittest::packed_int64_extension_lite, 602);
+ message->AddExtension(unittest::packed_uint32_extension_lite, 603);
+ message->AddExtension(unittest::packed_uint64_extension_lite, 604);
+ message->AddExtension(unittest::packed_sint32_extension_lite, 605);
+ message->AddExtension(unittest::packed_sint64_extension_lite, 606);
+ message->AddExtension(unittest::packed_fixed32_extension_lite, 607);
+ message->AddExtension(unittest::packed_fixed64_extension_lite, 608);
message->AddExtension(unittest::packed_sfixed32_extension_lite, 609);
message->AddExtension(unittest::packed_sfixed64_extension_lite, 610);
- message->AddExtension(unittest::packed_float_extension_lite , 611);
- message->AddExtension(unittest::packed_double_extension_lite , 612);
- message->AddExtension(unittest::packed_bool_extension_lite , true);
- message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAR);
+ message->AddExtension(unittest::packed_float_extension_lite, 611);
+ message->AddExtension(unittest::packed_double_extension_lite, 612);
+ message->AddExtension(unittest::packed_bool_extension_lite, true);
+ message->AddExtension(unittest::packed_enum_extension_lite,
+ unittest::FOREIGN_LITE_BAR);
// add a second one of each field
- message->AddExtension(unittest::packed_int32_extension_lite , 701);
- message->AddExtension(unittest::packed_int64_extension_lite , 702);
- message->AddExtension(unittest::packed_uint32_extension_lite , 703);
- message->AddExtension(unittest::packed_uint64_extension_lite , 704);
- message->AddExtension(unittest::packed_sint32_extension_lite , 705);
- message->AddExtension(unittest::packed_sint64_extension_lite , 706);
- message->AddExtension(unittest::packed_fixed32_extension_lite , 707);
- message->AddExtension(unittest::packed_fixed64_extension_lite , 708);
+ message->AddExtension(unittest::packed_int32_extension_lite, 701);
+ message->AddExtension(unittest::packed_int64_extension_lite, 702);
+ message->AddExtension(unittest::packed_uint32_extension_lite, 703);
+ message->AddExtension(unittest::packed_uint64_extension_lite, 704);
+ message->AddExtension(unittest::packed_sint32_extension_lite, 705);
+ message->AddExtension(unittest::packed_sint64_extension_lite, 706);
+ message->AddExtension(unittest::packed_fixed32_extension_lite, 707);
+ message->AddExtension(unittest::packed_fixed64_extension_lite, 708);
message->AddExtension(unittest::packed_sfixed32_extension_lite, 709);
message->AddExtension(unittest::packed_sfixed64_extension_lite, 710);
- message->AddExtension(unittest::packed_float_extension_lite , 711);
- message->AddExtension(unittest::packed_double_extension_lite , 712);
- message->AddExtension(unittest::packed_bool_extension_lite , false);
- message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAZ);
+ message->AddExtension(unittest::packed_float_extension_lite, 711);
+ message->AddExtension(unittest::packed_double_extension_lite, 712);
+ message->AddExtension(unittest::packed_bool_extension_lite, false);
+ message->AddExtension(unittest::packed_enum_extension_lite,
+ unittest::FOREIGN_LITE_BAZ);
}
// -------------------------------------------------------------------
void TestUtilLite::ModifyPackedExtensions(
unittest::TestPackedExtensionsLite* message) {
- message->SetExtension(unittest::packed_int32_extension_lite , 1, 801);
- message->SetExtension(unittest::packed_int64_extension_lite , 1, 802);
- message->SetExtension(unittest::packed_uint32_extension_lite , 1, 803);
- message->SetExtension(unittest::packed_uint64_extension_lite , 1, 804);
- message->SetExtension(unittest::packed_sint32_extension_lite , 1, 805);
- message->SetExtension(unittest::packed_sint64_extension_lite , 1, 806);
- message->SetExtension(unittest::packed_fixed32_extension_lite , 1, 807);
- message->SetExtension(unittest::packed_fixed64_extension_lite , 1, 808);
+ message->SetExtension(unittest::packed_int32_extension_lite, 1, 801);
+ message->SetExtension(unittest::packed_int64_extension_lite, 1, 802);
+ message->SetExtension(unittest::packed_uint32_extension_lite, 1, 803);
+ message->SetExtension(unittest::packed_uint64_extension_lite, 1, 804);
+ message->SetExtension(unittest::packed_sint32_extension_lite, 1, 805);
+ message->SetExtension(unittest::packed_sint64_extension_lite, 1, 806);
+ message->SetExtension(unittest::packed_fixed32_extension_lite, 1, 807);
+ message->SetExtension(unittest::packed_fixed64_extension_lite, 1, 808);
message->SetExtension(unittest::packed_sfixed32_extension_lite, 1, 809);
message->SetExtension(unittest::packed_sfixed64_extension_lite, 1, 810);
- message->SetExtension(unittest::packed_float_extension_lite , 1, 811);
- message->SetExtension(unittest::packed_double_extension_lite , 1, 812);
- message->SetExtension(unittest::packed_bool_extension_lite , 1, true);
- message->SetExtension(unittest::packed_enum_extension_lite , 1,
+ message->SetExtension(unittest::packed_float_extension_lite, 1, 811);
+ message->SetExtension(unittest::packed_double_extension_lite, 1, 812);
+ message->SetExtension(unittest::packed_bool_extension_lite, 1, true);
+ message->SetExtension(unittest::packed_enum_extension_lite, 1,
unittest::FOREIGN_LITE_FOO);
}
@@ -1458,49 +1794,75 @@
void TestUtilLite::ExpectPackedExtensionsSet(
const unittest::TestPackedExtensionsLite& message) {
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite));
ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite ));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite));
- EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension_lite , 0));
- EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension_lite , 0));
- EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension_lite , 0));
- EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension_lite , 0));
- EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension_lite , 0));
- EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension_lite , 0));
- EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension_lite , 0));
- EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension_lite , 0));
- EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
- EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
- EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension_lite , 0));
- EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension_lite , 0));
- EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite , 0));
+ EXPECT_EQ(601,
+ message.GetExtension(unittest::packed_int32_extension_lite, 0));
+ EXPECT_EQ(602,
+ message.GetExtension(unittest::packed_int64_extension_lite, 0));
+ EXPECT_EQ(603,
+ message.GetExtension(unittest::packed_uint32_extension_lite, 0));
+ EXPECT_EQ(604,
+ message.GetExtension(unittest::packed_uint64_extension_lite, 0));
+ EXPECT_EQ(605,
+ message.GetExtension(unittest::packed_sint32_extension_lite, 0));
+ EXPECT_EQ(606,
+ message.GetExtension(unittest::packed_sint64_extension_lite, 0));
+ EXPECT_EQ(607,
+ message.GetExtension(unittest::packed_fixed32_extension_lite, 0));
+ EXPECT_EQ(608,
+ message.GetExtension(unittest::packed_fixed64_extension_lite, 0));
+ EXPECT_EQ(609,
+ message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
+ EXPECT_EQ(610,
+ message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
+ EXPECT_EQ(611,
+ message.GetExtension(unittest::packed_float_extension_lite, 0));
+ EXPECT_EQ(612,
+ message.GetExtension(unittest::packed_double_extension_lite, 0));
+ EXPECT_EQ(true,
+ message.GetExtension(unittest::packed_bool_extension_lite, 0));
EXPECT_EQ(unittest::FOREIGN_LITE_BAR,
message.GetExtension(unittest::packed_enum_extension_lite, 0));
- EXPECT_EQ(701 , message.GetExtension(unittest::packed_int32_extension_lite , 1));
- EXPECT_EQ(702 , message.GetExtension(unittest::packed_int64_extension_lite , 1));
- EXPECT_EQ(703 , message.GetExtension(unittest::packed_uint32_extension_lite , 1));
- EXPECT_EQ(704 , message.GetExtension(unittest::packed_uint64_extension_lite , 1));
- EXPECT_EQ(705 , message.GetExtension(unittest::packed_sint32_extension_lite , 1));
- EXPECT_EQ(706 , message.GetExtension(unittest::packed_sint64_extension_lite , 1));
- EXPECT_EQ(707 , message.GetExtension(unittest::packed_fixed32_extension_lite , 1));
- EXPECT_EQ(708 , message.GetExtension(unittest::packed_fixed64_extension_lite , 1));
- EXPECT_EQ(709 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
- EXPECT_EQ(710 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
- EXPECT_EQ(711 , message.GetExtension(unittest::packed_float_extension_lite , 1));
- EXPECT_EQ(712 , message.GetExtension(unittest::packed_double_extension_lite , 1));
- EXPECT_EQ(false, message.GetExtension(unittest::packed_bool_extension_lite , 1));
+ EXPECT_EQ(701,
+ message.GetExtension(unittest::packed_int32_extension_lite, 1));
+ EXPECT_EQ(702,
+ message.GetExtension(unittest::packed_int64_extension_lite, 1));
+ EXPECT_EQ(703,
+ message.GetExtension(unittest::packed_uint32_extension_lite, 1));
+ EXPECT_EQ(704,
+ message.GetExtension(unittest::packed_uint64_extension_lite, 1));
+ EXPECT_EQ(705,
+ message.GetExtension(unittest::packed_sint32_extension_lite, 1));
+ EXPECT_EQ(706,
+ message.GetExtension(unittest::packed_sint64_extension_lite, 1));
+ EXPECT_EQ(707,
+ message.GetExtension(unittest::packed_fixed32_extension_lite, 1));
+ EXPECT_EQ(708,
+ message.GetExtension(unittest::packed_fixed64_extension_lite, 1));
+ EXPECT_EQ(709,
+ message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
+ EXPECT_EQ(710,
+ message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
+ EXPECT_EQ(711,
+ message.GetExtension(unittest::packed_float_extension_lite, 1));
+ EXPECT_EQ(712,
+ message.GetExtension(unittest::packed_double_extension_lite, 1));
+ EXPECT_EQ(false,
+ message.GetExtension(unittest::packed_bool_extension_lite, 1));
EXPECT_EQ(unittest::FOREIGN_LITE_BAZ,
message.GetExtension(unittest::packed_enum_extension_lite, 1));
}
@@ -1509,70 +1871,96 @@
void TestUtilLite::ExpectPackedExtensionsClear(
const unittest::TestPackedExtensionsLite& message) {
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int32_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int64_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint32_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint64_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint32_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint64_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int32_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int64_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint32_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint64_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint32_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint64_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed32_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed64_extension_lite));
EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_float_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_double_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_bool_extension_lite ));
- EXPECT_EQ(0, message.ExtensionSize(unittest::packed_enum_extension_lite ));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_float_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_double_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_bool_extension_lite));
+ EXPECT_EQ(0, message.ExtensionSize(unittest::packed_enum_extension_lite));
}
// -------------------------------------------------------------------
void TestUtilLite::ExpectPackedExtensionsModified(
const unittest::TestPackedExtensionsLite& message) {
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite));
ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite ));
- ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite ));
- EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension_lite , 0));
- EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension_lite , 0));
- EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension_lite , 0));
- EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension_lite , 0));
- EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension_lite , 0));
- EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension_lite , 0));
- EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension_lite , 0));
- EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension_lite , 0));
- EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
- EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
- EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension_lite , 0));
- EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension_lite , 0));
- EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite , 0));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite));
+ ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite));
+ EXPECT_EQ(601,
+ message.GetExtension(unittest::packed_int32_extension_lite, 0));
+ EXPECT_EQ(602,
+ message.GetExtension(unittest::packed_int64_extension_lite, 0));
+ EXPECT_EQ(603,
+ message.GetExtension(unittest::packed_uint32_extension_lite, 0));
+ EXPECT_EQ(604,
+ message.GetExtension(unittest::packed_uint64_extension_lite, 0));
+ EXPECT_EQ(605,
+ message.GetExtension(unittest::packed_sint32_extension_lite, 0));
+ EXPECT_EQ(606,
+ message.GetExtension(unittest::packed_sint64_extension_lite, 0));
+ EXPECT_EQ(607,
+ message.GetExtension(unittest::packed_fixed32_extension_lite, 0));
+ EXPECT_EQ(608,
+ message.GetExtension(unittest::packed_fixed64_extension_lite, 0));
+ EXPECT_EQ(609,
+ message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
+ EXPECT_EQ(610,
+ message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
+ EXPECT_EQ(611,
+ message.GetExtension(unittest::packed_float_extension_lite, 0));
+ EXPECT_EQ(612,
+ message.GetExtension(unittest::packed_double_extension_lite, 0));
+ EXPECT_EQ(true,
+ message.GetExtension(unittest::packed_bool_extension_lite, 0));
EXPECT_EQ(unittest::FOREIGN_LITE_BAR,
message.GetExtension(unittest::packed_enum_extension_lite, 0));
// Actually verify the second (modified) elements now.
- EXPECT_EQ(801 , message.GetExtension(unittest::packed_int32_extension_lite , 1));
- EXPECT_EQ(802 , message.GetExtension(unittest::packed_int64_extension_lite , 1));
- EXPECT_EQ(803 , message.GetExtension(unittest::packed_uint32_extension_lite , 1));
- EXPECT_EQ(804 , message.GetExtension(unittest::packed_uint64_extension_lite , 1));
- EXPECT_EQ(805 , message.GetExtension(unittest::packed_sint32_extension_lite , 1));
- EXPECT_EQ(806 , message.GetExtension(unittest::packed_sint64_extension_lite , 1));
- EXPECT_EQ(807 , message.GetExtension(unittest::packed_fixed32_extension_lite , 1));
- EXPECT_EQ(808 , message.GetExtension(unittest::packed_fixed64_extension_lite , 1));
- EXPECT_EQ(809 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
- EXPECT_EQ(810 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
- EXPECT_EQ(811 , message.GetExtension(unittest::packed_float_extension_lite , 1));
- EXPECT_EQ(812 , message.GetExtension(unittest::packed_double_extension_lite , 1));
- EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite , 1));
+ EXPECT_EQ(801,
+ message.GetExtension(unittest::packed_int32_extension_lite, 1));
+ EXPECT_EQ(802,
+ message.GetExtension(unittest::packed_int64_extension_lite, 1));
+ EXPECT_EQ(803,
+ message.GetExtension(unittest::packed_uint32_extension_lite, 1));
+ EXPECT_EQ(804,
+ message.GetExtension(unittest::packed_uint64_extension_lite, 1));
+ EXPECT_EQ(805,
+ message.GetExtension(unittest::packed_sint32_extension_lite, 1));
+ EXPECT_EQ(806,
+ message.GetExtension(unittest::packed_sint64_extension_lite, 1));
+ EXPECT_EQ(807,
+ message.GetExtension(unittest::packed_fixed32_extension_lite, 1));
+ EXPECT_EQ(808,
+ message.GetExtension(unittest::packed_fixed64_extension_lite, 1));
+ EXPECT_EQ(809,
+ message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
+ EXPECT_EQ(810,
+ message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
+ EXPECT_EQ(811,
+ message.GetExtension(unittest::packed_float_extension_lite, 1));
+ EXPECT_EQ(812,
+ message.GetExtension(unittest::packed_double_extension_lite, 1));
+ EXPECT_EQ(true,
+ message.GetExtension(unittest::packed_bool_extension_lite, 1));
EXPECT_EQ(unittest::FOREIGN_LITE_FOO,
message.GetExtension(unittest::packed_enum_extension_lite, 1));
}
diff --git a/src/google/protobuf/testing/file.cc b/src/google/protobuf/testing/file.cc
index 06cc981..7d3708e 100644
--- a/src/google/protobuf/testing/file.cc
+++ b/src/google/protobuf/testing/file.cc
@@ -45,7 +45,7 @@
#endif
#include <errno.h>
-#include <google/protobuf/stubs/io_win32.h>
+#include <google/protobuf/io/io_win32.h>
#include <google/protobuf/stubs/logging.h>
namespace google {
@@ -59,11 +59,11 @@
#endif
#ifdef _WIN32
-using google::protobuf::internal::win32::access;
-using google::protobuf::internal::win32::chdir;
-using google::protobuf::internal::win32::fopen;
-using google::protobuf::internal::win32::mkdir;
-using google::protobuf::internal::win32::stat;
+using google::protobuf::io::win32::access;
+using google::protobuf::io::win32::chdir;
+using google::protobuf::io::win32::fopen;
+using google::protobuf::io::win32::mkdir;
+using google::protobuf::io::win32::stat;
#endif
bool File::Exists(const string& name) {
diff --git a/src/google/protobuf/testing/googletest.cc b/src/google/protobuf/testing/googletest.cc
index 5c89c0f..aca089c 100644
--- a/src/google/protobuf/testing/googletest.cc
+++ b/src/google/protobuf/testing/googletest.cc
@@ -33,7 +33,7 @@
#include <google/protobuf/testing/googletest.h>
#include <google/protobuf/testing/file.h>
-#include <google/protobuf/stubs/io_win32.h>
+#include <google/protobuf/io/io_win32.h>
#include <google/protobuf/stubs/strutil.h>
#include <sys/stat.h>
#include <sys/types.h>
@@ -55,11 +55,11 @@
#ifdef _WIN32
// DO NOT include <io.h>, instead create functions in io_win32.{h,cc} and import
// them like we do below.
-using google::protobuf::internal::win32::close;
-using google::protobuf::internal::win32::dup2;
-using google::protobuf::internal::win32::dup;
-using google::protobuf::internal::win32::mkdir;
-using google::protobuf::internal::win32::open;
+using google::protobuf::io::win32::close;
+using google::protobuf::io::win32::dup2;
+using google::protobuf::io::win32::dup;
+using google::protobuf::io::win32::mkdir;
+using google::protobuf::io::win32::open;
#endif
#ifndef O_BINARY
diff --git a/src/google/protobuf/text_format.h b/src/google/protobuf/text_format.h
index 4c7c33b..f999f47 100644
--- a/src/google/protobuf/text_format.h
+++ b/src/google/protobuf/text_format.h
@@ -552,6 +552,13 @@
// a warning message will be generated.
void AllowUnknownExtension(bool allow) { allow_unknown_extension_ = allow; }
+ // When an unknown field is met, parsing will fail if this option is set
+ // to false(the default). If true, unknown fields will be ignored and
+ // a warning message will be generated.
+ // Please aware that set this option true may hide some errors (e.g.
+ // spelling error on field name). Avoid to use this option if possible.
+ void AllowUnknownField(bool allow) { allow_unknown_field_ = allow; }
+
void AllowFieldNumber(bool allow) { allow_field_number_ = allow; }
diff --git a/src/google/protobuf/text_format_unittest.cc b/src/google/protobuf/text_format_unittest.cc
index 0bed993..7faf5c0 100644
--- a/src/google/protobuf/text_format_unittest.cc
+++ b/src/google/protobuf/text_format_unittest.cc
@@ -48,9 +48,9 @@
#include <google/protobuf/test_util.h>
#include <google/protobuf/test_util2.h>
#include <google/protobuf/unittest.pb.h>
-#include <google/protobuf/unittest_proto3.pb.h>
#include <google/protobuf/unittest_mset.pb.h>
#include <google/protobuf/unittest_mset_wire_format.pb.h>
+#include <google/protobuf/unittest_proto3.pb.h>
#include <google/protobuf/io/tokenizer.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/stubs/strutil.h>
@@ -142,10 +142,11 @@
proto_.mutable_optional_nested_message()->set_bb(2);
proto_.mutable_optional_foreign_message();
- EXPECT_EQ("optional_int32: 1 optional_string: \"hello\" "
- "optional_nested_message { bb: 2 } "
- "optional_foreign_message { }",
- proto_.ShortDebugString());
+ EXPECT_EQ(
+ "optional_int32: 1 optional_string: \"hello\" "
+ "optional_nested_message { bb: 2 } "
+ "optional_foreign_message { }",
+ proto_.ShortDebugString());
}
TEST_F(TextFormatTest, ShortPrimitiveRepeateds) {
@@ -164,41 +165,44 @@
std::string text;
EXPECT_TRUE(printer.PrintToString(proto_, &text));
- EXPECT_EQ("optional_int32: 123\n"
- "repeated_int32: [456, 789]\n"
- "repeated_string: \"foo\"\n"
- "repeated_string: \"bar\"\n"
- "repeated_nested_message {\n bb: 2\n}\n"
- "repeated_nested_message {\n bb: 3\n}\n"
- "repeated_nested_enum: [FOO, BAR]\n",
- text);
+ EXPECT_EQ(
+ "optional_int32: 123\n"
+ "repeated_int32: [456, 789]\n"
+ "repeated_string: \"foo\"\n"
+ "repeated_string: \"bar\"\n"
+ "repeated_nested_message {\n bb: 2\n}\n"
+ "repeated_nested_message {\n bb: 3\n}\n"
+ "repeated_nested_enum: [FOO, BAR]\n",
+ text);
// Verify that any existing data in the string is cleared when PrintToString()
// is called.
text = "just some data here...\n\nblah blah";
EXPECT_TRUE(printer.PrintToString(proto_, &text));
- EXPECT_EQ("optional_int32: 123\n"
- "repeated_int32: [456, 789]\n"
- "repeated_string: \"foo\"\n"
- "repeated_string: \"bar\"\n"
- "repeated_nested_message {\n bb: 2\n}\n"
- "repeated_nested_message {\n bb: 3\n}\n"
- "repeated_nested_enum: [FOO, BAR]\n",
- text);
+ EXPECT_EQ(
+ "optional_int32: 123\n"
+ "repeated_int32: [456, 789]\n"
+ "repeated_string: \"foo\"\n"
+ "repeated_string: \"bar\"\n"
+ "repeated_nested_message {\n bb: 2\n}\n"
+ "repeated_nested_message {\n bb: 3\n}\n"
+ "repeated_nested_enum: [FOO, BAR]\n",
+ text);
// Try in single-line mode.
printer.SetSingleLineMode(true);
EXPECT_TRUE(printer.PrintToString(proto_, &text));
- EXPECT_EQ("optional_int32: 123 "
- "repeated_int32: [456, 789] "
- "repeated_string: \"foo\" "
- "repeated_string: \"bar\" "
- "repeated_nested_message { bb: 2 } "
- "repeated_nested_message { bb: 3 } "
- "repeated_nested_enum: [FOO, BAR] ",
- text);
+ EXPECT_EQ(
+ "optional_int32: 123 "
+ "repeated_int32: [456, 789] "
+ "repeated_string: \"foo\" "
+ "repeated_string: \"bar\" "
+ "repeated_nested_message { bb: 2 } "
+ "repeated_nested_message { bb: 3 } "
+ "repeated_nested_enum: [FOO, BAR] ",
+ text);
}
@@ -272,17 +276,17 @@
unknown_fields->AddVarint(8, 3);
EXPECT_EQ(
- "5: 1\n"
- "5: 0x00000002\n"
- "5: 0x0000000000000003\n"
- "5: \"4\"\n"
- "5 {\n"
- " 10: 5\n"
- "}\n"
- "8: 1\n"
- "8: 2\n"
- "8: 3\n",
- message.DebugString());
+ "5: 1\n"
+ "5: 0x00000002\n"
+ "5: 0x0000000000000003\n"
+ "5: \"4\"\n"
+ "5 {\n"
+ " 10: 5\n"
+ "}\n"
+ "8: 1\n"
+ "8: 2\n"
+ "8: 3\n",
+ message.DebugString());
}
TEST_F(TextFormatTest, PrintUnknownFieldsHidden) {
@@ -345,13 +349,13 @@
EXPECT_TRUE(unknown_fields.ParseFromString(data));
EXPECT_TRUE(TextFormat::PrintUnknownFieldsToString(unknown_fields, &text));
EXPECT_EQ(
- "44: \"abc\"\n"
- "44: \"def\"\n"
- "44: \"\"\n"
- "48 {\n"
- " 1: 123\n"
- "}\n",
- text);
+ "44: \"abc\"\n"
+ "44: \"def\"\n"
+ "44: \"\"\n"
+ "48 {\n"
+ " 1: 123\n"
+ "}\n",
+ text);
}
TEST_F(TextFormatTest, PrintMessageWithIndent) {
@@ -368,12 +372,12 @@
printer.SetInitialIndentLevel(1);
EXPECT_TRUE(printer.PrintToString(message, &text));
EXPECT_EQ(
- " repeated_string: \"abc\"\n"
- " repeated_string: \"def\"\n"
- " repeated_nested_message {\n"
- " bb: 123\n"
- " }\n",
- text);
+ " repeated_string: \"abc\"\n"
+ " repeated_string: \"def\"\n"
+ " repeated_nested_message {\n"
+ " bb: 123\n"
+ " }\n",
+ text);
}
TEST_F(TextFormatTest, PrintMessageSingleLine) {
@@ -391,9 +395,9 @@
printer.SetSingleLineMode(true);
EXPECT_TRUE(printer.PrintToString(message, &text));
EXPECT_EQ(
- " repeated_string: \"abc\" repeated_string: \"def\" "
- "repeated_nested_message { bb: 123 } ",
- text);
+ " repeated_string: \"abc\" repeated_string: \"def\" "
+ "repeated_nested_message { bb: 123 } ",
+ text);
}
TEST_F(TextFormatTest, PrintBufferTooSmall) {
@@ -778,8 +782,7 @@
std::string parse_string =
"optional_string: " + kEscapeTestStringEscaped + "\n";
- io::ArrayInputStream input_stream(parse_string.data(),
- parse_string.size());
+ io::ArrayInputStream input_stream(parse_string.data(), parse_string.size());
TextFormat::Parse(&input_stream, &proto_);
// Compare.
@@ -790,19 +793,18 @@
// Create a parse string with multiple parts on one line.
std::string parse_string = "optional_string: \"foo\" \"bar\"\n";
- io::ArrayInputStream input_stream1(parse_string.data(),
- parse_string.size());
+ io::ArrayInputStream input_stream1(parse_string.data(), parse_string.size());
TextFormat::Parse(&input_stream1, &proto_);
// Compare.
EXPECT_EQ("foobar", proto_.optional_string());
// Create a parse string with multiple parts on separate lines.
- parse_string = "optional_string: \"foo\"\n"
- "\"bar\"\n";
+ parse_string =
+ "optional_string: \"foo\"\n"
+ "\"bar\"\n";
- io::ArrayInputStream input_stream2(parse_string.data(),
- parse_string.size());
+ io::ArrayInputStream input_stream2(parse_string.data(), parse_string.size());
TextFormat::Parse(&input_stream2, &proto_);
// Compare.
@@ -816,8 +818,7 @@
// Have it parse a float with the 'f' suffix.
std::string parse_string = "optional_float: 1.0f\n";
- io::ArrayInputStream input_stream(parse_string.data(),
- parse_string.size());
+ io::ArrayInputStream input_stream(parse_string.data(), parse_string.size());
TextFormat::Parse(&input_stream, &proto_);
@@ -954,8 +955,7 @@
"optional_int32: 1 # a comment\n"
"optional_int64: 2 # another comment";
- io::ArrayInputStream input_stream(parse_string.data(),
- parse_string.size());
+ io::ArrayInputStream input_stream(parse_string.data(), parse_string.size());
TextFormat::Parse(&input_stream, &proto_);
@@ -970,8 +970,7 @@
std::string parse_string = "optional_nested_message: { bb: 1}\n";
- io::ArrayInputStream input_stream(parse_string.data(),
- parse_string.size());
+ io::ArrayInputStream input_stream(parse_string.data(), parse_string.size());
TextFormat::Parse(&input_stream, &proto_);
@@ -1018,16 +1017,17 @@
// have this problem, so we switched to that instead.
EXPECT_EQ(
- "repeated_int64: -9223372036854775808\n"
- "repeated_uint64: 18446744073709551615\n"
- "repeated_double: 123.456\n"
- "repeated_double: 1.23e+21\n"
- "repeated_double: 1.23e-18\n"
- "repeated_double: inf\n"
- "repeated_double: -inf\n"
- "repeated_double: nan\n"
- "repeated_string: \"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\'\\\"\"\n",
- RemoveRedundantZeros(message.DebugString()));
+ "repeated_int64: -9223372036854775808\n"
+ "repeated_uint64: 18446744073709551615\n"
+ "repeated_double: 123.456\n"
+ "repeated_double: 1.23e+21\n"
+ "repeated_double: 1.23e-18\n"
+ "repeated_double: inf\n"
+ "repeated_double: -inf\n"
+ "repeated_double: nan\n"
+ "repeated_string: "
+ "\"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\'\\\"\"\n",
+ RemoveRedundantZeros(message.DebugString()));
}
TEST_F(TextFormatTest, PrintFloatPrecision) {
@@ -1074,49 +1074,48 @@
message.add_repeated_double(1.23456789876543e100);
EXPECT_EQ(
- "repeated_float: 1\n"
- "repeated_float: 1.2\n"
- "repeated_float: 1.23\n"
- "repeated_float: 1.234\n"
- "repeated_float: 1.2345\n"
- "repeated_float: 1.23456\n"
- "repeated_float: 1.2e+10\n"
- "repeated_float: 1.23e+10\n"
- "repeated_float: 1.234e+10\n"
- "repeated_float: 1.2345e+10\n"
- "repeated_float: 1.23456e+10\n"
- "repeated_double: 1.2\n"
- "repeated_double: 1.23\n"
- "repeated_double: 1.234\n"
- "repeated_double: 1.2345\n"
- "repeated_double: 1.23456\n"
- "repeated_double: 1.234567\n"
- "repeated_double: 1.2345678\n"
- "repeated_double: 1.23456789\n"
- "repeated_double: 1.234567898\n"
- "repeated_double: 1.2345678987\n"
- "repeated_double: 1.23456789876\n"
- "repeated_double: 1.234567898765\n"
- "repeated_double: 1.2345678987654\n"
- "repeated_double: 1.23456789876543\n"
- "repeated_double: 1.2e+100\n"
- "repeated_double: 1.23e+100\n"
- "repeated_double: 1.234e+100\n"
- "repeated_double: 1.2345e+100\n"
- "repeated_double: 1.23456e+100\n"
- "repeated_double: 1.234567e+100\n"
- "repeated_double: 1.2345678e+100\n"
- "repeated_double: 1.23456789e+100\n"
- "repeated_double: 1.234567898e+100\n"
- "repeated_double: 1.2345678987e+100\n"
- "repeated_double: 1.23456789876e+100\n"
- "repeated_double: 1.234567898765e+100\n"
- "repeated_double: 1.2345678987654e+100\n"
- "repeated_double: 1.23456789876543e+100\n",
- RemoveRedundantZeros(message.DebugString()));
+ "repeated_float: 1\n"
+ "repeated_float: 1.2\n"
+ "repeated_float: 1.23\n"
+ "repeated_float: 1.234\n"
+ "repeated_float: 1.2345\n"
+ "repeated_float: 1.23456\n"
+ "repeated_float: 1.2e+10\n"
+ "repeated_float: 1.23e+10\n"
+ "repeated_float: 1.234e+10\n"
+ "repeated_float: 1.2345e+10\n"
+ "repeated_float: 1.23456e+10\n"
+ "repeated_double: 1.2\n"
+ "repeated_double: 1.23\n"
+ "repeated_double: 1.234\n"
+ "repeated_double: 1.2345\n"
+ "repeated_double: 1.23456\n"
+ "repeated_double: 1.234567\n"
+ "repeated_double: 1.2345678\n"
+ "repeated_double: 1.23456789\n"
+ "repeated_double: 1.234567898\n"
+ "repeated_double: 1.2345678987\n"
+ "repeated_double: 1.23456789876\n"
+ "repeated_double: 1.234567898765\n"
+ "repeated_double: 1.2345678987654\n"
+ "repeated_double: 1.23456789876543\n"
+ "repeated_double: 1.2e+100\n"
+ "repeated_double: 1.23e+100\n"
+ "repeated_double: 1.234e+100\n"
+ "repeated_double: 1.2345e+100\n"
+ "repeated_double: 1.23456e+100\n"
+ "repeated_double: 1.234567e+100\n"
+ "repeated_double: 1.2345678e+100\n"
+ "repeated_double: 1.23456789e+100\n"
+ "repeated_double: 1.234567898e+100\n"
+ "repeated_double: 1.2345678987e+100\n"
+ "repeated_double: 1.23456789876e+100\n"
+ "repeated_double: 1.234567898765e+100\n"
+ "repeated_double: 1.2345678987654e+100\n"
+ "repeated_double: 1.23456789876543e+100\n",
+ RemoveRedundantZeros(message.DebugString()));
}
-
TEST_F(TextFormatTest, AllowPartial) {
unittest::TestRequired message;
TextFormat::Parser parser;
@@ -1130,29 +1129,29 @@
TEST_F(TextFormatTest, ParseExotic) {
unittest::TestAllTypes message;
ASSERT_TRUE(TextFormat::ParseFromString(
- "repeated_int32: -1\n"
- "repeated_int32: -2147483648\n"
- "repeated_int64: -1\n"
- "repeated_int64: -9223372036854775808\n"
- "repeated_uint32: 4294967295\n"
- "repeated_uint32: 2147483648\n"
- "repeated_uint64: 18446744073709551615\n"
- "repeated_uint64: 9223372036854775808\n"
- "repeated_double: 123.0\n"
- "repeated_double: 123.5\n"
- "repeated_double: 0.125\n"
- "repeated_double: 1.23E17\n"
- "repeated_double: 1.235E+22\n"
- "repeated_double: 1.235e-18\n"
- "repeated_double: 123.456789\n"
- "repeated_double: inf\n"
- "repeated_double: Infinity\n"
- "repeated_double: -inf\n"
- "repeated_double: -Infinity\n"
- "repeated_double: nan\n"
- "repeated_double: NaN\n"
- "repeated_string: \"\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"\"\n",
- &message));
+ "repeated_int32: -1\n"
+ "repeated_int32: -2147483648\n"
+ "repeated_int64: -1\n"
+ "repeated_int64: -9223372036854775808\n"
+ "repeated_uint32: 4294967295\n"
+ "repeated_uint32: 2147483648\n"
+ "repeated_uint64: 18446744073709551615\n"
+ "repeated_uint64: 9223372036854775808\n"
+ "repeated_double: 123.0\n"
+ "repeated_double: 123.5\n"
+ "repeated_double: 0.125\n"
+ "repeated_double: 1.23E17\n"
+ "repeated_double: 1.235E+22\n"
+ "repeated_double: 1.235e-18\n"
+ "repeated_double: 123.456789\n"
+ "repeated_double: inf\n"
+ "repeated_double: Infinity\n"
+ "repeated_double: -inf\n"
+ "repeated_double: -Infinity\n"
+ "repeated_double: nan\n"
+ "repeated_double: NaN\n"
+ "repeated_string: \"\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"\"\n",
+ &message));
ASSERT_EQ(2, message.repeated_int32_size());
EXPECT_EQ(-1, message.repeated_int32(0));
@@ -1184,12 +1183,12 @@
message.repeated_uint64(1));
ASSERT_EQ(13, message.repeated_double_size());
- EXPECT_EQ(123.0 , message.repeated_double(0));
- EXPECT_EQ(123.5 , message.repeated_double(1));
- EXPECT_EQ(0.125 , message.repeated_double(2));
- EXPECT_EQ(1.23E17 , message.repeated_double(3));
- EXPECT_EQ(1.235E22 , message.repeated_double(4));
- EXPECT_EQ(1.235E-18 , message.repeated_double(5));
+ EXPECT_EQ(123.0, message.repeated_double(0));
+ EXPECT_EQ(123.5, message.repeated_double(1));
+ EXPECT_EQ(0.125, message.repeated_double(2));
+ EXPECT_EQ(1.23E17, message.repeated_double(3));
+ EXPECT_EQ(1.235E22, message.repeated_double(4));
+ EXPECT_EQ(1.235E-18, message.repeated_double(5));
EXPECT_EQ(123.456789, message.repeated_double(6));
EXPECT_EQ(message.repeated_double(7),
std::numeric_limits<double>::infinity());
@@ -1207,14 +1206,26 @@
ASSERT_EQ(1, message.repeated_string_size());
EXPECT_EQ(std::string("\000\001\a\b\f\n\r\t\v\\\'\"", 12),
message.repeated_string(0));
+
+ ASSERT_TRUE(
+ TextFormat::ParseFromString("repeated_float: 3.4028235e+38\n"
+ "repeated_float: -3.4028235e+38\n"
+ "repeated_float: 3.40282351e+38\n"
+ "repeated_float: -3.40282351e+38\n",
+ &message));
+ EXPECT_EQ(message.repeated_float(0), std::numeric_limits<float>::max());
+ EXPECT_EQ(message.repeated_float(1), -std::numeric_limits<float>::max());
+ EXPECT_EQ(message.repeated_float(2), std::numeric_limits<float>::infinity());
+ EXPECT_EQ(message.repeated_float(3), -std::numeric_limits<float>::infinity());
+
}
TEST_F(TextFormatTest, PrintFieldsInIndexOrder) {
protobuf_unittest::TestFieldOrderings message;
// Fields are listed in index order instead of field number.
- message.set_my_string("str"); // Field number 11
- message.set_my_int(12345); // Field number 1
- message.set_my_float(0.999); // Field number 101
+ message.set_my_string("str"); // Field number 11
+ message.set_my_int(12345); // Field number 1
+ message.set_my_float(0.999); // Field number 101
// Extensions are listed based on the order of extension number.
// Extension number 12.
message
@@ -1332,8 +1343,8 @@
void ExpectLocation(TextFormat::ParseInfoTree* tree, const Descriptor* d,
const std::string& field_name, int index, int line,
int column) {
- TextFormat::ParseLocation location = tree->GetLocation(
- d->FindFieldByName(field_name), index);
+ TextFormat::ParseLocation location =
+ tree->GetLocation(d->FindFieldByName(field_name), index);
EXPECT_EQ(line, location.line);
EXPECT_EQ(column, location.column);
}
@@ -1349,8 +1360,8 @@
// implements ErrorCollector -------------------------------------
void AddError(int line, int column, const std::string& message) {
- strings::SubstituteAndAppend(&text_, "$0:$1: $2\n",
- line + 1, column + 1, message);
+ strings::SubstituteAndAppend(&text_, "$0:$1: $2\n", line + 1, column + 1,
+ message);
}
void AddWarning(int line, int column, const std::string& message) {
@@ -1429,33 +1440,33 @@
std::unique_ptr<unittest::TestAllTypes> message(new unittest::TestAllTypes);
const Descriptor* d = message->GetDescriptor();
-#define EXPECT_FIELD(name, value, valuestring) \
- EXPECT_TRUE(TextFormat::ParseFieldValueFromString( \
- valuestring, d->FindFieldByName("optional_" #name), message.get())); \
- EXPECT_EQ(value, message->optional_##name()); \
+#define EXPECT_FIELD(name, value, valuestring) \
+ EXPECT_TRUE(TextFormat::ParseFieldValueFromString( \
+ valuestring, d->FindFieldByName("optional_" #name), message.get())); \
+ EXPECT_EQ(value, message->optional_##name()); \
EXPECT_TRUE(message->has_optional_##name());
-#define EXPECT_BOOL_FIELD(name, value, valuestring) \
- EXPECT_TRUE(TextFormat::ParseFieldValueFromString( \
- valuestring, d->FindFieldByName("optional_" #name), message.get())); \
- EXPECT_TRUE(message->optional_##name() == value); \
+#define EXPECT_BOOL_FIELD(name, value, valuestring) \
+ EXPECT_TRUE(TextFormat::ParseFieldValueFromString( \
+ valuestring, d->FindFieldByName("optional_" #name), message.get())); \
+ EXPECT_TRUE(message->optional_##name() == value); \
EXPECT_TRUE(message->has_optional_##name());
-#define EXPECT_FLOAT_FIELD(name, value, valuestring) \
- EXPECT_TRUE(TextFormat::ParseFieldValueFromString( \
- valuestring, d->FindFieldByName("optional_" #name), message.get())); \
- EXPECT_FLOAT_EQ(value, message->optional_##name()); \
+#define EXPECT_FLOAT_FIELD(name, value, valuestring) \
+ EXPECT_TRUE(TextFormat::ParseFieldValueFromString( \
+ valuestring, d->FindFieldByName("optional_" #name), message.get())); \
+ EXPECT_FLOAT_EQ(value, message->optional_##name()); \
EXPECT_TRUE(message->has_optional_##name());
-#define EXPECT_DOUBLE_FIELD(name, value, valuestring) \
- EXPECT_TRUE(TextFormat::ParseFieldValueFromString( \
- valuestring, d->FindFieldByName("optional_" #name), message.get())); \
- EXPECT_DOUBLE_EQ(value, message->optional_##name()); \
+#define EXPECT_DOUBLE_FIELD(name, value, valuestring) \
+ EXPECT_TRUE(TextFormat::ParseFieldValueFromString( \
+ valuestring, d->FindFieldByName("optional_" #name), message.get())); \
+ EXPECT_DOUBLE_EQ(value, message->optional_##name()); \
EXPECT_TRUE(message->has_optional_##name());
-#define EXPECT_INVALID(name, valuestring) \
+#define EXPECT_INVALID(name, valuestring) \
EXPECT_FALSE(TextFormat::ParseFieldValueFromString( \
- valuestring, d->FindFieldByName("optional_" #name), message.get()));
+ valuestring, d->FindFieldByName("optional_" #name), message.get()));
// int32
EXPECT_FIELD(int32, 1, "1");
@@ -1545,8 +1556,8 @@
// message
EXPECT_TRUE(TextFormat::ParseFieldValueFromString(
- "<bb:12>", d->FindFieldByName("optional_nested_message"), message.get()));
- EXPECT_EQ(12, message->optional_nested_message().bb()); \
+ "<bb:12>", d->FindFieldByName("optional_nested_message"), message.get()));
+ EXPECT_EQ(12, message->optional_nested_message().bb());
EXPECT_TRUE(message->has_optional_nested_message());
EXPECT_INVALID(nested_message, "any");
@@ -1557,15 +1568,13 @@
#undef EXPECT_INVALID
}
-
TEST_F(TextFormatParserTest, InvalidToken) {
- ExpectFailure("optional_bool: true\n-5\n", "Expected identifier, got: -",
- 2, 1);
+ ExpectFailure("optional_bool: true\n-5\n", "Expected identifier, got: -", 2,
+ 1);
- ExpectFailure("optional_bool: true!\n", "Expected identifier, got: !", 1,
- 20);
- ExpectFailure("\"some string\"",
- "Expected identifier, got: \"some string\"", 1, 1);
+ ExpectFailure("optional_bool: true!\n", "Expected identifier, got: !", 1, 20);
+ ExpectFailure("\"some string\"", "Expected identifier, got: \"some string\"",
+ 1, 1);
}
TEST_F(TextFormatParserTest, InvalidFieldName) {
@@ -1615,11 +1624,10 @@
// Invalid values for a double/float field.
ExpectFailure("optional_double: \"hello\"\n",
"Expected double, got: \"hello\"", 1, 18);
- ExpectFailure("optional_double: true\n", "Expected double, got: true", 1,
- 18);
+ ExpectFailure("optional_double: true\n", "Expected double, got: true", 1, 18);
ExpectFailure("optional_double: !\n", "Expected double, got: !", 1, 18);
- ExpectFailure("optional_double {\n \n}\n", "Expected \":\", found \"{\".",
- 1, 17);
+ ExpectFailure("optional_double {\n \n}\n", "Expected \":\", found \"{\".", 1,
+ 17);
// Invalid values for a signed integer field.
ExpectFailure("optional_int32: \"hello\"\n",
@@ -1627,8 +1635,8 @@
ExpectFailure("optional_int32: true\n", "Expected integer, got: true", 1, 17);
ExpectFailure("optional_int32: 4.5\n", "Expected integer, got: 4.5", 1, 17);
ExpectFailure("optional_int32: !\n", "Expected integer, got: !", 1, 17);
- ExpectFailure("optional_int32 {\n \n}\n", "Expected \":\", found \"{\".",
- 1, 16);
+ ExpectFailure("optional_int32 {\n \n}\n", "Expected \":\", found \"{\".", 1,
+ 16);
ExpectFailure("optional_int32: 0x80000000\n",
"Integer out of range (0x80000000)", 1, 17);
ExpectFailure("optional_int64: 0x8000000000000000\n",
@@ -1641,13 +1649,13 @@
// Invalid values for an unsigned integer field.
ExpectFailure("optional_uint64: \"hello\"\n",
"Expected integer, got: \"hello\"", 1, 18);
- ExpectFailure("optional_uint64: true\n",
- "Expected integer, got: true", 1, 18);
+ ExpectFailure("optional_uint64: true\n", "Expected integer, got: true", 1,
+ 18);
ExpectFailure("optional_uint64: 4.5\n", "Expected integer, got: 4.5", 1, 18);
ExpectFailure("optional_uint64: -5\n", "Expected integer, got: -", 1, 18);
ExpectFailure("optional_uint64: !\n", "Expected integer, got: !", 1, 18);
- ExpectFailure("optional_uint64 {\n \n}\n", "Expected \":\", found \"{\".",
- 1, 17);
+ ExpectFailure("optional_uint64 {\n \n}\n", "Expected \":\", found \"{\".", 1,
+ 17);
ExpectFailure("optional_uint32: 0x100000000\n",
"Integer out of range (0x100000000)", 1, 18);
ExpectFailure("optional_uint64: 0x10000000000000000\n",
@@ -1662,19 +1670,19 @@
ExpectFailure(
"optional_bool: meh\n",
- "Invalid value for boolean field \"optional_bool\". Value: \"meh\".",
- 2, 1);
+ "Invalid value for boolean field \"optional_bool\". Value: \"meh\".", 2,
+ 1);
- ExpectFailure("optional_bool {\n \n}\n", "Expected \":\", found \"{\".",
- 1, 15);
+ ExpectFailure("optional_bool {\n \n}\n", "Expected \":\", found \"{\".", 1,
+ 15);
// Invalid values for a string field.
ExpectFailure("optional_string: true\n", "Expected string, got: true", 1, 18);
ExpectFailure("optional_string: 5\n", "Expected string, got: 5", 1, 18);
ExpectFailure("optional_string: -7.5\n", "Expected string, got: -", 1, 18);
ExpectFailure("optional_string: !\n", "Expected string, got: !", 1, 18);
- ExpectFailure("optional_string {\n \n}\n", "Expected \":\", found \"{\".",
- 1, 17);
+ ExpectFailure("optional_string {\n \n}\n", "Expected \":\", found \"{\".", 1,
+ 17);
// Invalid values for an enumeration field.
ExpectFailure("optional_nested_enum: \"hello\"\n",
@@ -1683,7 +1691,8 @@
// Valid token, but enum value is not defined.
ExpectFailure("optional_nested_enum: 5\n",
"Unknown enumeration value of \"5\" for field "
- "\"optional_nested_enum\".", 2, 1);
+ "\"optional_nested_enum\".",
+ 2, 1);
// We consume the negative sign, so the error position starts one character
// later.
ExpectFailure("optional_nested_enum: -7.5\n", "Expected integer, got: 7.5", 1,
@@ -1691,29 +1700,27 @@
ExpectFailure("optional_nested_enum: !\n",
"Expected integer or identifier, got: !", 1, 23);
- ExpectFailure(
- "optional_nested_enum: grah\n",
- "Unknown enumeration value of \"grah\" for field "
- "\"optional_nested_enum\".", 2, 1);
+ ExpectFailure("optional_nested_enum: grah\n",
+ "Unknown enumeration value of \"grah\" for field "
+ "\"optional_nested_enum\".",
+ 2, 1);
- ExpectFailure(
- "optional_nested_enum {\n \n}\n",
- "Expected \":\", found \"{\".", 1, 22);
+ ExpectFailure("optional_nested_enum {\n \n}\n",
+ "Expected \":\", found \"{\".", 1, 22);
}
TEST_F(TextFormatParserTest, MessageDelimiters) {
// Non-matching delimiters.
- ExpectFailure("OptionalGroup <\n \n}\n", "Expected \">\", found \"}\".",
- 3, 1);
+ ExpectFailure("OptionalGroup <\n \n}\n", "Expected \">\", found \"}\".", 3,
+ 1);
// Invalid delimiters.
- ExpectFailure("OptionalGroup [\n \n]\n", "Expected \"{\", found \"[\".",
- 1, 15);
+ ExpectFailure("OptionalGroup [\n \n]\n", "Expected \"{\", found \"[\".", 1,
+ 15);
// Unending message.
ExpectFailure("optional_nested_message {\n \nbb: 118\n",
- "Expected identifier, got: ",
- 4, 1);
+ "Expected identifier, got: ", 4, 1);
}
TEST_F(TextFormatParserTest, UnknownExtension) {
@@ -1726,23 +1733,22 @@
TEST_F(TextFormatParserTest, MissingRequired) {
unittest::TestRequired message;
- ExpectFailure("a: 1",
- "Message missing required fields: b, c",
- 0, 1, &message);
+ ExpectFailure("a: 1", "Message missing required fields: b, c", 0, 1,
+ &message);
}
TEST_F(TextFormatParserTest, ParseDuplicateRequired) {
unittest::TestRequired message;
ExpectFailure("a: 1 b: 2 c: 3 a: 1",
- "Non-repeated field \"a\" is specified multiple times.",
- 1, 17, &message);
+ "Non-repeated field \"a\" is specified multiple times.", 1, 17,
+ &message);
}
TEST_F(TextFormatParserTest, ParseDuplicateOptional) {
unittest::ForeignMessage message;
ExpectFailure("c: 1 c: 2",
- "Non-repeated field \"c\" is specified multiple times.",
- 1, 7, &message);
+ "Non-repeated field \"c\" is specified multiple times.", 1, 7,
+ &message);
}
TEST_F(TextFormatParserTest, MergeDuplicateRequired) {
@@ -1778,10 +1784,11 @@
}
ASSERT_EQ(1, errors.size());
- EXPECT_EQ("Error parsing text-format protobuf_unittest.TestAllTypes: "
- "1:14: Message type \"protobuf_unittest.TestAllTypes\" has no field "
- "named \"no_such_field\".",
- errors[0]);
+ EXPECT_EQ(
+ "Error parsing text-format protobuf_unittest.TestAllTypes: "
+ "1:14: Message type \"protobuf_unittest.TestAllTypes\" has no field "
+ "named \"no_such_field\".",
+ errors[0]);
}
TEST_F(TextFormatParserTest, FailsOnTokenizationError) {
@@ -1795,16 +1802,18 @@
}
ASSERT_EQ(1, errors.size());
- EXPECT_EQ("Error parsing text-format protobuf_unittest.TestAllTypes: "
- "1:1: Invalid control characters encountered in text.",
- errors[0]);
+ EXPECT_EQ(
+ "Error parsing text-format protobuf_unittest.TestAllTypes: "
+ "1:1: Invalid control characters encountered in text.",
+ errors[0]);
}
TEST_F(TextFormatParserTest, ParseDeprecatedField) {
unittest::TestDeprecatedFields message;
ExpectMessage("deprecated_int32: 42",
"WARNING:text format contains deprecated field "
- "\"deprecated_int32\"", 1, 21, &message, true);
+ "\"deprecated_int32\"",
+ 1, 21, &message, true);
}
TEST_F(TextFormatParserTest, SetRecursionLimit) {
@@ -1828,25 +1837,24 @@
static const char proto_debug_string_[];
};
const char TextFormatMessageSetTest::proto_debug_string_[] =
-"message_set {\n"
-" [protobuf_unittest.TestMessageSetExtension1] {\n"
-" i: 23\n"
-" }\n"
-" [protobuf_unittest.TestMessageSetExtension2] {\n"
-" str: \"foo\"\n"
-" }\n"
-"}\n";
-
+ "message_set {\n"
+ " [protobuf_unittest.TestMessageSetExtension1] {\n"
+ " i: 23\n"
+ " }\n"
+ " [protobuf_unittest.TestMessageSetExtension2] {\n"
+ " str: \"foo\"\n"
+ " }\n"
+ "}\n";
TEST_F(TextFormatMessageSetTest, Serialize) {
protobuf_unittest::TestMessageSetContainer proto;
protobuf_unittest::TestMessageSetExtension1* item_a =
- proto.mutable_message_set()->MutableExtension(
- protobuf_unittest::TestMessageSetExtension1::message_set_extension);
+ proto.mutable_message_set()->MutableExtension(
+ protobuf_unittest::TestMessageSetExtension1::message_set_extension);
item_a->set_i(23);
protobuf_unittest::TestMessageSetExtension2* item_b =
- proto.mutable_message_set()->MutableExtension(
- protobuf_unittest::TestMessageSetExtension2::message_set_extension);
+ proto.mutable_message_set()->MutableExtension(
+ protobuf_unittest::TestMessageSetExtension2::message_set_extension);
item_b->set_str("foo");
EXPECT_EQ(proto_debug_string_, proto.DebugString());
}
@@ -1854,18 +1862,165 @@
TEST_F(TextFormatMessageSetTest, Deserialize) {
protobuf_unittest::TestMessageSetContainer proto;
ASSERT_TRUE(TextFormat::ParseFromString(proto_debug_string_, &proto));
- EXPECT_EQ(23, proto.message_set().GetExtension(
- protobuf_unittest::TestMessageSetExtension1::message_set_extension).i());
- EXPECT_EQ("foo", proto.message_set().GetExtension(
- protobuf_unittest::TestMessageSetExtension2::message_set_extension).str());
+ EXPECT_EQ(
+ 23,
+ proto.message_set()
+ .GetExtension(
+ protobuf_unittest::TestMessageSetExtension1::message_set_extension)
+ .i());
+ EXPECT_EQ(
+ "foo",
+ proto.message_set()
+ .GetExtension(
+ protobuf_unittest::TestMessageSetExtension2::message_set_extension)
+ .str());
// Ensure that these are the only entries present.
std::vector<const FieldDescriptor*> descriptors;
- proto.message_set().GetReflection()->ListFields(
- proto.message_set(), &descriptors);
+ proto.message_set().GetReflection()->ListFields(proto.message_set(),
+ &descriptors);
EXPECT_EQ(2, descriptors.size());
}
+TEST(TextFormatUnknownFieldTest, TestUnknownField) {
+ protobuf_unittest::TestAllTypes proto;
+ TextFormat::Parser parser;
+ // Unknown field is not permitted by default.
+ EXPECT_FALSE(parser.ParseFromString("unknown_field: 12345", &proto));
+ EXPECT_FALSE(parser.ParseFromString("12345678: 12345", &proto));
+
+ parser.AllowUnknownField(true);
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: 12345", &proto));
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: -12345", &proto));
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: 1.2345", &proto));
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: -1.2345", &proto));
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: 1.2345f", &proto));
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: -1.2345f", &proto));
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: inf", &proto));
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: -inf", &proto));
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: TYPE_STRING", &proto));
+ EXPECT_TRUE(
+ parser.ParseFromString("unknown_field: \"string value\"", &proto));
+ // Invalid field value
+ EXPECT_FALSE(parser.ParseFromString("unknown_field: -TYPE_STRING", &proto));
+ // Two or more unknown fields
+ EXPECT_TRUE(
+ parser.ParseFromString("unknown_field1: TYPE_STRING\n"
+ "unknown_field2: 12345",
+ &proto));
+ // Unknown nested message
+ EXPECT_TRUE(
+ parser.ParseFromString("unknown_message1: {}\n"
+ "unknown_message2 {\n"
+ " unknown_field: 12345\n"
+ "}\n"
+ "unknown_message3 <\n"
+ " unknown_nested_message {\n"
+ " unknown_field: 12345\n"
+ " }\n"
+ ">",
+ &proto));
+ // Unmatched delimeters for message body
+ EXPECT_FALSE(parser.ParseFromString("unknown_message: {>", &proto));
+ // Unknown extension
+ EXPECT_TRUE(
+ parser.ParseFromString("[somewhere.unknown_extension1]: 12345\n"
+ "[somewhere.unknown_extension2] {\n"
+ " unknown_field: 12345\n"
+ "}",
+ &proto));
+ // Unknown fields between known fields
+ ASSERT_TRUE(
+ parser.ParseFromString("optional_int32: 1\n"
+ "unknown_field: 12345\n"
+ "optional_string: \"string\"\n"
+ "unknown_message { unknown: 0 }\n"
+ "optional_nested_message { bb: 2 }",
+ &proto));
+ EXPECT_EQ(1, proto.optional_int32());
+ EXPECT_EQ("string", proto.optional_string());
+ EXPECT_EQ(2, proto.optional_nested_message().bb());
+
+ // Unknown field with numeric tag number instead of identifier.
+ EXPECT_TRUE(parser.ParseFromString("12345678: 12345", &proto));
+
+ // Nested unknown extensions.
+ EXPECT_TRUE(
+ parser.ParseFromString("[test.extension1] <\n"
+ " unknown_nested_message <\n"
+ " [test.extension2] <\n"
+ " unknown_field: 12345\n"
+ " >\n"
+ " >\n"
+ ">",
+ &proto));
+ EXPECT_TRUE(
+ parser.ParseFromString("[test.extension1] {\n"
+ " unknown_nested_message {\n"
+ " [test.extension2] {\n"
+ " unknown_field: 12345\n"
+ " }\n"
+ " }\n"
+ "}",
+ &proto));
+ EXPECT_TRUE(
+ parser.ParseFromString("[test.extension1] <\n"
+ " some_unknown_fields: <\n"
+ " unknown_field: 12345\n"
+ " >\n"
+ ">",
+ &proto));
+ EXPECT_TRUE(
+ parser.ParseFromString("[test.extension1] {\n"
+ " some_unknown_fields: {\n"
+ " unknown_field: 12345\n"
+ " }\n"
+ "}",
+ &proto));
+
+ // Unknown field with compact repetition.
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: [1, 2]", &proto));
+ // Unknown field with compact repetition of some unknown enum.
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: [VAL1, VAL2]", &proto));
+ // Unknown field with compact repetition with sub-message.
+ EXPECT_TRUE(parser.ParseFromString("unknown_field: [{a:1}, <b:2>]", &proto));
+}
+
+TEST(TextFormatUnknownFieldTest, TestAnyInUnknownField) {
+ protobuf_unittest::TestAllTypes proto;
+ TextFormat::Parser parser;
+ parser.AllowUnknownField(true);
+ EXPECT_TRUE(
+ parser.ParseFromString("unknown {\n"
+ " [type.googleapis.com/foo.bar] {\n"
+ " }\n"
+ "}",
+ &proto));
+}
+
+TEST(TextFormatUnknownFieldTest, TestUnknownExtension) {
+ protobuf_unittest::TestAllTypes proto;
+ TextFormat::Parser parser;
+ std::string message_with_ext =
+ "[test.extension1] {\n"
+ " some_unknown_fields: {\n"
+ " unknown_field: 12345\n"
+ " }\n"
+ "}";
+ // Unknown extensions are not permitted by default.
+ EXPECT_FALSE(parser.ParseFromString(message_with_ext, &proto));
+ // AllowUnknownField implies AllowUnknownExtension.
+ parser.AllowUnknownField(true);
+ EXPECT_TRUE(parser.ParseFromString(message_with_ext, &proto));
+
+ parser.AllowUnknownField(false);
+ EXPECT_FALSE(parser.ParseFromString(message_with_ext, &proto));
+ parser.AllowUnknownExtension(true);
+ EXPECT_TRUE(parser.ParseFromString(message_with_ext, &proto));
+ // Unknown fields are still not accepted.
+ EXPECT_FALSE(parser.ParseFromString("unknown_field: 1", &proto));
+}
+
} // namespace text_format_unittest
} // namespace protobuf
diff --git a/src/google/protobuf/timestamp.pb.cc b/src/google/protobuf/timestamp.pb.cc
index 091caa5..6ec5991 100644
--- a/src/google/protobuf/timestamp.pb.cc
+++ b/src/google/protobuf/timestamp.pb.cc
@@ -36,10 +36,6 @@
PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Timestamp_google_2fprotobuf_2ftimestamp_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTimestamp_google_2fprotobuf_2ftimestamp_2eproto}, {}};
-void InitDefaults_google_2fprotobuf_2ftimestamp_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Timestamp_google_2fprotobuf_2ftimestamp_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2ftimestamp_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2ftimestamp_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2ftimestamp_2eproto = nullptr;
@@ -76,8 +72,7 @@
"Protobuf.WellKnownTypesb\006proto3"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ftimestamp_2eproto = {
- false, InitDefaults_google_2fprotobuf_2ftimestamp_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2ftimestamp_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2ftimestamp_2eproto,
"google/protobuf/timestamp.proto", &assign_descriptors_table_google_2fprotobuf_2ftimestamp_2eproto, 231,
};
@@ -85,6 +80,7 @@
static constexpr ::PROTOBUF_NAMESPACE_ID::internal::InitFunc deps[1] =
{
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Timestamp_google_2fprotobuf_2ftimestamp_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2ftimestamp_2eproto, deps, 0);
}
@@ -171,39 +167,45 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Timestamp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// int64 seconds = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_seconds(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// int32 nanos = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_nanos(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ nanos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Timestamp::MergePartialFromCodedStream(
diff --git a/src/google/protobuf/timestamp.proto b/src/google/protobuf/timestamp.proto
index 2b9e26a..cd35786 100644
--- a/src/google/protobuf/timestamp.proto
+++ b/src/google/protobuf/timestamp.proto
@@ -113,17 +113,18 @@
// 01:30 UTC on January 15, 2017.
//
// In JavaScript, one can convert a Date object to this format using the
-// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+// standard
+// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
// method. In Python, a standard `datetime.datetime` object can be converted
-// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
-// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
-// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
+// to this format using
+// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+// the Joda Time's [`ISODateTimeFormat.dateTime()`](
// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
// ) to obtain a formatter capable of generating timestamps in this format.
//
//
message Timestamp {
-
// Represents seconds of UTC time since Unix epoch
// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
// 9999-12-31T23:59:59Z inclusive.
diff --git a/src/google/protobuf/type.pb.cc b/src/google/protobuf/type.pb.cc
index f30839c..d75b30a 100644
--- a/src/google/protobuf/type.pb.cc
+++ b/src/google/protobuf/type.pb.cc
@@ -122,14 +122,6 @@
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsOption_google_2fprotobuf_2ftype_2eproto}, {
&scc_info_Any_google_2fprotobuf_2fany_2eproto.base,}};
-void InitDefaults_google_2fprotobuf_2ftype_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Type_google_2fprotobuf_2ftype_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Field_google_2fprotobuf_2ftype_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Enum_google_2fprotobuf_2ftype_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumValue_google_2fprotobuf_2ftype_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Option_google_2fprotobuf_2ftype_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2ftype_2eproto[5];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2ftype_2eproto[3];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2ftype_2eproto = nullptr;
@@ -252,8 +244,7 @@
"le.Protobuf.WellKnownTypesb\006proto3"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ftype_2eproto = {
- false, InitDefaults_google_2fprotobuf_2ftype_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2ftype_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2ftype_2eproto,
"google/protobuf/type.proto", &assign_descriptors_table_google_2fprotobuf_2ftype_2eproto, 1594,
};
@@ -263,6 +254,11 @@
::AddDescriptors_google_2fprotobuf_2fany_2eproto,
::AddDescriptors_google_2fprotobuf_2fsource_5fcontext_2eproto,
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Type_google_2fprotobuf_2ftype_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Field_google_2fprotobuf_2ftype_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Enum_google_2fprotobuf_2ftype_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EnumValue_google_2fprotobuf_2ftype_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Option_google_2fprotobuf_2ftype_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2ftype_2eproto, deps, 2);
}
@@ -498,61 +494,68 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Type::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "google.protobuf.Type.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.Field fields = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_fields(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 18 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 18) break;
+ ptr += 1;
+ }
break;
}
// repeated string oneofs = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
- do {
+ while (true) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_oneofs(), ptr, ctx, "google.protobuf.Type.oneofs");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 26 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 26) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.Option options = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 34 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 34) break;
+ ptr += 1;
+ }
break;
}
// .google.protobuf.SourceContext source_context = 5;
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 42) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_source_context(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// .google.protobuf.Syntax syntax = 6;
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 48) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
set_syntax(static_cast<PROTOBUF_NAMESPACE_ID::Syntax>(val));
break;
}
@@ -560,15 +563,20 @@
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Type::MergePartialFromCodedStream(
@@ -1090,17 +1098,18 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Field::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// .google.protobuf.Field.Kind kind = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
set_kind(static_cast<PROTOBUF_NAMESPACE_ID::Field_Kind>(val));
break;
}
@@ -1108,82 +1117,89 @@
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
set_cardinality(static_cast<PROTOBUF_NAMESPACE_ID::Field_Cardinality>(val));
break;
}
// int32 number = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 24) goto handle_unusual;
- set_number(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// string name = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "google.protobuf.Field.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// string type_url = 6;
case 6: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 50) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_type_url(), ptr, ctx, "google.protobuf.Field.type_url");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// int32 oneof_index = 7;
case 7: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 56) goto handle_unusual;
- set_oneof_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ oneof_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// bool packed = 8;
case 8: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 64) goto handle_unusual;
- set_packed(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ packed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.Option options = 9;
case 9: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 74) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 74 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 74) break;
+ ptr += 1;
+ }
break;
}
// string json_name = 10;
case 10: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 82) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_json_name(), ptr, ctx, "google.protobuf.Field.json_name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// string default_value = 11;
case 11: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 90) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_default_value(), ptr, ctx, "google.protobuf.Field.default_value");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Field::MergePartialFromCodedStream(
@@ -1869,51 +1885,56 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Enum::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "google.protobuf.Enum.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.EnumValue enumvalue = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_enumvalue(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 18 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 18) break;
+ ptr += 1;
+ }
break;
}
// repeated .google.protobuf.Option options = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 26 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 26) break;
+ ptr += 1;
+ }
break;
}
// .google.protobuf.SourceContext source_context = 4;
case 4: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 34) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_source_context(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// .google.protobuf.Syntax syntax = 5;
case 5: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 40) goto handle_unusual;
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
set_syntax(static_cast<PROTOBUF_NAMESPACE_ID::Syntax>(val));
break;
}
@@ -1921,15 +1942,20 @@
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Enum::MergePartialFromCodedStream(
@@ -2368,49 +2394,57 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* EnumValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "google.protobuf.EnumValue.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// int32 number = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 16) goto handle_unusual;
- set_number(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
// repeated .google.protobuf.Option options = 3;
case 3: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 26) goto handle_unusual;
- do {
+ while (true) {
ptr = ctx->ParseMessage(add_options(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- if (ctx->Done(&ptr)) return ptr;
- } while ((::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr) & 255) == 26 && (ptr += 1));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ if (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) != 26) break;
+ ptr += 1;
+ }
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool EnumValue::MergePartialFromCodedStream(
@@ -2801,39 +2835,45 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Option::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// string name = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "google.protobuf.Option.name");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
// .google.protobuf.Any value = 2;
case 2: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 18) goto handle_unusual;
ptr = ctx->ParseMessage(mutable_value(), ptr);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Option::MergePartialFromCodedStream(
diff --git a/src/google/protobuf/type.pb.h b/src/google/protobuf/type.pb.h
index 7e57a50..262c41c 100644
--- a/src/google/protobuf/type.pb.h
+++ b/src/google/protobuf/type.pb.h
@@ -82,7 +82,7 @@
PROTOBUF_NAMESPACE_CLOSE
PROTOBUF_NAMESPACE_OPEN
-enum Field_Kind {
+enum Field_Kind : int {
Field_Kind_TYPE_UNKNOWN = 0,
Field_Kind_TYPE_DOUBLE = 1,
Field_Kind_TYPE_FLOAT = 2,
@@ -111,16 +111,20 @@
constexpr int Field_Kind_Kind_ARRAYSIZE = Field_Kind_Kind_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Field_Kind_descriptor();
-inline const std::string& Field_Kind_Name(Field_Kind value) {
+template<typename T>
+inline const std::string& Field_Kind_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Field_Kind>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function Field_Kind_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
- Field_Kind_descriptor(), value);
+ Field_Kind_descriptor(), enum_t_value);
}
inline bool Field_Kind_Parse(
const std::string& name, Field_Kind* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Field_Kind>(
Field_Kind_descriptor(), name, value);
}
-enum Field_Cardinality {
+enum Field_Cardinality : int {
Field_Cardinality_CARDINALITY_UNKNOWN = 0,
Field_Cardinality_CARDINALITY_OPTIONAL = 1,
Field_Cardinality_CARDINALITY_REQUIRED = 2,
@@ -134,16 +138,20 @@
constexpr int Field_Cardinality_Cardinality_ARRAYSIZE = Field_Cardinality_Cardinality_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Field_Cardinality_descriptor();
-inline const std::string& Field_Cardinality_Name(Field_Cardinality value) {
+template<typename T>
+inline const std::string& Field_Cardinality_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Field_Cardinality>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function Field_Cardinality_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
- Field_Cardinality_descriptor(), value);
+ Field_Cardinality_descriptor(), enum_t_value);
}
inline bool Field_Cardinality_Parse(
const std::string& name, Field_Cardinality* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Field_Cardinality>(
Field_Cardinality_descriptor(), name, value);
}
-enum Syntax {
+enum Syntax : int {
SYNTAX_PROTO2 = 0,
SYNTAX_PROTO3 = 1,
Syntax_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
@@ -155,9 +163,13 @@
constexpr int Syntax_ARRAYSIZE = Syntax_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Syntax_descriptor();
-inline const std::string& Syntax_Name(Syntax value) {
+template<typename T>
+inline const std::string& Syntax_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Syntax>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function Syntax_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
- Syntax_descriptor(), value);
+ Syntax_descriptor(), enum_t_value);
}
inline bool Syntax_Parse(
const std::string& name, Syntax* value) {
@@ -532,8 +544,12 @@
Kind_descriptor() {
return Field_Kind_descriptor();
}
- static inline const std::string& Kind_Name(Kind value) {
- return Field_Kind_Name(value);
+ template<typename T>
+ static inline const std::string& Kind_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Kind>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function Kind_Name.");
+ return Field_Kind_Name(enum_t_value);
}
static inline bool Kind_Parse(const std::string& name,
Kind* value) {
@@ -562,8 +578,12 @@
Cardinality_descriptor() {
return Field_Cardinality_descriptor();
}
- static inline const std::string& Cardinality_Name(Cardinality value) {
- return Field_Cardinality_Name(value);
+ template<typename T>
+ static inline const std::string& Cardinality_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Cardinality>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function Cardinality_Name.");
+ return Field_Cardinality_Name(enum_t_value);
}
static inline bool Cardinality_Parse(const std::string& name,
Cardinality* value) {
diff --git a/src/google/protobuf/type.proto b/src/google/protobuf/type.proto
index 624c15e..e4b1d3a 100644
--- a/src/google/protobuf/type.proto
+++ b/src/google/protobuf/type.proto
@@ -64,44 +64,44 @@
// Basic field types.
enum Kind {
// Field type unknown.
- TYPE_UNKNOWN = 0;
+ TYPE_UNKNOWN = 0;
// Field type double.
- TYPE_DOUBLE = 1;
+ TYPE_DOUBLE = 1;
// Field type float.
- TYPE_FLOAT = 2;
+ TYPE_FLOAT = 2;
// Field type int64.
- TYPE_INT64 = 3;
+ TYPE_INT64 = 3;
// Field type uint64.
- TYPE_UINT64 = 4;
+ TYPE_UINT64 = 4;
// Field type int32.
- TYPE_INT32 = 5;
+ TYPE_INT32 = 5;
// Field type fixed64.
- TYPE_FIXED64 = 6;
+ TYPE_FIXED64 = 6;
// Field type fixed32.
- TYPE_FIXED32 = 7;
+ TYPE_FIXED32 = 7;
// Field type bool.
- TYPE_BOOL = 8;
+ TYPE_BOOL = 8;
// Field type string.
- TYPE_STRING = 9;
+ TYPE_STRING = 9;
// Field type group. Proto2 syntax only, and deprecated.
- TYPE_GROUP = 10;
+ TYPE_GROUP = 10;
// Field type message.
- TYPE_MESSAGE = 11;
+ TYPE_MESSAGE = 11;
// Field type bytes.
- TYPE_BYTES = 12;
+ TYPE_BYTES = 12;
// Field type uint32.
- TYPE_UINT32 = 13;
+ TYPE_UINT32 = 13;
// Field type enum.
- TYPE_ENUM = 14;
+ TYPE_ENUM = 14;
// Field type sfixed32.
- TYPE_SFIXED32 = 15;
+ TYPE_SFIXED32 = 15;
// Field type sfixed64.
- TYPE_SFIXED64 = 16;
+ TYPE_SFIXED64 = 16;
// Field type sint32.
- TYPE_SINT32 = 17;
+ TYPE_SINT32 = 17;
// Field type sint64.
- TYPE_SINT64 = 18;
- };
+ TYPE_SINT64 = 18;
+ }
// Whether a field is optional, required, or repeated.
enum Cardinality {
diff --git a/src/google/protobuf/unknown_field_set.h b/src/google/protobuf/unknown_field_set.h
index 0d61f89..4d5cc06 100644
--- a/src/google/protobuf/unknown_field_set.h
+++ b/src/google/protobuf/unknown_field_set.h
@@ -56,20 +56,20 @@
namespace google {
namespace protobuf {
- namespace io {
- class CodedInputStream; // coded_stream.h
- class CodedOutputStream; // coded_stream.h
- class ZeroCopyInputStream; // zero_copy_stream.h
- }
- namespace internal {
- class InternalMetadataWithArena; // metadata.h
- class WireFormat; // wire_format.h
- class MessageSetFieldSkipperUsingCord;
- // extension_set_heavy.cc
- }
+namespace io {
+class CodedInputStream; // coded_stream.h
+class CodedOutputStream; // coded_stream.h
+class ZeroCopyInputStream; // zero_copy_stream.h
+} // namespace io
+namespace internal {
+class InternalMetadataWithArena; // metadata.h
+class WireFormat; // wire_format.h
+class MessageSetFieldSkipperUsingCord;
+// extension_set_heavy.cc
+} // namespace internal
-class Message; // message.h
-class UnknownField; // below
+class Message; // message.h
+class UnknownField; // below
// An UnknownFieldSet contains fields that were encountered while parsing a
// message but were not defined by its type. Keeping track of these can be
@@ -125,9 +125,7 @@
// Version of SpaceUsed() including sizeof(*this).
size_t SpaceUsedLong() const;
- int SpaceUsed() const {
- return internal::ToIntSize(SpaceUsedLong());
- }
+ int SpaceUsed() const { return internal::ToIntSize(SpaceUsedLong()); }
// Returns the number of fields present in the UnknownFieldSet.
inline int field_count() const;
@@ -172,6 +170,7 @@
}
static const UnknownFieldSet* default_instance();
+
private:
// For InternalMergeFrom
friend class UnknownField;
@@ -302,9 +301,7 @@
}
}
-inline bool UnknownFieldSet::empty() const {
- return fields_.empty();
-}
+inline bool UnknownFieldSet::empty() const { return fields_.empty(); }
inline void UnknownFieldSet::Swap(UnknownFieldSet* x) {
fields_.swap(x->fields_);
diff --git a/src/google/protobuf/unknown_field_set_unittest.cc b/src/google/protobuf/unknown_field_set_unittest.cc
index 771413d..6d76b67 100644
--- a/src/google/protobuf/unknown_field_set_unittest.cc
+++ b/src/google/protobuf/unknown_field_set_unittest.cc
@@ -35,14 +35,14 @@
// This test is testing a lot more than just the UnknownFieldSet class. It
// tests handling of unknown fields throughout the system.
-#include <google/protobuf/stubs/mutex.h>
#include <google/protobuf/unknown_field_set.h>
-#include <google/protobuf/descriptor.h>
+#include <google/protobuf/test_util.h>
+#include <google/protobuf/unittest.pb.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/stubs/mutex.h>
#include <google/protobuf/wire_format.h>
-#include <google/protobuf/unittest.pb.h>
-#include <google/protobuf/test_util.h>
#include <google/protobuf/stubs/callback.h>
#include <google/protobuf/stubs/common.h>
@@ -85,7 +85,7 @@
std::string GetBizarroData() {
unittest::TestEmptyMessage bizarro_message;
UnknownFieldSet* bizarro_unknown_fields =
- bizarro_message.mutable_unknown_fields();
+ bizarro_message.mutable_unknown_fields();
for (int i = 0; i < unknown_fields_->field_count(); i++) {
const UnknownField& unknown_field = unknown_fields_->field(i);
if (unknown_field.type() == UnknownField::TYPE_VARINT) {
@@ -180,7 +180,7 @@
const UnknownField& nested_field = field->group().field(0);
const FieldDescriptor* nested_field_descriptor =
- unittest::TestAllTypes::OptionalGroup::descriptor()->FindFieldByName("a");
+ unittest::TestAllTypes::OptionalGroup::descriptor()->FindFieldByName("a");
ASSERT_TRUE(nested_field_descriptor != NULL);
EXPECT_EQ(nested_field_descriptor->number(), nested_field.number());
@@ -189,8 +189,8 @@
}
TEST_F(UnknownFieldSetTest, SerializeFastAndSlowAreEquivalent) {
- int size = WireFormat::ComputeUnknownFieldsSize(
- empty_message_.unknown_fields());
+ int size =
+ WireFormat::ComputeUnknownFieldsSize(empty_message_.unknown_fields());
std::string slow_buffer;
std::string fast_buffer;
slow_buffer.resize(size);
@@ -198,7 +198,7 @@
uint8* target = reinterpret_cast<uint8*>(::google::protobuf::string_as_array(&fast_buffer));
uint8* result = WireFormat::SerializeUnknownFieldsToArray(
- empty_message_.unknown_fields(), target);
+ empty_message_.unknown_fields(), target);
EXPECT_EQ(size, result - target);
{
@@ -299,13 +299,13 @@
destination.MergeFrom(source);
EXPECT_EQ(
- // Note: The ordering of fields here depends on the ordering of adds
- // and merging, above.
- "1: 1\n"
- "3: 2\n"
- "2: 3\n"
- "3: 4\n",
- destination.DebugString());
+ // Note: The ordering of fields here depends on the ordering of adds
+ // and merging, above.
+ "1: 1\n"
+ "3: 2\n"
+ "2: 3\n"
+ "3: 4\n",
+ destination.DebugString());
}
@@ -408,14 +408,14 @@
}
TEST_F(UnknownFieldSetTest, UnknownEnumValue) {
- using unittest::TestAllTypes;
using unittest::TestAllExtensions;
+ using unittest::TestAllTypes;
using unittest::TestEmptyMessage;
const FieldDescriptor* singular_field =
- TestAllTypes::descriptor()->FindFieldByName("optional_nested_enum");
+ TestAllTypes::descriptor()->FindFieldByName("optional_nested_enum");
const FieldDescriptor* repeated_field =
- TestAllTypes::descriptor()->FindFieldByName("repeated_nested_enum");
+ TestAllTypes::descriptor()->FindFieldByName("repeated_nested_enum");
ASSERT_TRUE(singular_field != NULL);
ASSERT_TRUE(repeated_field != NULL);
@@ -572,8 +572,7 @@
unknown_fields.DeleteByNumber(deleted_number);
ASSERT_EQ(expected_field_nubmers.size(), unknown_fields.field_count());
for (int i = 0; i < expected_field_nubmers.size(); ++i) {
- EXPECT_EQ(expected_field_nubmers[i],
- unknown_fields.field(i).number());
+ EXPECT_EQ(expected_field_nubmers[i], unknown_fields.field(i).number());
}
}
diff --git a/src/google/protobuf/util/delimited_message_util.cc b/src/google/protobuf/util/delimited_message_util.cc
index c0d5cb0..425dc2c 100644
--- a/src/google/protobuf/util/delimited_message_util.cc
+++ b/src/google/protobuf/util/delimited_message_util.cc
@@ -1,8 +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.
+
// Adapted from the patch of kenton@google.com (Kenton Varda)
// See https://github.com/protocolbuffers/protobuf/pull/710 for details.
-#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/util/delimited_message_util.h>
+#include <google/protobuf/io/coded_stream.h>
namespace google {
namespace protobuf {
@@ -66,7 +96,9 @@
bool SerializeDelimitedToCodedStream(const MessageLite& message,
io::CodedOutputStream* output) {
// Write the size.
- int size = message.ByteSize();
+ size_t size = message.ByteSizeLong();
+ if (size > INT_MAX) return false;
+
output->WriteVarint32(size);
// Write the content.
diff --git a/src/google/protobuf/util/delimited_message_util.h b/src/google/protobuf/util/delimited_message_util.h
index 5f2d94c..946bbc9 100644
--- a/src/google/protobuf/util/delimited_message_util.h
+++ b/src/google/protobuf/util/delimited_message_util.h
@@ -1,3 +1,33 @@
+// 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.
+
// Adapted from the patch of kenton@google.com (Kenton Varda)
// See https://github.com/protocolbuffers/protobuf/pull/710 for details.
diff --git a/src/google/protobuf/util/delimited_message_util_test.cc b/src/google/protobuf/util/delimited_message_util_test.cc
index 5a311c0..9ed6778 100644
--- a/src/google/protobuf/util/delimited_message_util_test.cc
+++ b/src/google/protobuf/util/delimited_message_util_test.cc
@@ -1,3 +1,33 @@
+// 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.
+
// Adapted from the patch of kenton@google.com (Kenton Varda)
// See https://github.com/protocolbuffers/protobuf/pull/710 for details.
diff --git a/src/google/protobuf/util/field_comparator.cc b/src/google/protobuf/util/field_comparator.cc
index 83d21c9..3316506 100644
--- a/src/google/protobuf/util/field_comparator.cc
+++ b/src/google/protobuf/util/field_comparator.cc
@@ -51,8 +51,7 @@
DefaultFieldComparator::DefaultFieldComparator()
: float_comparison_(EXACT),
treat_nan_as_equal_(false),
- has_default_tolerance_(false) {
-}
+ has_default_tolerance_(false) {}
DefaultFieldComparator::~DefaultFieldComparator() {}
@@ -64,19 +63,17 @@
const Reflection* reflection_2 = message_2.GetReflection();
switch (field->cpp_type()) {
-#define COMPARE_FIELD(METHOD) \
- if (field->is_repeated()) { \
- return ResultFromBoolean(Compare##METHOD( \
- *field, \
- reflection_1->GetRepeated##METHOD(message_1, field, index_1), \
- reflection_2->GetRepeated##METHOD(message_2, field, index_2))); \
- } else { \
- return ResultFromBoolean(Compare##METHOD( \
- *field, \
- reflection_1->Get##METHOD(message_1, field), \
- reflection_2->Get##METHOD(message_2, field))); \
- } \
- break; // Make sure no fall-through is introduced.
+#define COMPARE_FIELD(METHOD) \
+ if (field->is_repeated()) { \
+ return ResultFromBoolean(Compare##METHOD( \
+ *field, reflection_1->GetRepeated##METHOD(message_1, field, index_1), \
+ reflection_2->GetRepeated##METHOD(message_2, field, index_2))); \
+ } else { \
+ return ResultFromBoolean( \
+ Compare##METHOD(*field, reflection_1->Get##METHOD(message_1, field), \
+ reflection_2->Get##METHOD(message_2, field))); \
+ } \
+ break; // Make sure no fall-through is introduced.
case FieldDescriptor::CPPTYPE_BOOL:
COMPARE_FIELD(Bool);
@@ -97,8 +94,9 @@
std::string scratch1;
std::string scratch2;
return ResultFromBoolean(
- CompareString(*field, reflection_1->GetRepeatedStringReference(
- message_1, field, index_1, &scratch1),
+ CompareString(*field,
+ reflection_1->GetRepeatedStringReference(
+ message_1, field, index_1, &scratch1),
reflection_2->GetRepeatedStringReference(
message_2, field, index_2, &scratch2)));
} else {
@@ -133,8 +131,8 @@
const Message& message1,
const Message& message2,
const util::FieldContext* field_context) {
- return differencer->Compare(
- message1, message2, field_context->parent_fields());
+ return differencer->Compare(message1, message2,
+ field_context->parent_fields());
}
void DefaultFieldComparator::SetDefaultFractionAndMargin(double fraction,
@@ -169,7 +167,7 @@
return CompareDoubleOrFloat(field, value_1, value_2);
}
-template<typename T>
+template <typename T>
bool DefaultFieldComparator::CompareDoubleOrFloat(const FieldDescriptor& field,
T value_1, T value_2) {
if (value_1 == value_2) {
@@ -177,14 +175,14 @@
// themselves), and is a shortcut for finite values.
return true;
} else if (float_comparison_ == EXACT) {
- if (treat_nan_as_equal_ &&
- MathLimits<T>::IsNaN(value_1) && MathLimits<T>::IsNaN(value_2)) {
+ if (treat_nan_as_equal_ && MathLimits<T>::IsNaN(value_1) &&
+ MathLimits<T>::IsNaN(value_2)) {
return true;
}
return false;
} else {
- if (treat_nan_as_equal_ &&
- MathLimits<T>::IsNaN(value_1) && MathLimits<T>::IsNaN(value_2)) {
+ if (treat_nan_as_equal_ && MathLimits<T>::IsNaN(value_1) &&
+ MathLimits<T>::IsNaN(value_2)) {
return true;
}
// float_comparison_ == APPROXIMATE covers two use cases.
diff --git a/src/google/protobuf/util/field_comparator.h b/src/google/protobuf/util/field_comparator.h
index ca78fc5..7b5ce52 100644
--- a/src/google/protobuf/util/field_comparator.h
+++ b/src/google/protobuf/util/field_comparator.h
@@ -100,12 +100,12 @@
class PROTOBUF_EXPORT DefaultFieldComparator : public FieldComparator {
public:
enum FloatComparison {
- EXACT, // Floats and doubles are compared exactly.
- APPROXIMATE, // Floats and doubles are compared using the
- // MathUtil::AlmostEqual method or
- // MathUtil::WithinFractionOrMargin method.
- // TODO(ksroka): Introduce third value to differenciate uses of AlmostEqual
- // and WithinFractionOrMargin.
+ EXACT, // Floats and doubles are compared exactly.
+ APPROXIMATE, // Floats and doubles are compared using the
+ // MathUtil::AlmostEqual method or
+ // MathUtil::WithinFractionOrMargin method.
+ // TODO(ksroka): Introduce third value to differentiate uses of AlmostEqual
+ // and WithinFractionOrMargin.
};
// Creates new comparator with float comparison set to EXACT.
@@ -122,9 +122,7 @@
float_comparison_ = float_comparison;
}
- FloatComparison float_comparison() const {
- return float_comparison_;
- }
+ FloatComparison float_comparison() const { return float_comparison_; }
// Set whether the FieldComparator shall treat floats or doubles that are both
// NaN as equal (treat_nan_as_equal = true) or as different
@@ -133,9 +131,7 @@
treat_nan_as_equal_ = treat_nan_as_equal;
}
- bool treat_nan_as_equal() const {
- return treat_nan_as_equal_;
- }
+ bool treat_nan_as_equal() const { return treat_nan_as_equal_; }
// Sets the fraction and margin for the float comparison of a given field.
// Uses MathUtil::WithinFractionOrMargin to compare the values.
@@ -167,12 +163,8 @@
struct Tolerance {
double fraction;
double margin;
- Tolerance()
- : fraction(0.0),
- margin(0.0) {}
- Tolerance(double f, double m)
- : fraction(f),
- margin(m) {}
+ Tolerance() : fraction(0.0), margin(0.0) {}
+ Tolerance(double f, double m) : fraction(f), margin(m) {}
};
// Defines the map to store the tolerances for floating point comparison.
@@ -182,8 +174,8 @@
// basic types (instead of submessages). They return true on success. One
// can use ResultFromBoolean() to convert that boolean to a ComparisonResult
// value.
- bool CompareBool(const FieldDescriptor& /* unused */,
- bool value_1, bool value_2) {
+ bool CompareBool(const FieldDescriptor& /* unused */, bool value_1,
+ bool value_2) {
return value_1 == value_2;
}
@@ -210,8 +202,8 @@
return value_1 == value_2;
}
- bool CompareString(const FieldDescriptor& /* unused */, const std::string& value_1,
- const std::string& value_2) {
+ bool CompareString(const FieldDescriptor& /* unused */,
+ const std::string& value_1, const std::string& value_2) {
return value_1 == value_2;
}
diff --git a/src/google/protobuf/util/field_comparator_test.cc b/src/google/protobuf/util/field_comparator_test.cc
index 00de96d..6b7ee49 100644
--- a/src/google/protobuf/util/field_comparator_test.cc
+++ b/src/google/protobuf/util/field_comparator_test.cc
@@ -51,9 +51,7 @@
class DefaultFieldComparatorTest : public ::testing::Test {
protected:
- void SetUp() {
- descriptor_ = TestAllTypes::descriptor();
- }
+ void SetUp() { descriptor_ = TestAllTypes::descriptor(); }
const Descriptor* descriptor_;
DefaultFieldComparator comparator_;
@@ -62,8 +60,7 @@
};
TEST_F(DefaultFieldComparatorTest, RecursesIntoGroup) {
- const FieldDescriptor* field =
- descriptor_->FindFieldByName("optionalgroup");
+ const FieldDescriptor* field = descriptor_->FindFieldByName("optionalgroup");
EXPECT_EQ(FieldComparator::RECURSE,
comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
}
@@ -137,8 +134,7 @@
}
TEST_F(DefaultFieldComparatorTest, BooleanComparison) {
- const FieldDescriptor* field =
- descriptor_->FindFieldByName("optional_bool");
+ const FieldDescriptor* field = descriptor_->FindFieldByName("optional_bool");
message_1_.set_optional_bool(true);
message_2_.set_optional_bool(true);
@@ -189,22 +185,22 @@
message_1_.set_optional_double(0.1);
message_2_.set_optional_double(0.1);
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
message_2_.set_optional_float(0.2f);
message_2_.set_optional_double(0.2);
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
}
TEST_F(DefaultFieldComparatorTest, FloatingPointComparisonApproximate) {
@@ -229,21 +225,21 @@
// DefaultFieldComparator's default float comparison mode is EXACT.
ASSERT_EQ(DefaultFieldComparator::EXACT, comparator_.float_comparison());
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
comparator_.set_float_comparison(DefaultFieldComparator::APPROXIMATE);
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
}
TEST_F(DefaultFieldComparatorTest, FloatingPointComparisonTreatNaNsAsEqual) {
@@ -261,36 +257,36 @@
// treating NaNs as different.
ASSERT_EQ(DefaultFieldComparator::EXACT, comparator_.float_comparison());
ASSERT_EQ(false, comparator_.treat_nan_as_equal());
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
comparator_.set_float_comparison(DefaultFieldComparator::APPROXIMATE);
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
comparator_.set_treat_nan_as_equal(true);
ASSERT_EQ(true, comparator_.treat_nan_as_equal());
comparator_.set_float_comparison(DefaultFieldComparator::EXACT);
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
comparator_.set_float_comparison(DefaultFieldComparator::APPROXIMATE);
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
}
TEST_F(DefaultFieldComparatorTest,
@@ -306,62 +302,62 @@
message_2_.set_optional_double(109.9);
comparator_.set_float_comparison(DefaultFieldComparator::APPROXIMATE);
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
// Should fail since the fraction is too low.
comparator_.SetFractionAndMargin(field_float, 0.01, 0.0);
comparator_.SetFractionAndMargin(field_double, 0.01, 0.0);
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
// Should fail since the margin is too low.
comparator_.SetFractionAndMargin(field_float, 0.0, 9.0);
comparator_.SetFractionAndMargin(field_double, 0.0, 9.0);
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
// Should succeed since the fraction is high enough.
comparator_.SetFractionAndMargin(field_float, 0.2, 0.0);
comparator_.SetFractionAndMargin(field_double, 0.2, 0.0);
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
// Should succeed since the margin is high enough.
comparator_.SetFractionAndMargin(field_float, 0.0, 10.0);
comparator_.SetFractionAndMargin(field_double, 0.0, 10.0);
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
// Setting values for one of the fields should not affect the other.
comparator_.SetFractionAndMargin(field_double, 0.0, 0.0);
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
// +inf should be equal even though they are not technically within margin or
// fraction.
@@ -371,12 +367,12 @@
message_2_.set_optional_double(std::numeric_limits<double>::infinity());
comparator_.SetFractionAndMargin(field_float, 0.0, 0.0);
comparator_.SetFractionAndMargin(field_double, 0.0, 0.0);
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
// -inf should be equal even though they are not technically within margin or
// fraction.
@@ -386,12 +382,12 @@
message_2_.set_optional_double(-std::numeric_limits<double>::infinity());
comparator_.SetFractionAndMargin(field_float, 0.0, 0.0);
comparator_.SetFractionAndMargin(field_double, 0.0, 0.0);
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
}
TEST_F(DefaultFieldComparatorTest,
@@ -407,23 +403,23 @@
message_2_.set_optional_double(109.9);
comparator_.set_float_comparison(DefaultFieldComparator::APPROXIMATE);
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
// Set default fraction and margin.
comparator_.SetDefaultFractionAndMargin(0.01, 0.0);
// Float comparisons should fail since the fraction is too low.
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
// Set field-specific fraction and margin for one field (field_float) but not
// the other (field_double)
@@ -431,37 +427,37 @@
// The field with the override should succeed, since its field-specific
// fraction is high enough.
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
// The field with no override should fail, since the default fraction is too
// low
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
// Set the default fraction and margin high enough so that fields that use
// the default should succeed
comparator_.SetDefaultFractionAndMargin(0.2, 0.0);
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
// The field with an override should still be OK
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
// Set fraction and margin for the field with an override to be too low
comparator_.SetFractionAndMargin(field_float, 0.01, 0.0);
// Now our default is high enough but field_float's override is too low.
- EXPECT_EQ(FieldComparator::DIFFERENT,
- comparator_.Compare(message_1_, message_2_,
- field_float, -1, -1, NULL));
- EXPECT_EQ(FieldComparator::SAME,
- comparator_.Compare(message_1_, message_2_,
- field_double, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::DIFFERENT,
+ comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
+ EXPECT_EQ(
+ FieldComparator::SAME,
+ comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
}
// Simple test checking whether we compare values at correct indices.
diff --git a/src/google/protobuf/util/field_mask_util.cc b/src/google/protobuf/util/field_mask_util.cc
index 11f62ba..c4b2758 100644
--- a/src/google/protobuf/util/field_mask_util.cc
+++ b/src/google/protobuf/util/field_mask_util.cc
@@ -34,6 +34,8 @@
#include <google/protobuf/stubs/map_util.h>
+#include <google/protobuf/port_def.inc>
+
namespace google {
namespace protobuf {
namespace util {
@@ -160,8 +162,8 @@
return true;
}
-void FieldMaskUtil::GetFieldMaskForAllFields(
- const Descriptor* descriptor, FieldMask* out) {
+void FieldMaskUtil::GetFieldMaskForAllFields(const Descriptor* descriptor,
+ FieldMask* out) {
for (int i = 0; i < descriptor->field_count(); ++i) {
out->add_paths(descriptor->field(i)->name());
}
@@ -548,8 +550,8 @@
}
}
-void FieldMaskTree::AddRequiredFieldPath(
- Node* node, const Descriptor* descriptor) {
+void FieldMaskTree::AddRequiredFieldPath(Node* node,
+ const Descriptor* descriptor) {
const int32 field_count = descriptor->field_count();
for (int index = 0; index < field_count; ++index) {
const FieldDescriptor* field = descriptor->field(index);
@@ -559,7 +561,7 @@
if (child == nullptr) {
// Add required field path to the tree
child = new Node();
- } else if (child->children.empty()){
+ } else if (child->children.empty()) {
// If the required field is in the tree and does not have any children,
// do nothing.
continue;
diff --git a/src/google/protobuf/util/field_mask_util.h b/src/google/protobuf/util/field_mask_util.h
index 7031442..3e7a93e 100644
--- a/src/google/protobuf/util/field_mask_util.h
+++ b/src/google/protobuf/util/field_mask_util.h
@@ -35,8 +35,8 @@
#include <string>
-#include <google/protobuf/descriptor.h>
#include <google/protobuf/field_mask.pb.h>
+#include <google/protobuf/descriptor.h>
#include <google/protobuf/stubs/stringpiece.h>
#include <google/protobuf/port_def.inc>
@@ -134,9 +134,8 @@
}
// This flavor takes the protobuf type descriptor as an argument.
// Useful when the type is not known at compile time.
- static void Subtract(const Descriptor* descriptor,
- const FieldMask& mask1, const FieldMask& mask2,
- FieldMask* out);
+ static void Subtract(const Descriptor* descriptor, const FieldMask& mask1,
+ const FieldMask& mask2, FieldMask* out);
// Returns true if path is covered by the given FieldMask. Note that path
// "foo.bar" covers all paths like "foo.bar.baz", "foo.bar.quz.x", etc.
@@ -177,7 +176,8 @@
// Note that the input can contain characters not allowed in C identifiers.
// For example, "foo_bar,baz_quz" will be converted to "fooBar,bazQuz"
// successfully.
- static bool SnakeCaseToCamelCase(StringPiece input, std::string* output);
+ static bool SnakeCaseToCamelCase(StringPiece input,
+ std::string* output);
// Converts a field name from camelCase to snake_case:
// 1. Every uppercase letter is converted to lowercase with a additional
// preceding "-".
@@ -190,7 +190,8 @@
// Note that the input can contain characters not allowed in C identifiers.
// For example, "fooBar,bazQuz" will be converted to "foo_bar,baz_quz"
// successfully.
- static bool CamelCaseToSnakeCase(StringPiece input, std::string* output);
+ static bool CamelCaseToSnakeCase(StringPiece input,
+ std::string* output);
};
class PROTOBUF_EXPORT FieldMaskUtil::MergeOptions {
@@ -223,15 +224,12 @@
class PROTOBUF_EXPORT FieldMaskUtil::TrimOptions {
public:
- TrimOptions()
- : keep_required_fields_(false) {}
+ TrimOptions() : keep_required_fields_(false) {}
// When trimming message fields, the default behavior is to trim required
// fields of the present message if they are not specified in the field mask.
// If you instead want to keep required fields of the present message even
- // they are not speicifed in the field mask, set this flag to true.
- void set_keep_required_fields(bool value) {
- keep_required_fields_ = value;
- }
+ // they are not specified in the field mask, set this flag to true.
+ void set_keep_required_fields(bool value) { keep_required_fields_ = value; }
bool keep_required_fields() const { return keep_required_fields_; }
private:
diff --git a/src/google/protobuf/util/field_mask_util_test.cc b/src/google/protobuf/util/field_mask_util_test.cc
index 1481c17..401a56a 100644
--- a/src/google/protobuf/util/field_mask_util_test.cc
+++ b/src/google/protobuf/util/field_mask_util_test.cc
@@ -35,8 +35,8 @@
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/field_mask.pb.h>
-#include <google/protobuf/unittest.pb.h>
#include <google/protobuf/test_util.h>
+#include <google/protobuf/unittest.pb.h>
#include <gtest/gtest.h>
namespace google {
@@ -113,11 +113,11 @@
} while (std::next_permutation(name.begin(), name.end()));
}
+using google::protobuf::FieldMask;
+using protobuf_unittest::NestedTestAllTypes;
using protobuf_unittest::TestAllTypes;
using protobuf_unittest::TestRequired;
using protobuf_unittest::TestRequiredMessage;
-using protobuf_unittest::NestedTestAllTypes;
-using google::protobuf::FieldMask;
TEST(FieldMaskUtilTest, StringFormat) {
FieldMask mask;
@@ -707,16 +707,14 @@
required_msg_2.clear_repeated_message();
required_msg_2.mutable_required_message()->clear_dummy2();
FieldMaskUtil::TrimMessage(mask, &trimmed_required_msg_2, options);
- EXPECT_EQ(trimmed_required_msg_2.DebugString(),
- required_msg_2.DebugString());
+ EXPECT_EQ(trimmed_required_msg_2.DebugString(), required_msg_2.DebugString());
FieldMaskUtil::FromString("required_message", &mask);
required_msg_2.mutable_required_message()->set_dummy2(7890);
trimmed_required_msg_2.mutable_required_message()->set_dummy2(7890);
required_msg_2.clear_optional_message();
FieldMaskUtil::TrimMessage(mask, &trimmed_required_msg_2, options);
- EXPECT_EQ(trimmed_required_msg_2.DebugString(),
- required_msg_2.DebugString());
+ EXPECT_EQ(trimmed_required_msg_2.DebugString(), required_msg_2.DebugString());
// Test trim required message with keep_required_fields is set false.
FieldMaskUtil::FromString("required_message.dummy2", &mask);
@@ -725,8 +723,7 @@
required_msg_2.mutable_required_message()->clear_c();
options.set_keep_required_fields(false);
FieldMaskUtil::TrimMessage(mask, &trimmed_required_msg_2, options);
- EXPECT_EQ(trimmed_required_msg_2.DebugString(),
- required_msg_2.DebugString());
+ EXPECT_EQ(trimmed_required_msg_2.DebugString(), required_msg_2.DebugString());
// Verify that trimming an empty message has no effect. In particular, fields
// mentioned in the field mask should not be created or changed.
diff --git a/src/google/protobuf/util/internal/datapiece.cc b/src/google/protobuf/util/internal/datapiece.cc
index be47454..55af434 100644
--- a/src/google/protobuf/util/internal/datapiece.cc
+++ b/src/google/protobuf/util/internal/datapiece.cc
@@ -47,9 +47,9 @@
;
;
;
-using util::error::Code;
using util::Status;
using util::StatusOr;
+using util::error::Code;
namespace {
diff --git a/src/google/protobuf/util/internal/default_value_objectwriter.cc b/src/google/protobuf/util/internal/default_value_objectwriter.cc
index 3d7f27c..6c3b58b 100644
--- a/src/google/protobuf/util/internal/default_value_objectwriter.cc
+++ b/src/google/protobuf/util/internal/default_value_objectwriter.cc
@@ -481,7 +481,9 @@
case google::protobuf::Field_Kind_TYPE_ENUM: {
return FindEnumDefault(field, typeinfo, use_ints_for_enums);
}
- default: { return DataPiece::NullData(); }
+ default: {
+ return DataPiece::NullData();
+ }
}
}
diff --git a/src/google/protobuf/util/internal/json_escaping.cc b/src/google/protobuf/util/internal/json_escaping.cc
index d167359..5347c7b 100644
--- a/src/google/protobuf/util/internal/json_escaping.cc
+++ b/src/google/protobuf/util/internal/json_escaping.cc
@@ -50,39 +50,30 @@
// kCommonEscapes[ch] is the escaped string of ch, if escaping is needed;
// or an empty string, if escaping is not needed.
static const char kCommonEscapes[160][7] = {
- // C0 (ASCII and derivatives) control characters
- "\\u0000", "\\u0001", "\\u0002", "\\u0003", // 0x00
- "\\u0004", "\\u0005", "\\u0006", "\\u0007",
- "\\b", "\\t", "\\n", "\\u000b",
- "\\f", "\\r", "\\u000e", "\\u000f",
- "\\u0010", "\\u0011", "\\u0012", "\\u0013", // 0x10
- "\\u0014", "\\u0015", "\\u0016", "\\u0017",
- "\\u0018", "\\u0019", "\\u001a", "\\u001b",
- "\\u001c", "\\u001d", "\\u001e", "\\u001f",
- // Escaping of " and \ are required by www.json.org string definition.
- // Escaping of < and > are required for HTML security.
- "", "", "\\\"", "", "", "", "", "", // 0x20
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "", // 0x30
- "", "", "", "", "\\u003c", "", "\\u003e", "",
- "", "", "", "", "", "", "", "", // 0x40
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "", // 0x50
- "", "", "", "", "\\\\", "", "", "",
- "", "", "", "", "", "", "", "", // 0x60
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "", // 0x70
- "", "", "", "", "", "", "", "\\u007f",
- // C1 (ISO 8859 and Unicode) extended control characters
- "\\u0080", "\\u0081", "\\u0082", "\\u0083", // 0x80
- "\\u0084", "\\u0085", "\\u0086", "\\u0087",
- "\\u0088", "\\u0089", "\\u008a", "\\u008b",
- "\\u008c", "\\u008d", "\\u008e", "\\u008f",
- "\\u0090", "\\u0091", "\\u0092", "\\u0093", // 0x90
- "\\u0094", "\\u0095", "\\u0096", "\\u0097",
- "\\u0098", "\\u0099", "\\u009a", "\\u009b",
- "\\u009c", "\\u009d", "\\u009e", "\\u009f"
-};
+ // C0 (ASCII and derivatives) control characters
+ "\\u0000", "\\u0001", "\\u0002", "\\u0003", // 0x00
+ "\\u0004", "\\u0005", "\\u0006", "\\u0007", "\\b", "\\t", "\\n", "\\u000b",
+ "\\f", "\\r", "\\u000e", "\\u000f", "\\u0010", "\\u0011", "\\u0012",
+ "\\u0013", // 0x10
+ "\\u0014", "\\u0015", "\\u0016", "\\u0017", "\\u0018", "\\u0019", "\\u001a",
+ "\\u001b", "\\u001c", "\\u001d", "\\u001e", "\\u001f",
+ // Escaping of " and \ are required by www.json.org string definition.
+ // Escaping of < and > are required for HTML security.
+ "", "", "\\\"", "", "", "", "", "", // 0x20
+ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", // 0x30
+ "", "", "", "", "\\u003c", "", "\\u003e", "", "", "", "", "", "", "", "",
+ "", // 0x40
+ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", // 0x50
+ "", "", "", "", "\\\\", "", "", "", "", "", "", "", "", "", "", "", // 0x60
+ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", // 0x70
+ "", "", "", "", "", "", "", "\\u007f",
+ // C1 (ISO 8859 and Unicode) extended control characters
+ "\\u0080", "\\u0081", "\\u0082", "\\u0083", // 0x80
+ "\\u0084", "\\u0085", "\\u0086", "\\u0087", "\\u0088", "\\u0089", "\\u008a",
+ "\\u008b", "\\u008c", "\\u008d", "\\u008e", "\\u008f", "\\u0090", "\\u0091",
+ "\\u0092", "\\u0093", // 0x90
+ "\\u0094", "\\u0095", "\\u0096", "\\u0097", "\\u0098", "\\u0099", "\\u009a",
+ "\\u009b", "\\u009c", "\\u009d", "\\u009e", "\\u009f"};
// Determines if the given char value is a unicode surrogate code unit (either
// high-surrogate or low-surrogate).
@@ -102,9 +93,9 @@
// Returns the low surrogate for the given unicode code point. The result is
// meaningless if the given code point is not a supplementary character.
inline uint16 ToLowSurrogate(uint32 cp) {
- return (cp & (JsonEscaping::kMaxLowSurrogate
- - JsonEscaping::kMinLowSurrogate))
- + JsonEscaping::kMinLowSurrogate;
+ return (cp &
+ (JsonEscaping::kMaxLowSurrogate - JsonEscaping::kMinLowSurrogate)) +
+ JsonEscaping::kMinLowSurrogate;
}
// Returns the high surrogate for the given unicode code point. The result is
@@ -328,10 +319,10 @@
ok = ReadCodePoint(str, i, &cp, &num_left, &num_read);
if (num_left > 0 || !ok) break; // case iii or iv
escaped = EscapeCodePoint(cp, buffer, cp_was_split);
- if (!escaped.empty()) break; // case i or ii
+ if (!escaped.empty()) break; // case i or ii
i += num_read;
num_read = 0;
- } while (i < str.length()); // case iv
+ } while (i < str.length()); // case iv
// First copy the un-escaped prefix, if any, to the output ByteSink.
if (i > 0) input->CopyTo(output, i);
if (num_read > 0) input->Skip(num_read);
diff --git a/src/google/protobuf/util/internal/json_stream_parser_test.cc b/src/google/protobuf/util/internal/json_stream_parser_test.cc
index d0980f9..7916085 100644
--- a/src/google/protobuf/util/internal/json_stream_parser_test.cc
+++ b/src/google/protobuf/util/internal/json_stream_parser_test.cc
@@ -118,7 +118,7 @@
result = parser.FinishParse();
}
}
- if (result.ok()){
+ if (result.ok()) {
EXPECT_EQ(parser.recursion_depth(), 0);
}
return result;
@@ -138,8 +138,7 @@
void DoErrorTest(StringPiece json, int split,
StringPiece error_prefix, bool coerce_utf8 = false,
bool allow_empty_null = false) {
- util::Status result =
- RunTest(json, split, coerce_utf8, allow_empty_null);
+ util::Status result = RunTest(json, split, coerce_utf8, allow_empty_null);
EXPECT_EQ(util::error::INVALID_ARGUMENT, result.code());
StringPiece error_message(result.error_message());
EXPECT_EQ(error_prefix, error_message.substr(0, error_prefix.size()));
diff --git a/src/google/protobuf/util/internal/proto_writer.cc b/src/google/protobuf/util/internal/proto_writer.cc
index 222ffc3..74fe0f4 100644
--- a/src/google/protobuf/util/internal/proto_writer.cc
+++ b/src/google/protobuf/util/internal/proto_writer.cc
@@ -313,10 +313,10 @@
typeinfo_(this->parent()->typeinfo_),
proto3_(type.syntax() == google::protobuf::SYNTAX_PROTO3),
type_(type),
- size_index_(
- !is_list && field->kind() == google::protobuf::Field_Kind_TYPE_MESSAGE
- ? ow_->size_insert_.size()
- : -1),
+ size_index_(!is_list && field->kind() ==
+ google::protobuf::Field_Kind_TYPE_MESSAGE
+ ? ow_->size_insert_.size()
+ : -1),
array_index_(is_list ? 0 : -1),
// oneof_indices_ values are 1-indexed (0 means not present).
oneof_indices_(type_.oneofs_size() + 1) {
diff --git a/src/google/protobuf/util/internal/protostream_objectsource.cc b/src/google/protobuf/util/internal/protostream_objectsource.cc
index 7accf05..a4e7f34 100644
--- a/src/google/protobuf/util/internal/protostream_objectsource.cc
+++ b/src/google/protobuf/util/internal/protostream_objectsource.cc
@@ -64,7 +64,7 @@
namespace error {
using util::error::Code;
using util::error::INTERNAL;
-}
+} // namespace error
namespace converter {
using ::PROTOBUF_NAMESPACE_ID::internal::WireFormat;
using ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite;
diff --git a/src/google/protobuf/util/internal/protostream_objectsource.h b/src/google/protobuf/util/internal/protostream_objectsource.h
index 804f6e6..af51a27 100644
--- a/src/google/protobuf/util/internal/protostream_objectsource.h
+++ b/src/google/protobuf/util/internal/protostream_objectsource.h
@@ -37,9 +37,9 @@
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/type.pb.h>
+#include <google/protobuf/util/internal/type_info.h>
#include <google/protobuf/util/internal/object_source.h>
#include <google/protobuf/util/internal/object_writer.h>
-#include <google/protobuf/util/internal/type_info.h>
#include <google/protobuf/util/type_resolver.h>
#include <google/protobuf/stubs/stringpiece.h>
#include <google/protobuf/stubs/hash.h>
@@ -175,10 +175,9 @@
// Renders a NWP map.
// Returns the next tag after reading all map entries. The caller should use
// this tag before reading more tags from the stream.
- util::StatusOr<uint32>
- RenderMap(const google::protobuf::Field* field,
- StringPiece name, uint32 list_tag,
- ObjectWriter* ow) const;
+ util::StatusOr<uint32> RenderMap(const google::protobuf::Field* field,
+ StringPiece name, uint32 list_tag,
+ ObjectWriter* ow) const;
// Renders a packed repeating field. A packed field is stored as:
// {tag length item1 item2 item3} instead of the less efficient
diff --git a/src/google/protobuf/util/internal/protostream_objectsource_test.cc b/src/google/protobuf/util/internal/protostream_objectsource_test.cc
index 686aa08..dc2875a 100644
--- a/src/google/protobuf/util/internal/protostream_objectsource_test.cc
+++ b/src/google/protobuf/util/internal/protostream_objectsource_test.cc
@@ -57,6 +57,8 @@
namespace util {
namespace converter {
+using io::ArrayInputStream;
+using io::CodedInputStream;
using proto_util_converter::testing::AnyM;
using proto_util_converter::testing::AnyOut;
using proto_util_converter::testing::Author;
@@ -75,8 +77,6 @@
using proto_util_converter::testing::Proto3Message;
using proto_util_converter::testing::StructType;
using proto_util_converter::testing::TimestampDuration;
-using io::ArrayInputStream;
-using io::CodedInputStream;
using ::testing::_;
using util::Status;
diff --git a/src/google/protobuf/util/internal/protostream_objectwriter.cc b/src/google/protobuf/util/internal/protostream_objectwriter.cc
index a3c3065..7865f78 100644
--- a/src/google/protobuf/util/internal/protostream_objectwriter.cc
+++ b/src/google/protobuf/util/internal/protostream_objectwriter.cc
@@ -57,10 +57,10 @@
namespace converter {
using ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite;
+using std::placeholders::_1;
using util::Status;
using util::StatusOr;
using util::error::INVALID_ARGUMENT;
-using std::placeholders::_1;
ProtoStreamObjectWriter::ProtoStreamObjectWriter(
@@ -359,9 +359,9 @@
// Create our object writer and initialize it with the first StartObject
// call.
- ow_.reset(new ProtoStreamObjectWriter(
- parent_->typeinfo(), *type, &output_, parent_->listener(),
- parent_->options_));
+ ow_.reset(new ProtoStreamObjectWriter(parent_->typeinfo(), *type, &output_,
+ parent_->listener(),
+ parent_->options_));
// Don't call StartObject() for well-known types yet. Depending on the
// type of actual data, we may not need to call StartObject(). For
@@ -985,9 +985,9 @@
data.ValueAsStringOrDefault("")));
}
-// TODO(tsun): figure out how to do proto descriptor based snake case
-// conversions as much as possible. Because ToSnakeCase sometimes returns the
-// wrong value.
+ // TODO(tsun): figure out how to do proto descriptor based snake case
+ // conversions as much as possible. Because ToSnakeCase sometimes returns the
+ // wrong value.
return DecodeCompactFieldMaskPaths(data.str(),
std::bind(&RenderOneFieldPath, ow, _1));
}
diff --git a/src/google/protobuf/util/internal/protostream_objectwriter_test.cc b/src/google/protobuf/util/internal/protostream_objectwriter_test.cc
index 5eda41c..006e85b 100644
--- a/src/google/protobuf/util/internal/protostream_objectwriter_test.cc
+++ b/src/google/protobuf/util/internal/protostream_objectwriter_test.cc
@@ -91,9 +91,9 @@
} // namespace
#if __cplusplus >= 201103L
- using std::get;
+using std::get;
#else
- using std::tr1::get;
+using std::tr1::get;
#endif
class BaseProtoStreamObjectWriterTest
@@ -183,9 +183,7 @@
ProtoStreamObjectWriterTest()
: BaseProtoStreamObjectWriterTest(Book::descriptor()) {}
- void ResetProtoWriter() {
- ResetTypeInfo(Book::descriptor());
- }
+ void ResetProtoWriter() { ResetTypeInfo(Book::descriptor()); }
virtual ~ProtoStreamObjectWriterTest() {}
};
@@ -1024,9 +1022,7 @@
expected.set_enum_value(static_cast<Proto3Message::NestedEnum>(12345));
EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
- ow_->StartObject("")
- ->RenderInt32("enumValue", 12345)
- ->EndObject();
+ ow_->StartObject("")->RenderInt32("enumValue", 12345)->EndObject();
CheckOutput(expected);
}
diff --git a/src/google/protobuf/util/internal/type_info_test_helper.cc b/src/google/protobuf/util/internal/type_info_test_helper.cc
index 9106f11..cc2dcd7 100644
--- a/src/google/protobuf/util/internal/type_info_test_helper.cc
+++ b/src/google/protobuf/util/internal/type_info_test_helper.cc
@@ -33,7 +33,6 @@
#include <memory>
#include <vector>
-
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/descriptor.h>
diff --git a/src/google/protobuf/util/json_util.cc b/src/google/protobuf/util/json_util.cc
index ed50b1d..52ce331 100644
--- a/src/google/protobuf/util/json_util.cc
+++ b/src/google/protobuf/util/json_util.cc
@@ -98,8 +98,8 @@
converter::JsonObjectWriter json_writer(options.add_whitespace ? " " : "",
&out_stream);
if (options.always_print_primitive_fields) {
- converter::DefaultValueObjectWriter default_value_writer(
- resolver, type, &json_writer);
+ converter::DefaultValueObjectWriter default_value_writer(resolver, type,
+ &json_writer);
default_value_writer.set_preserve_proto_field_names(
options.preserve_proto_field_names);
default_value_writer.set_print_enums_as_ints(
@@ -129,9 +129,9 @@
util::Status GetStatus() { return status_; }
- virtual void InvalidName(const converter::LocationTrackerInterface& loc,
- StringPiece unknown_name,
- StringPiece message) {
+ void InvalidName(const converter::LocationTrackerInterface& loc,
+ StringPiece unknown_name,
+ StringPiece message) override {
std::string loc_string = GetLocString(loc);
if (!loc_string.empty()) {
loc_string.append(" ");
@@ -141,17 +141,17 @@
StrCat(loc_string, unknown_name, ": ", message));
}
- virtual void InvalidValue(const converter::LocationTrackerInterface& loc,
- StringPiece type_name,
- StringPiece value) {
+ void InvalidValue(const converter::LocationTrackerInterface& loc,
+ StringPiece type_name,
+ StringPiece value) override {
status_ = util::Status(
util::error::INVALID_ARGUMENT,
StrCat(GetLocString(loc), ": invalid value ", string(value),
" for type ", string(type_name)));
}
- virtual void MissingField(const converter::LocationTrackerInterface& loc,
- StringPiece missing_name) {
+ void MissingField(const converter::LocationTrackerInterface& loc,
+ StringPiece missing_name) override {
status_ = util::Status(util::error::INVALID_ARGUMENT,
StrCat(GetLocString(loc), ": missing field ",
std::string(missing_name)));
@@ -188,9 +188,8 @@
options.ignore_unknown_fields;
proto_writer_options.case_insensitive_enum_parsing =
options.case_insensitive_enum_parsing;
- converter::ProtoStreamObjectWriter proto_writer(resolver, type, &sink,
- &listener,
- proto_writer_options);
+ converter::ProtoStreamObjectWriter proto_writer(
+ resolver, type, &sink, &listener, proto_writer_options);
converter::JsonStreamParser parser(&proto_writer);
const void* buffer;
@@ -212,8 +211,8 @@
const JsonParseOptions& options) {
io::ArrayInputStream input_stream(json_input.data(), json_input.size());
io::StringOutputStream output_stream(binary_output);
- return JsonToBinaryStream(
- resolver, type_url, &input_stream, &output_stream, options);
+ return JsonToBinaryStream(resolver, type_url, &input_stream, &output_stream,
+ options);
}
namespace {
@@ -265,8 +264,8 @@
? GetGeneratedTypeResolver()
: NewTypeResolverForDescriptorPool(kTypeUrlPrefix, pool);
std::string binary;
- util::Status result = JsonToBinaryString(
- resolver, GetTypeUrl(*message), input, &binary, options);
+ util::Status result = JsonToBinaryString(resolver, GetTypeUrl(*message),
+ input, &binary, options);
if (result.ok() && !message->ParseFromString(binary)) {
result =
util::Status(util::error::INVALID_ARGUMENT,
diff --git a/src/google/protobuf/util/json_util.h b/src/google/protobuf/util/json_util.h
index 2e40615..39b6b5a 100644
--- a/src/google/protobuf/util/json_util.h
+++ b/src/google/protobuf/util/json_util.h
@@ -133,8 +133,9 @@
}
PROTOBUF_EXPORT util::Status BinaryToJsonString(
- TypeResolver* resolver, const std::string& type_url, const std::string& binary_input,
- std::string* json_output, const JsonPrintOptions& options);
+ TypeResolver* resolver, const std::string& type_url,
+ const std::string& binary_input, std::string* json_output,
+ const JsonPrintOptions& options);
inline util::Status BinaryToJsonString(TypeResolver* resolver,
const std::string& type_url,
@@ -155,8 +156,7 @@
io::ZeroCopyOutputStream* binary_output, const JsonParseOptions& options);
inline util::Status JsonToBinaryStream(
- TypeResolver* resolver,
- const std::string& type_url,
+ TypeResolver* resolver, const std::string& type_url,
io::ZeroCopyInputStream* json_input,
io::ZeroCopyOutputStream* binary_output) {
return JsonToBinaryStream(resolver, type_url, json_input, binary_output,
diff --git a/src/google/protobuf/util/json_util_test.cc b/src/google/protobuf/util/json_util_test.cc
index dedcff8..9f60543 100644
--- a/src/google/protobuf/util/json_util_test.cc
+++ b/src/google/protobuf/util/json_util_test.cc
@@ -49,14 +49,14 @@
namespace util {
namespace {
-using proto_util_converter::testing::MapIn;
using proto3::BAR;
using proto3::FOO;
+using proto3::TestAny;
using proto3::TestEnumValue;
using proto3::TestMap;
using proto3::TestMessage;
using proto3::TestOneof;
-using proto3::TestAny;
+using proto_util_converter::testing::MapIn;
static const char kTypeUrlPrefix[] = "type.googleapis.com";
@@ -67,8 +67,7 @@
// tests are contained in the //net/proto2/util/converter directory.
class JsonUtilTest : public ::testing::Test {
protected:
- JsonUtilTest() {
- }
+ JsonUtilTest() {}
std::string ToJson(const Message& message, const JsonPrintOptions& options) {
std::string result;
@@ -339,8 +338,9 @@
DescriptorPool pool(&database);
// A dynamic version of the test proto.
DynamicMessageFactory factory;
- std::unique_ptr<Message> message(factory.GetPrototype(
- pool.FindMessageTypeByName("proto3.TestMessage"))->New());
+ std::unique_ptr<Message> message(
+ factory.GetPrototype(pool.FindMessageTypeByName("proto3.TestMessage"))
+ ->New());
EXPECT_TRUE(FromJson(input, message.get()));
// Convert to generated message for easy inspection.
@@ -498,7 +498,9 @@
class SegmentedZeroCopyOutputStream : public io::ZeroCopyOutputStream {
public:
explicit SegmentedZeroCopyOutputStream(std::list<Segment> segments)
- : segments_(segments), last_segment_(static_cast<char*>(NULL), 0), byte_count_(0) {}
+ : segments_(segments),
+ last_segment_(static_cast<char*>(NULL), 0),
+ byte_count_(0) {}
virtual bool Next(void** buffer, int* length) {
if (segments_.empty()) {
@@ -627,8 +629,8 @@
TypeResolver* resolver = NewTypeResolverForDescriptorPool(
"type.googleapis.com", DescriptorPool::generated_pool());
- auto result_status = util::JsonToBinaryStream(
- resolver, message_type, &input_stream, &output_stream);
+ auto result_status = util::JsonToBinaryStream(resolver, message_type,
+ &input_stream, &output_stream);
delete resolver;
diff --git a/src/google/protobuf/util/message_differencer.cc b/src/google/protobuf/util/message_differencer.cc
index 57e9987..92d113d 100644
--- a/src/google/protobuf/util/message_differencer.cc
+++ b/src/google/protobuf/util/message_differencer.cc
@@ -53,6 +53,8 @@
#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/port_def.inc>
+
namespace google {
namespace protobuf {
@@ -72,19 +74,25 @@
void ReportAdded(
const google::protobuf::Message& message1, const google::protobuf::Message& message2,
const std::vector<google::protobuf::util::MessageDifferencer::SpecificField>&
- field_path) override { ++num_diffs_; }
+ field_path) override {
+ ++num_diffs_;
+ }
// Report that a field has been deleted from Message1.
void ReportDeleted(
const google::protobuf::Message& message1, const google::protobuf::Message& message2,
const std::vector<google::protobuf::util::MessageDifferencer::SpecificField>&
- field_path) override { ++num_diffs_; }
+ field_path) override {
+ ++num_diffs_;
+ }
// Report that the value of a field has been modified.
void ReportModified(
const google::protobuf::Message& message1, const google::protobuf::Message& message2,
const std::vector<google::protobuf::util::MessageDifferencer::SpecificField>&
- field_path) override { ++num_diffs_; }
+ field_path) override {
+ ++num_diffs_;
+ }
private:
int32 num_diffs_;
@@ -101,17 +109,16 @@
MultipleFieldsMapKeyComparator(
MessageDifferencer* message_differencer,
const std::vector<std::vector<const FieldDescriptor*> >& key_field_paths)
- : message_differencer_(message_differencer),
- key_field_paths_(key_field_paths) {
+ : message_differencer_(message_differencer),
+ key_field_paths_(key_field_paths) {
GOOGLE_CHECK(!key_field_paths_.empty());
for (int i = 0; i < key_field_paths_.size(); ++i) {
GOOGLE_CHECK(!key_field_paths_[i].empty());
}
}
- MultipleFieldsMapKeyComparator(
- MessageDifferencer* message_differencer,
- const FieldDescriptor* key)
- : message_differencer_(message_differencer) {
+ MultipleFieldsMapKeyComparator(MessageDifferencer* message_differencer,
+ const FieldDescriptor* key)
+ : message_differencer_(message_differencer) {
std::vector<const FieldDescriptor*> key_field_path;
key_field_path.push_back(key);
key_field_paths_.push_back(key_field_path);
@@ -129,8 +136,7 @@
private:
bool IsMatchInternal(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const std::vector<SpecificField>& parent_fields,
const std::vector<const FieldDescriptor*>& key_field_path,
int path_index) const {
@@ -139,12 +145,12 @@
if (path_index == key_field_path.size() - 1) {
if (field->is_repeated()) {
if (!message_differencer_->CompareRepeatedField(
- message1, message2, field, ¤t_parent_fields)) {
+ message1, message2, field, ¤t_parent_fields)) {
return false;
}
} else {
if (!message_differencer_->CompareFieldValueUsingParentFields(
- message1, message2, field, -1, -1, ¤t_parent_fields)) {
+ message1, message2, field, -1, -1, ¤t_parent_fields)) {
return false;
}
}
@@ -163,12 +169,10 @@
SpecificField specific_field;
specific_field.field = field;
current_parent_fields.push_back(specific_field);
- return IsMatchInternal(
- reflection1->GetMessage(message1, field),
- reflection2->GetMessage(message2, field),
- current_parent_fields,
- key_field_path,
- path_index + 1);
+ return IsMatchInternal(reflection1->GetMessage(message1, field),
+ reflection2->GetMessage(message2, field),
+ current_parent_fields, key_field_path,
+ path_index + 1);
}
}
MessageDifferencer* message_differencer_;
@@ -241,8 +245,7 @@
bool MessageDifferencer::ApproximatelyEquals(const Message& message1,
const Message& message2) {
MessageDifferencer differencer;
- differencer.set_float_comparison(
- MessageDifferencer::APPROXIMATE);
+ differencer.set_float_comparison(MessageDifferencer::APPROXIMATE);
return differencer.Compare(message1, message2);
}
@@ -291,18 +294,14 @@
message_field_comparison_ = comparison;
}
-void MessageDifferencer::set_scope(Scope scope) {
- scope_ = scope;
-}
+void MessageDifferencer::set_scope(Scope scope) { scope_ = scope; }
-MessageDifferencer::Scope MessageDifferencer::scope() {
- return scope_;
-}
+MessageDifferencer::Scope MessageDifferencer::scope() { return scope_; }
void MessageDifferencer::set_float_comparison(FloatComparison comparison) {
default_field_comparator_.set_float_comparison(
- comparison == EXACT ?
- DefaultFieldComparator::EXACT : DefaultFieldComparator::APPROXIMATE);
+ comparison == EXACT ? DefaultFieldComparator::EXACT
+ : DefaultFieldComparator::APPROXIMATE);
}
void MessageDifferencer::set_repeated_field_comparison(
@@ -313,23 +312,19 @@
void MessageDifferencer::CheckRepeatedFieldComparisons(
const FieldDescriptor* field,
const RepeatedFieldComparison& new_comparison) {
- GOOGLE_CHECK(field->is_repeated()) << "Field must be repeated: "
- << field->full_name();
+ GOOGLE_CHECK(field->is_repeated())
+ << "Field must be repeated: " << field->full_name();
const MapKeyComparator* key_comparator = GetMapKeyComparator(field);
GOOGLE_CHECK(key_comparator == NULL)
- << "Cannot treat this repeated field as both MAP and "
- << new_comparison
+ << "Cannot treat this repeated field as both MAP and " << new_comparison
<< " for"
<< " comparison. Field name is: " << field->full_name();
GOOGLE_CHECK(repeated_field_comparisons_.find(field) ==
- repeated_field_comparisons_.end() ||
+ repeated_field_comparisons_.end() ||
repeated_field_comparisons_[field] == new_comparison)
<< "Cannot treat the same field as both "
- << repeated_field_comparisons_[field]
- << " and "
- << new_comparison
- <<". Field name is: "
- << field->full_name();
+ << repeated_field_comparisons_[field] << " and " << new_comparison
+ << ". Field name is: " << field->full_name();
}
void MessageDifferencer::TreatAsSet(const FieldDescriptor* field) {
@@ -360,8 +355,7 @@
void MessageDifferencer::TreatAsMap(const FieldDescriptor* field,
const FieldDescriptor* key) {
GOOGLE_CHECK_EQ(FieldDescriptor::CPPTYPE_MESSAGE, field->cpp_type())
- << "Field has to be message type. Field name is: "
- << field->full_name();
+ << "Field has to be message type. Field name is: " << field->full_name();
GOOGLE_CHECK(key->containing_type() == field->message_type())
<< key->full_name()
<< " must be a direct subfield within the repeated field "
@@ -370,8 +364,7 @@
repeated_field_comparisons_.end())
<< "Cannot treat the same field as both "
<< repeated_field_comparisons_[field]
- << " and MAP. Field name is: "
- << field->full_name();
+ << " and MAP. Field name is: " << field->full_name();
MapKeyComparator* key_comparator =
new MultipleFieldsMapKeyComparator(this, key);
owned_key_comparators_.push_back(key_comparator);
@@ -393,11 +386,10 @@
void MessageDifferencer::TreatAsMapWithMultipleFieldPathsAsKey(
const FieldDescriptor* field,
const std::vector<std::vector<const FieldDescriptor*> >& key_field_paths) {
- GOOGLE_CHECK(field->is_repeated()) << "Field must be repeated: "
- << field->full_name();
+ GOOGLE_CHECK(field->is_repeated())
+ << "Field must be repeated: " << field->full_name();
GOOGLE_CHECK_EQ(FieldDescriptor::CPPTYPE_MESSAGE, field->cpp_type())
- << "Field has to be message type. Field name is: "
- << field->full_name();
+ << "Field has to be message type. Field name is: " << field->full_name();
for (int i = 0; i < key_field_paths.size(); ++i) {
const std::vector<const FieldDescriptor*>& key_field_path =
key_field_paths[i];
@@ -419,10 +411,9 @@
}
GOOGLE_CHECK(repeated_field_comparisons_.find(field) ==
repeated_field_comparisons_.end())
- << "Cannot treat the same field as both "
- << repeated_field_comparisons_[field]
- << " and MAP. Field name is: "
- << field->full_name();
+ << "Cannot treat the same field as both "
+ << repeated_field_comparisons_[field]
+ << " and MAP. Field name is: " << field->full_name();
MapKeyComparator* key_comparator =
new MultipleFieldsMapKeyComparator(this, key_field_paths);
owned_key_comparators_.push_back(key_comparator);
@@ -430,16 +421,14 @@
}
void MessageDifferencer::TreatAsMapUsingKeyComparator(
- const FieldDescriptor* field,
- const MapKeyComparator* key_comparator) {
- GOOGLE_CHECK(field->is_repeated()) << "Field must be repeated: "
- << field->full_name();
+ const FieldDescriptor* field, const MapKeyComparator* key_comparator) {
+ GOOGLE_CHECK(field->is_repeated())
+ << "Field must be repeated: " << field->full_name();
GOOGLE_CHECK(repeated_field_comparisons_.find(field) ==
repeated_field_comparisons_.end())
<< "Cannot treat the same field as both "
<< repeated_field_comparisons_[field]
- << " and MAP. Field name is: "
- << field->full_name();
+ << " and MAP. Field name is: " << field->full_name();
map_field_key_comparator_[field] = key_comparator;
}
@@ -510,8 +499,7 @@
}
bool MessageDifferencer::CompareWithFields(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const std::vector<const FieldDescriptor*>& message1_fields_arg,
const std::vector<const FieldDescriptor*>& message2_fields_arg) {
if (message1.GetDescriptor() != message2.GetDescriptor()) {
@@ -549,16 +537,14 @@
return result;
}
-bool MessageDifferencer::Compare(
- const Message& message1,
- const Message& message2,
- std::vector<SpecificField>* parent_fields) {
+bool MessageDifferencer::Compare(const Message& message1,
+ const Message& message2,
+ std::vector<SpecificField>* parent_fields) {
const Descriptor* descriptor1 = message1.GetDescriptor();
const Descriptor* descriptor2 = message2.GetDescriptor();
if (descriptor1 != descriptor2) {
GOOGLE_LOG(DFATAL) << "Comparison between two messages with different "
- << "descriptors. "
- << descriptor1->full_name() << " vs "
+ << "descriptors. " << descriptor1->full_name() << " vs "
<< descriptor2->full_name();
return false;
}
@@ -577,11 +563,6 @@
const Reflection* reflection1 = message1.GetReflection();
const Reflection* reflection2 = message2.GetReflection();
- std::vector<const FieldDescriptor*> message1_fields =
- RetrieveFields(message1, true);
- std::vector<const FieldDescriptor*> message2_fields =
- RetrieveFields(message2, false);
-
bool unknown_compare_result = true;
// Ignore unknown fields in EQUIVALENT mode
if (message_field_comparison_ != EQUIVALENT) {
@@ -589,9 +570,8 @@
&reflection1->GetUnknownFields(message1);
const UnknownFieldSet* unknown_field_set2 =
&reflection2->GetUnknownFields(message2);
- if (!CompareUnknownFields(message1, message2,
- *unknown_field_set1, *unknown_field_set2,
- parent_fields)) {
+ if (!CompareUnknownFields(message1, message2, *unknown_field_set1,
+ *unknown_field_set2, parent_fields)) {
if (reporter_ == NULL) {
return false;
};
@@ -599,6 +579,11 @@
}
}
+ std::vector<const FieldDescriptor*> message1_fields =
+ RetrieveFields(message1, true);
+ std::vector<const FieldDescriptor*> message2_fields =
+ RetrieveFields(message2, false);
+
return CompareRequestedFieldsUsingSettings(
message1, message2,
message1_fields, message2_fields,
@@ -751,8 +736,9 @@
if (reporter_ != NULL) {
assert(field1 != NULL);
- int count = field1->is_repeated() ?
- reflection1->FieldSize(message1, field1) : 1;
+ int count = field1->is_repeated()
+ ? reflection1->FieldSize(message1, field1)
+ : 1;
for (int i = 0; i < count; ++i) {
SpecificField specific_field;
@@ -791,8 +777,9 @@
}
if (reporter_ != NULL) {
- int count = field2->is_repeated() ?
- reflection2->FieldSize(message2, field2) : 1;
+ int count = field2->is_repeated()
+ ? reflection2->FieldSize(message2, field2)
+ : 1;
for (int i = 0; i < count; ++i) {
SpecificField specific_field;
@@ -837,8 +824,8 @@
bool fieldDifferent = false;
assert(field1 != NULL);
if (field1->is_repeated()) {
- fieldDifferent = !CompareRepeatedField(message1, message2, field1,
- parent_fields);
+ fieldDifferent =
+ !CompareRepeatedField(message1, message2, field1, parent_fields);
if (fieldDifferent) {
if (reporter_ == NULL) return false;
isDifferent = true;
@@ -881,9 +868,9 @@
Reporter* reporter, int index1, int index2) {
std::vector<SpecificField> current_parent_fields(parent_fields);
if (repeated_field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
- return CompareFieldValueUsingParentFields(
- *message1, *message2, repeated_field, index1, index2,
- ¤t_parent_fields);
+ return CompareFieldValueUsingParentFields(*message1, *message2,
+ repeated_field, index1, index2,
+ ¤t_parent_fields);
}
// Back up the Reporter and output_string_. They will be reset in the
// following code.
@@ -894,9 +881,9 @@
bool match;
if (key_comparator == NULL) {
- match = CompareFieldValueUsingParentFields(
- *message1, *message2, repeated_field, index1, index2,
- ¤t_parent_fields);
+ match = CompareFieldValueUsingParentFields(*message1, *message2,
+ repeated_field, index1, index2,
+ ¤t_parent_fields);
} else {
const Reflection* reflection1 = message1->GetReflection();
const Reflection* reflection2 = message2->GetReflection();
@@ -918,8 +905,7 @@
}
bool MessageDifferencer::CompareRepeatedField(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const FieldDescriptor* repeated_field,
std::vector<SpecificField>* parent_fields) {
// the input FieldDescriptor is guaranteed to be repeated field.
@@ -1048,8 +1034,7 @@
bool MessageDifferencer::CompareFieldValue(const Message& message1,
const Message& message2,
const FieldDescriptor* field,
- int index1,
- int index2) {
+ int index1, int index2) {
return CompareFieldValueUsingParentFields(message1, message2, field, index1,
index2, NULL);
}
@@ -1068,12 +1053,14 @@
// methods.
const Reflection* reflection1 = message1.GetReflection();
const Reflection* reflection2 = message2.GetReflection();
- const Message& m1 = field->is_repeated() ?
- reflection1->GetRepeatedMessage(message1, field, index1) :
- reflection1->GetMessage(message1, field);
- const Message& m2 = field->is_repeated() ?
- reflection2->GetRepeatedMessage(message2, field, index2) :
- reflection2->GetMessage(message2, field);
+ const Message& m1 =
+ field->is_repeated()
+ ? reflection1->GetRepeatedMessage(message1, field, index1)
+ : reflection1->GetMessage(message1, field);
+ const Message& m2 =
+ field->is_repeated()
+ ? reflection2->GetRepeatedMessage(message2, field, index2)
+ : reflection2->GetMessage(message2, field);
// parent_fields is used in calls to Reporter methods.
if (parent_fields != NULL) {
@@ -1134,12 +1121,11 @@
bool MessageDifferencer::IsTreatedAsSubset(const FieldDescriptor* field) {
return scope_ == PARTIAL &&
- (IsTreatedAsSet(field) || GetMapKeyComparator(field) != NULL);
+ (IsTreatedAsSet(field) || GetMapKeyComparator(field) != NULL);
}
bool MessageDifferencer::IsIgnored(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const FieldDescriptor* field,
const std::vector<SpecificField>& parent_fields) {
if (ignored_fields_.find(field) != ignored_fields_.end()) {
@@ -1282,8 +1268,13 @@
int index1 = 0;
int index2 = 0;
while (index1 < fields1.size() || index2 < fields2.size()) {
- enum { ADDITION, DELETION, MODIFICATION, COMPARE_GROUPS,
- NO_CHANGE } change_type;
+ enum {
+ ADDITION,
+ DELETION,
+ MODIFICATION,
+ COMPARE_GROUPS,
+ NO_CHANGE
+ } change_type;
// focus_field is the field we're currently reporting on. (In the case
// of a modification, it's the field on the left side.)
@@ -1292,7 +1283,7 @@
if (index2 == fields2.size() ||
(index1 < fields1.size() &&
- is_before(fields1[index1], fields2[index2]))) {
+ is_before(fields1[index1], fields2[index2]))) {
// fields1[index1] is not present in fields2.
change_type = DELETION;
focus_field = fields1[index1].second;
@@ -1414,10 +1405,9 @@
++index2;
break;
case COMPARE_GROUPS:
- if (!CompareUnknownFields(message1, message2,
- fields1[index1].second->group(),
- fields2[index2].second->group(),
- parent_field)) {
+ if (!CompareUnknownFields(
+ message1, message2, fields1[index1].second->group(),
+ fields2[index2].second->group(), parent_field)) {
if (reporter_ == NULL) return false;
is_different = true;
reporter_->ReportModified(message1, message2, *parent_field);
@@ -1461,6 +1451,7 @@
// If early_return is true, this method will return 0 immediately when it
// finds that not all nodes on the left side can be matched.
int FindMaximumMatch(bool early_return);
+
private:
// Determines whether the node on the left side of the bipartial graph
// matches the one on the right side.
@@ -1582,20 +1573,17 @@
bool success = true;
// Find potential match if this is a special repeated field.
- if (key_comparator != nullptr ||
- IsTreatedAsSet(repeated_field) ||
+ if (key_comparator != nullptr || IsTreatedAsSet(repeated_field) ||
IsTreatedAsSmartSet(repeated_field) ||
IsTreatedAsSmartList(repeated_field)) {
if (scope_ == PARTIAL) {
// When partial matching is enabled, Compare(a, b) && Compare(a, c)
// doesn't necessarily imply Compare(b, c). Therefore a naive greedy
// algorithm will fail to find a maximum matching.
- // Here we use the argumenting path algorithm.
- MaximumMatcher::NodeMatchCallback* callback =
- ::google::protobuf::NewPermanentCallback(
- this, &MessageDifferencer::IsMatch,
- repeated_field, key_comparator,
- &message1, &message2, parent_fields, nullptr);
+ // Here we use the augmenting path algorithm.
+ MaximumMatcher::NodeMatchCallback* callback = ::google::protobuf::NewPermanentCallback(
+ this, &MessageDifferencer::IsMatch, repeated_field, key_comparator,
+ &message1, &message2, parent_fields, nullptr);
MaximumMatcher matcher(count1, count2, callback, match_list1,
match_list2);
// If diff info is not needed, we should end the matching process as
@@ -1637,13 +1625,12 @@
if (is_treated_as_smart_set) {
num_diffs_reporter.Reset();
- match = IsMatch(repeated_field, key_comparator,
- &message1, &message2, parent_fields,
- &num_diffs_reporter, i, j);
+ match =
+ IsMatch(repeated_field, key_comparator, &message1, &message2,
+ parent_fields, &num_diffs_reporter, i, j);
} else {
- match = IsMatch(repeated_field, key_comparator,
- &message1, &message2, parent_fields,
- nullptr, i, j);
+ match = IsMatch(repeated_field, key_comparator, &message1,
+ &message2, parent_fields, nullptr, i, j);
}
if (is_treated_as_smart_set) {
@@ -1704,15 +1691,16 @@
const Message& message1, const Message& message2,
const FieldDescriptor* field, int index1, int index2,
const FieldContext* field_context) {
- FieldComparator* comparator = field_comparator_ != NULL ?
- field_comparator_ : &default_field_comparator_;
- return comparator->Compare(message1, message2, field,
- index1, index2, field_context);
+ FieldComparator* comparator = field_comparator_ != NULL
+ ? field_comparator_
+ : &default_field_comparator_;
+ return comparator->Compare(message1, message2, field, index1, index2,
+ field_context);
}
// ===========================================================================
-MessageDifferencer::Reporter::Reporter() { }
+MessageDifferencer::Reporter::Reporter() {}
MessageDifferencer::Reporter::~Reporter() {}
// ===========================================================================
@@ -1730,14 +1718,15 @@
// Note that the printer's delimiter is not used, because if we are given a
// printer, we don't know its delimiter.
MessageDifferencer::StreamReporter::StreamReporter(
- io::ZeroCopyOutputStream* output) : printer_(new io::Printer(output, '$')),
- delete_printer_(true),
- report_modified_aggregates_(false) { }
+ io::ZeroCopyOutputStream* output)
+ : printer_(new io::Printer(output, '$')),
+ delete_printer_(true),
+ report_modified_aggregates_(false) {}
-MessageDifferencer::StreamReporter::StreamReporter(
- io::Printer* printer) : printer_(printer),
- delete_printer_(false),
- report_modified_aggregates_(false) { }
+MessageDifferencer::StreamReporter::StreamReporter(io::Printer* printer)
+ : printer_(printer),
+ delete_printer_(false),
+ report_modified_aggregates_(false) {}
MessageDifferencer::StreamReporter::~StreamReporter() {
if (delete_printer_) delete printer_;
@@ -1754,8 +1743,7 @@
if (specific_field.field != NULL) {
if (specific_field.field->is_extension()) {
- printer_->Print("($name$)", "name",
- specific_field.field->full_name());
+ printer_->Print("($name$)", "name", specific_field.field->full_name());
} else {
printer_->PrintRaw(specific_field.field->name());
}
@@ -1782,10 +1770,9 @@
PrintPath(field_path, left_side);
}
-void MessageDifferencer::
-StreamReporter::PrintValue(const Message& message,
- const std::vector<SpecificField>& field_path,
- bool left_side) {
+void MessageDifferencer::StreamReporter::PrintValue(
+ const Message& message, const std::vector<SpecificField>& field_path,
+ bool left_side) {
const SpecificField& specific_field = field_path.back();
const FieldDescriptor* field = specific_field.field;
if (field != NULL) {
@@ -1793,9 +1780,10 @@
int index = left_side ? specific_field.index : specific_field.new_index;
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
const Reflection* reflection = message.GetReflection();
- const Message& field_message = field->is_repeated() ?
- reflection->GetRepeatedMessage(message, field, index) :
- reflection->GetMessage(message, field);
+ const Message& field_message =
+ field->is_repeated()
+ ? reflection->GetRepeatedMessage(message, field, index)
+ : reflection->GetMessage(message, field);
output = field_message.ShortDebugString();
if (output.empty()) {
printer_->Print("{ }");
@@ -1808,19 +1796,17 @@
}
} else {
const UnknownFieldSet* unknown_fields =
- (left_side ?
- specific_field.unknown_field_set1 :
- specific_field.unknown_field_set2);
- const UnknownField* unknown_field = &unknown_fields->field(
- left_side ?
- specific_field.unknown_field_index1 :
- specific_field.unknown_field_index2);
+ (left_side ? specific_field.unknown_field_set1
+ : specific_field.unknown_field_set2);
+ const UnknownField* unknown_field =
+ &unknown_fields->field(left_side ? specific_field.unknown_field_index1
+ : specific_field.unknown_field_index2);
PrintUnknownFieldValue(unknown_field);
}
}
-void MessageDifferencer::
-StreamReporter::PrintUnknownFieldValue(const UnknownField* unknown_field) {
+void MessageDifferencer::StreamReporter::PrintUnknownFieldValue(
+ const UnknownField* unknown_field) {
GOOGLE_CHECK(unknown_field != NULL) << " Cannot print NULL unknown_field.";
std::string output;
@@ -1837,8 +1823,8 @@
"0x", strings::Hex(unknown_field->fixed64(), strings::ZERO_PAD_16));
break;
case UnknownField::TYPE_LENGTH_DELIMITED:
- output = StringPrintf("\"%s\"",
- CEscape(unknown_field->length_delimited()).c_str());
+ output = StringPrintf(
+ "\"%s\"", CEscape(unknown_field->length_delimited()).c_str());
break;
case UnknownField::TYPE_GROUP:
// TODO(kenton): Print the contents of the group like we do for
@@ -1855,8 +1841,7 @@
}
void MessageDifferencer::StreamReporter::ReportAdded(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const std::vector<SpecificField>& field_path) {
printer_->Print("added: ");
PrintPath(field_path, false, message2);
@@ -1866,8 +1851,7 @@
}
void MessageDifferencer::StreamReporter::ReportDeleted(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const std::vector<SpecificField>& field_path) {
printer_->Print("deleted: ");
PrintPath(field_path, true, message1);
@@ -1877,8 +1861,7 @@
}
void MessageDifferencer::StreamReporter::ReportModified(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const std::vector<SpecificField>& field_path) {
if (!report_modified_aggregates_ && field_path.back().field == NULL) {
if (field_path.back().unknown_field_type == UnknownField::TYPE_GROUP) {
@@ -1907,8 +1890,7 @@
}
void MessageDifferencer::StreamReporter::ReportMoved(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const std::vector<SpecificField>& field_path) {
printer_->Print("moved: ");
PrintPath(field_path, true, message1);
@@ -1920,8 +1902,7 @@
}
void MessageDifferencer::StreamReporter::ReportMatched(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const std::vector<SpecificField>& field_path) {
printer_->Print("matched: ");
PrintPath(field_path, true, message1);
@@ -1935,8 +1916,7 @@
}
void MessageDifferencer::StreamReporter::ReportIgnored(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const std::vector<SpecificField>& field_path) {
printer_->Print("ignored: ");
PrintPath(field_path, true, message1);
@@ -1965,7 +1945,6 @@
return new MultipleFieldsMapKeyComparator(this, key_field_paths);
}
-
} // namespace util
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/util/message_differencer.h b/src/google/protobuf/util/message_differencer.h
index 7504227..e36a72b 100644
--- a/src/google/protobuf/util/message_differencer.h
+++ b/src/google/protobuf/util/message_differencer.h
@@ -48,7 +48,7 @@
#include <string>
#include <vector>
#include <google/protobuf/descriptor.h> // FieldDescriptor
-#include <google/protobuf/message.h> // Message
+#include <google/protobuf/message.h> // Message
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/util/field_comparator.h>
@@ -70,7 +70,6 @@
class DefaultFieldComparator;
class FieldContext; // declared below MessageDifferencer
-
// A basic differencer that can be used to determine
// the differences between two specified Protocol Messages. If any differences
// are found, the Compare method will return false, and any differencer reporter
@@ -224,20 +223,17 @@
virtual ~Reporter();
// Reports that a field has been added into Message2.
- virtual void ReportAdded(
- const Message& message1, const Message& message2,
- const std::vector<SpecificField>& field_path) = 0;
+ virtual void ReportAdded(const Message& message1, const Message& message2,
+ const std::vector<SpecificField>& field_path) = 0;
// Reports that a field has been deleted from Message1.
virtual void ReportDeleted(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const std::vector<SpecificField>& field_path) = 0;
// Reports that the value of a field has been modified.
virtual void ReportModified(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const std::vector<SpecificField>& field_path) = 0;
// Reports that a repeated field has been moved to another location. This
@@ -246,18 +242,16 @@
// mutually exclusive. If a field has been both moved and modified, then
// only ReportModified will be called.
virtual void ReportMoved(
- const Message& /* message1 */,
- const Message& /* message2 */,
- const std::vector<SpecificField>& /* field_path */) { }
+ const Message& /* message1 */, const Message& /* message2 */,
+ const std::vector<SpecificField>& /* field_path */) {}
// Reports that two fields match. Useful for doing side-by-side diffs.
// This function is mutually exclusive with ReportModified and ReportMoved.
// Note that you must call set_report_matches(true) before calling Compare
// to make use of this function.
virtual void ReportMatched(
- const Message& /* message1 */,
- const Message& /* message2 */,
- const std::vector<SpecificField>& /* field_path */) { }
+ const Message& /* message1 */, const Message& /* message2 */,
+ const std::vector<SpecificField>& /* field_path */) {}
// Reports that two fields would have been compared, but the
// comparison has been skipped because the field was marked as
@@ -279,9 +273,8 @@
// the fields are equal or not (perhaps with a second call to
// Compare()), if it cares.
virtual void ReportIgnored(
- const Message& /* message1 */,
- const Message& /* message2 */,
- const std::vector<SpecificField>& /* field_path */) { }
+ const Message& /* message1 */, const Message& /* message2 */,
+ const std::vector<SpecificField>& /* field_path */) {}
// Report that an unknown field is ignored. (see comment above).
// Note this is a different function since the last SpecificField in field
@@ -302,8 +295,7 @@
virtual ~MapKeyComparator();
virtual bool IsMatch(
- const Message& /* message1 */,
- const Message& /* message2 */,
+ const Message& /* message1 */, const Message& /* message2 */,
const std::vector<SpecificField>& /* parent_fields */) const {
GOOGLE_CHECK(false) << "IsMatch() is not implemented.";
return false;
@@ -326,8 +318,7 @@
// Returns true if the field should be ignored.
virtual bool IsIgnored(
- const Message& /* message1 */,
- const Message& /* message2 */,
+ const Message& /* message1 */, const Message& /* message2 */,
const FieldDescriptor* /* field */,
const std::vector<SpecificField>& /* parent_fields */) = 0;
@@ -372,13 +363,13 @@
};
enum RepeatedFieldComparison {
- AS_LIST, // Repeated fields are compared in order. Differing values at
- // the same index are reported using ReportModified(). If the
- // repeated fields have different numbers of elements, the
- // unpaired elements are reported using ReportAdded() or
- // ReportDeleted().
- AS_SET, // Treat all the repeated fields as sets.
- // See TreatAsSet(), as below.
+ AS_LIST, // Repeated fields are compared in order. Differing values at
+ // the same index are reported using ReportModified(). If the
+ // repeated fields have different numbers of elements, the
+ // unpaired elements are reported using ReportAdded() or
+ // ReportDeleted().
+ AS_SET, // Treat all the repeated fields as sets.
+ // See TreatAsSet(), as below.
AS_SMART_LIST, // Similar to AS_SET, but preserve the order and find the
// longest matching sequence from the first matching
// element. To use an optimal solution, call
@@ -484,9 +475,8 @@
// first key matching step. Rather than comparing some specified fields, it
// will invoke the IsMatch method of the given 'key_comparator' to decide if
// two elements have the same key.
- void TreatAsMapUsingKeyComparator(
- const FieldDescriptor* field,
- const MapKeyComparator* key_comparator);
+ void TreatAsMapUsingKeyComparator(const FieldDescriptor* field,
+ const MapKeyComparator* key_comparator);
// Initiates and returns a new instance of MultipleFieldsMapKeyComparator.
MapKeyComparator* CreateMultipleFieldsMapKeyComparator(
@@ -543,9 +533,7 @@
// Tells the differencer whether or not to report moves (in a set or map
// repeated field). This method must be called before Compare. The default for
// a new differencer is true.
- void set_report_moves(bool report_moves) {
- report_moves_ = report_moves;
- }
+ void set_report_moves(bool report_moves) { report_moves_ = report_moves; }
// Tells the differencer whether or not to report ignored values. This method
// must be called before Compare. The default for a new differencer is true.
@@ -757,11 +745,8 @@
std::vector<SpecificField>* parent_fields);
// Shorthand for CompareFieldValueUsingParentFields with NULL parent_fields.
- bool CompareFieldValue(const Message& message1,
- const Message& message2,
- const FieldDescriptor* field,
- int index1,
- int index2);
+ bool CompareFieldValue(const Message& message1, const Message& message2,
+ const FieldDescriptor* field, int index1, int index2);
// Compares the specified field on the two messages, returning
// true if they are the same, false otherwise. For repeated fields,
@@ -773,11 +758,8 @@
// To avoid confusing users you should not set it to NULL unless you modified
// Reporter to handle the change of parent_fields correctly.
bool CompareFieldValueUsingParentFields(
- const Message& message1,
- const Message& message2,
- const FieldDescriptor* field,
- int index1,
- int index2,
+ const Message& message1, const Message& message2,
+ const FieldDescriptor* field, int index1, int index2,
std::vector<SpecificField>* parent_fields);
// Compares the specified field on the two messages, returning comparison
@@ -791,8 +773,8 @@
// if the key_comprator is NULL, this function returns true when the two
// elements are equal.
bool IsMatch(const FieldDescriptor* repeated_field,
- const MapKeyComparator* key_comparator,
- const Message* message1, const Message* message2,
+ const MapKeyComparator* key_comparator, const Message* message1,
+ const Message* message2,
const std::vector<SpecificField>& parent_fields,
Reporter* reporter, int index1, int index2);
@@ -816,11 +798,9 @@
// Returns true if this field is to be ignored when this
// MessageDifferencer compares messages.
- bool IsIgnored(
- const Message& message1,
- const Message& message2,
- const FieldDescriptor* field,
- const std::vector<SpecificField>& parent_fields);
+ bool IsIgnored(const Message& message1, const Message& message2,
+ const FieldDescriptor* field,
+ const std::vector<SpecificField>& parent_fields);
// Returns true if this unknown field is to be ignored when this
// MessageDifferencer compares messages.
@@ -841,12 +821,10 @@
// that the comparison succeeds when this method returns true (you need to
// double-check in this case).
bool MatchRepeatedFieldIndices(
- const Message& message1,
- const Message& message2,
+ const Message& message1, const Message& message2,
const FieldDescriptor* repeated_field,
const std::vector<SpecificField>& parent_fields,
- std::vector<int>* match_list1,
- std::vector<int>* match_list2);
+ std::vector<int>* match_list1, std::vector<int>* match_list2);
// If "any" is of type google.protobuf.Any, extract its payload using
// DynamicMessageFactory and store in "data".
@@ -863,8 +841,8 @@
// Defines a map between field descriptors and their MapKeyComparators.
// Used for repeated fields when they are configured as TreatAsMap.
- typedef std::map<const FieldDescriptor*,
- const MapKeyComparator*> FieldKeyComparatorMap;
+ typedef std::map<const FieldDescriptor*, const MapKeyComparator*>
+ FieldKeyComparatorMap;
// Defines a set to store field descriptors. Used for repeated fields when
// they are configured as TreatAsSet.
@@ -899,8 +877,8 @@
std::string* output_string_;
// Callback to post-process the matched indices to support SMART_LIST.
- std::function<void(std::vector<int>*,
- std::vector<int>*)> match_indices_for_smart_list_callback_;
+ std::function<void(std::vector<int>*, std::vector<int>*)>
+ match_indices_for_smart_list_callback_;
std::unique_ptr<DynamicMessageFactory> dynamic_message_factory_;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageDifferencer);
diff --git a/src/google/protobuf/util/message_differencer_unittest.cc b/src/google/protobuf/util/message_differencer_unittest.cc
index cacfc1f..702f99f 100644
--- a/src/google/protobuf/util/message_differencer_unittest.cc
+++ b/src/google/protobuf/util/message_differencer_unittest.cc
@@ -41,18 +41,18 @@
#include <google/protobuf/stubs/strutil.h>
-#include <google/protobuf/util/field_comparator.h>
-#include <google/protobuf/util/message_differencer.h>
-#include <google/protobuf/util/message_differencer_unittest.pb.h>
+#include <google/protobuf/any_test.pb.h>
+#include <google/protobuf/map_test_util.h>
+#include <google/protobuf/map_unittest.pb.h>
+#include <google/protobuf/test_util.h>
+#include <google/protobuf/unittest.pb.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/text_format.h>
#include <google/protobuf/wire_format.h>
-#include <google/protobuf/io/zero_copy_stream_impl.h>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/any_test.pb.h>
-#include <google/protobuf/map_unittest.pb.h>
-#include <google/protobuf/unittest.pb.h>
-#include <google/protobuf/map_test_util.h>
-#include <google/protobuf/test_util.h>
+#include <google/protobuf/util/message_differencer_unittest.pb.h>
+#include <google/protobuf/util/field_comparator.h>
+#include <google/protobuf/util/message_differencer.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
@@ -79,8 +79,7 @@
}
void ExpectEqualsWithDifferencer(util::MessageDifferencer* differencer,
- const Message& msg1,
- const Message& msg2) {
+ const Message& msg1, const Message& msg2) {
differencer->set_scope(util::MessageDifferencer::FULL);
EXPECT_TRUE(differencer->Compare(msg1, msg2));
@@ -298,7 +297,6 @@
EXPECT_FALSE(util::MessageDifferencer::Equivalent(msg1, msg2));
}
-
TEST(MessageDifferencerTest, BasicEquivalencyNonSetTest) {
// Create the testing protos
unittest::TestAllTypes msg1;
@@ -308,7 +306,6 @@
EXPECT_TRUE(util::MessageDifferencer::Equivalent(msg1, msg2));
}
-
TEST(MessageDifferencerTest, BasicInequivalencyNonSetTest) {
// Create the testing protos
unittest::TestAllTypes msg1;
@@ -320,7 +317,6 @@
EXPECT_FALSE(util::MessageDifferencer::Equivalent(msg1, msg2));
}
-
TEST(MessageDifferencerTest, BasicPartialEquivalencyTest) {
// Create the testing protos
unittest::TestAllTypes msg1;
@@ -479,8 +475,7 @@
TestUtil::SetAllFields(&msg2);
// Compare
- EXPECT_TRUE(util::MessageDifferencer::ApproximatelyEquivalent(msg1,
- msg2));
+ EXPECT_TRUE(util::MessageDifferencer::ApproximatelyEquivalent(msg1, msg2));
}
TEST(MessageDifferencerTest, ApproximateModifiedEquivalencyTest) {
@@ -501,8 +496,7 @@
ASSERT_NE(v1, v2) << "Should not be the same: " << v1 << ", " << v2;
ASSERT_FLOAT_EQ(v1, v2) << "Should be approx. equal: " << v1 << ", " << v2;
EXPECT_FALSE(util::MessageDifferencer::Equals(msg1, msg2));
- EXPECT_TRUE(util::MessageDifferencer::ApproximatelyEquivalent(msg1,
- msg2));
+ EXPECT_TRUE(util::MessageDifferencer::ApproximatelyEquivalent(msg1, msg2));
// Modify the equivalency requirement too
msg1.clear_optional_int32();
@@ -512,8 +506,7 @@
EXPECT_FALSE(util::MessageDifferencer::Equals(msg1, msg2));
EXPECT_FALSE(util::MessageDifferencer::Equivalent(msg1, msg2));
EXPECT_FALSE(util::MessageDifferencer::ApproximatelyEquals(msg1, msg2));
- EXPECT_TRUE(util::MessageDifferencer::ApproximatelyEquivalent(msg1,
- msg2));
+ EXPECT_TRUE(util::MessageDifferencer::ApproximatelyEquivalent(msg1, msg2));
}
TEST(MessageDifferencerTest, ApproximateInequivalencyTest) {
@@ -526,22 +519,19 @@
// Should fail on equivalency
msg1.set_optional_int32(-1);
- EXPECT_FALSE(util::MessageDifferencer::ApproximatelyEquivalent(msg1,
- msg2));
+ EXPECT_FALSE(util::MessageDifferencer::ApproximatelyEquivalent(msg1, msg2));
// Make these fields the same again.
msg1.set_optional_int32(0);
msg2.set_optional_int32(0);
- EXPECT_TRUE(util::MessageDifferencer::ApproximatelyEquivalent(msg1,
- msg2));
+ EXPECT_TRUE(util::MessageDifferencer::ApproximatelyEquivalent(msg1, msg2));
// Should fail on approximate equality check
const float v1 = 2.3f;
const float v2 = 9.3f;
msg1.set_optional_float(v1);
msg2.set_optional_float(v2);
- EXPECT_FALSE(util::MessageDifferencer::ApproximatelyEquivalent(msg1,
- msg2));
+ EXPECT_FALSE(util::MessageDifferencer::ApproximatelyEquivalent(msg1, msg2));
}
TEST(MessageDifferencerTest, WithinFractionOrMarginFloatTest) {
@@ -715,7 +705,6 @@
EXPECT_TRUE(util::MessageDifferencer::Equals(msg1, msg2));
}
-
TEST(MessageDifferencerTest, BasicFieldOrderingInequalityTest) {
// Create the testing protos
unittest::TestFieldOrderings msg1;
@@ -743,7 +732,6 @@
EXPECT_TRUE(util::MessageDifferencer::Equals(msg1, msg2));
}
-
TEST(MessageDifferencerTest, BasicExtensionInequalityTest) {
// Create the testing protos
unittest::TestAllExtensions msg1;
@@ -845,12 +833,12 @@
std::vector<const FieldDescriptor*> empty_fields;
util::MessageDifferencer differencer;
- EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2,
- empty_fields, empty_fields));
+ EXPECT_TRUE(
+ differencer.CompareWithFields(msg1, msg2, empty_fields, empty_fields));
TestUtil::SetAllFields(&msg2);
- EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2,
- empty_fields, empty_fields));
+ EXPECT_TRUE(
+ differencer.CompareWithFields(msg1, msg2, empty_fields, empty_fields));
}
TEST(MessageDifferencerTest, SpecifiedFieldsCompareWithSelf) {
@@ -871,8 +859,8 @@
compare_fields.push_back(fields[i]);
}
}
- EXPECT_TRUE(differencer.CompareWithFields(msg1, msg1,
- compare_fields, compare_fields));
+ EXPECT_TRUE(differencer.CompareWithFields(msg1, msg1, compare_fields,
+ compare_fields));
}
{
// Specify a different set of fields to compare, even though we're using the
@@ -887,8 +875,8 @@
compare_fields2.push_back(fields[i]);
}
}
- EXPECT_FALSE(differencer.CompareWithFields(
- msg1, msg1, compare_fields1, compare_fields2));
+ EXPECT_FALSE(differencer.CompareWithFields(msg1, msg1, compare_fields1,
+ compare_fields2));
}
}
@@ -934,8 +922,8 @@
}
util::MessageDifferencer differencer;
- EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2,
- compare_fields, compare_fields));
+ EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2, compare_fields,
+ compare_fields));
}
TEST(MessageDifferencerTest,
@@ -964,8 +952,8 @@
util::MessageDifferencer differencer;
EXPECT_FALSE(differencer.Compare(msg1, msg2));
- EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2,
- compare_fields, compare_fields));
+ EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2, compare_fields,
+ compare_fields));
}
TEST(MessageDifferencerTest, SpecifiedFieldsDetectsDifferencesTest) {
@@ -989,8 +977,8 @@
}
util::MessageDifferencer differencer;
- EXPECT_FALSE(differencer.CompareWithFields(msg1, msg2,
- compare_fields, compare_fields));
+ EXPECT_FALSE(differencer.CompareWithFields(msg1, msg2, compare_fields,
+ compare_fields));
}
TEST(MessageDifferencerTest, SpecifiedFieldsEquivalenceAllTest) {
@@ -1080,18 +1068,20 @@
differencer.set_repeated_field_comparison(
util::MessageDifferencer::AS_SMART_LIST);
EXPECT_FALSE(differencer.Compare(msg1, msg2));
- EXPECT_EQ("deleted: rv[0]: 1\n"
- "added: rv[0]: 9\n"
- "added: rv[1]: 0\n"
- "moved: rv[1] -> rv[2] : 2\n"
- "added: rv[3]: 7\n"
- "moved: rv[2] -> rv[4] : 3\n"
- "deleted: rv[3]: 9\n"
- "moved: rv[4] -> rv[5] : 4\n"
- "moved: rv[5] -> rv[6] : 5\n"
- "deleted: rv[6]: 7\n"
- "added: rv[7]: 6\n"
- "moved: rv[7] -> rv[8] : 2\n", diff_report);
+ EXPECT_EQ(
+ "deleted: rv[0]: 1\n"
+ "added: rv[0]: 9\n"
+ "added: rv[1]: 0\n"
+ "moved: rv[1] -> rv[2] : 2\n"
+ "added: rv[3]: 7\n"
+ "moved: rv[2] -> rv[4] : 3\n"
+ "deleted: rv[3]: 9\n"
+ "moved: rv[4] -> rv[5] : 4\n"
+ "moved: rv[5] -> rv[6] : 5\n"
+ "deleted: rv[6]: 7\n"
+ "added: rv[7]: 6\n"
+ "moved: rv[7] -> rv[8] : 2\n",
+ diff_report);
// Compare two sub messages
// a: 1, 2, 3, 4, 5
@@ -1110,12 +1100,14 @@
differencer.set_repeated_field_comparison(
util::MessageDifferencer::AS_SMART_LIST);
EXPECT_FALSE(differencer.Compare(msg1, msg2));
- EXPECT_EQ("deleted: rm[0]: { a: 1 }\n"
- "moved: rm[1] -> rm[0] : { a: 2 }\n"
- "deleted: rm[2]: { a: 3 }\n"
- "added: rm[1]: { a: 6 }\n"
- "moved: rm[3] -> rm[2] : { a: 4 }\n"
- "deleted: rm[4]: { a: 5 }\n", diff_report);
+ EXPECT_EQ(
+ "deleted: rm[0]: { a: 1 }\n"
+ "moved: rm[1] -> rm[0] : { a: 2 }\n"
+ "deleted: rm[2]: { a: 3 }\n"
+ "added: rm[1]: { a: 6 }\n"
+ "moved: rm[3] -> rm[2] : { a: 4 }\n"
+ "deleted: rm[4]: { a: 5 }\n",
+ diff_report);
}
TEST(MessageDifferencerTest, RepeatedFieldSmartSetTest) {
@@ -1126,15 +1118,24 @@
protobuf_unittest::TestField elem1_2, elem2_2, elem3_2;
// Only one field is different for each pair of elememts
- elem1_1.set_a(1); elem1_2.set_a(0);
- elem1_1.set_b(1); elem1_2.set_b(1);
- elem1_1.set_c(1); elem1_2.set_c(1);
- elem2_1.set_a(2); elem2_2.set_a(2);
- elem2_1.set_b(2); elem2_2.set_b(0);
- elem2_1.set_c(2); elem2_2.set_c(2);
- elem3_1.set_a(3); elem3_2.set_a(3);
- elem3_1.set_b(3); elem3_2.set_b(0);
- elem3_1.set_c(3); elem3_2.set_c(3);
+ elem1_1.set_a(1);
+ elem1_2.set_a(0);
+ elem1_1.set_b(1);
+ elem1_2.set_b(1);
+ elem1_1.set_c(1);
+ elem1_2.set_c(1);
+ elem2_1.set_a(2);
+ elem2_2.set_a(2);
+ elem2_1.set_b(2);
+ elem2_2.set_b(0);
+ elem2_1.set_c(2);
+ elem2_2.set_c(2);
+ elem3_1.set_a(3);
+ elem3_2.set_a(3);
+ elem3_1.set_b(3);
+ elem3_2.set_b(0);
+ elem3_1.set_c(3);
+ elem3_2.set_c(3);
*msg1.add_rm() = elem1_1;
*msg1.add_rm() = elem2_1;
@@ -1150,9 +1151,11 @@
differencer.set_repeated_field_comparison(
util::MessageDifferencer::AS_SMART_SET);
EXPECT_FALSE(differencer.Compare(msg1, msg2));
- EXPECT_EQ("modified: rm[0].a -> rm[1].a: 1 -> 0\n"
- "modified: rm[1].b -> rm[2].b: 2 -> 0\n"
- "modified: rm[2].b -> rm[0].b: 3 -> 0\n", diff_report);
+ EXPECT_EQ(
+ "modified: rm[0].a -> rm[1].a: 1 -> 0\n"
+ "modified: rm[1].b -> rm[2].b: 2 -> 0\n"
+ "modified: rm[2].b -> rm[0].b: 3 -> 0\n",
+ diff_report);
}
TEST(MessageDifferencerTest, RepeatedFieldSmartSet_MultipleMatches) {
@@ -1166,14 +1169,18 @@
elem1_1.set_a(1);
elem1_1.set_b(1);
elem1_1.set_c(1);
- elem2_1.set_a(2); elem2_2.set_a(2);
- elem2_1.set_b(2); elem2_2.set_b(0);
- elem2_1.set_c(2); elem2_2.set_c(2);
- elem3_1.set_a(3); elem3_2.set_a(3);
- elem3_1.set_b(3); elem3_2.set_b(0);
- elem3_1.set_c(3); elem3_2.set_c(3);
-
-
+ elem2_1.set_a(2);
+ elem2_2.set_a(2);
+ elem2_1.set_b(2);
+ elem2_2.set_b(0);
+ elem2_1.set_c(2);
+ elem2_2.set_c(2);
+ elem3_1.set_a(3);
+ elem3_2.set_a(3);
+ elem3_1.set_b(3);
+ elem3_2.set_b(0);
+ elem3_1.set_c(3);
+ elem3_2.set_c(3);
// In this testcase, elem1_1 will match with elem2_2 first and then get
// reverted because elem2_1 matches with elem2_2 later.
@@ -1189,9 +1196,11 @@
differencer.set_repeated_field_comparison(
util::MessageDifferencer::AS_SMART_SET);
EXPECT_FALSE(differencer.Compare(msg1, msg2));
- EXPECT_EQ("modified: rm[1].b -> rm[0].b: 2 -> 0\n"
- "modified: rm[2].b -> rm[1].b: 3 -> 0\n"
- "deleted: rm[0]: { c: 1 a: 1 b: 1 }\n", diff_report);
+ EXPECT_EQ(
+ "modified: rm[1].b -> rm[0].b: 2 -> 0\n"
+ "modified: rm[2].b -> rm[1].b: 3 -> 0\n"
+ "deleted: rm[0]: { c: 1 a: 1 b: 1 }\n",
+ diff_report);
}
TEST(MessageDifferencerTest, RepeatedFieldSmartSet_MultipleMatchesNoReporter) {
@@ -1222,9 +1231,12 @@
protobuf_unittest::TestDiffMessage msg2;
// Create 3 elements, but in different order.
- msg1.add_rw("b"); msg2.add_rw("a");
- msg1.add_rw("x"); msg2.add_rw("x");
- msg1.add_rw("a"); msg2.add_rw("b");
+ msg1.add_rw("b");
+ msg2.add_rw("a");
+ msg1.add_rw("x");
+ msg2.add_rw("x");
+ msg1.add_rw("a");
+ msg2.add_rw("b");
std::string diff_report;
util::MessageDifferencer differencer;
@@ -1232,8 +1244,10 @@
differencer.set_repeated_field_comparison(
util::MessageDifferencer::AS_SMART_SET);
EXPECT_TRUE(differencer.Compare(msg1, msg2));
- EXPECT_EQ("moved: rw[0] -> rw[2] : \"b\"\n"
- "moved: rw[2] -> rw[0] : \"a\"\n", diff_report);
+ EXPECT_EQ(
+ "moved: rw[0] -> rw[2] : \"b\"\n"
+ "moved: rw[2] -> rw[0] : \"a\"\n",
+ diff_report);
}
TEST(MessageDifferencerTest, RepeatedFieldSetTest_SetOfSet) {
@@ -1242,22 +1256,34 @@
protobuf_unittest::TestDiffMessage msg2;
protobuf_unittest::TestDiffMessage::Item* item = msg1.add_item();
- item->add_ra(1); item->add_ra(2); item->add_ra(3);
+ item->add_ra(1);
+ item->add_ra(2);
+ item->add_ra(3);
item = msg1.add_item();
- item->add_ra(5); item->add_ra(6);
+ item->add_ra(5);
+ item->add_ra(6);
item = msg1.add_item();
- item->add_ra(1); item->add_ra(3);
+ item->add_ra(1);
+ item->add_ra(3);
item = msg1.add_item();
- item->add_ra(6); item->add_ra(7); item->add_ra(8);
+ item->add_ra(6);
+ item->add_ra(7);
+ item->add_ra(8);
item = msg2.add_item();
- item->add_ra(6); item->add_ra(5);
+ item->add_ra(6);
+ item->add_ra(5);
item = msg2.add_item();
- item->add_ra(6); item->add_ra(8); item->add_ra(7);
+ item->add_ra(6);
+ item->add_ra(8);
+ item->add_ra(7);
item = msg2.add_item();
- item->add_ra(1); item->add_ra(3);
+ item->add_ra(1);
+ item->add_ra(3);
item = msg2.add_item();
- item->add_ra(3); item->add_ra(2); item->add_ra(1);
+ item->add_ra(3);
+ item->add_ra(2);
+ item->add_ra(1);
// Compare
util::MessageDifferencer differencer;
@@ -1275,29 +1301,41 @@
// Treat "rw" as List
protobuf_unittest::TestDiffMessage::Item* item = msg1.add_item();
item->set_a(3);
- item->add_ra(1); item->add_ra(2); item->add_ra(3);
+ item->add_ra(1);
+ item->add_ra(2);
+ item->add_ra(3);
item = msg1.add_item();
item->set_a(4);
- item->add_ra(5); item->add_ra(6);
+ item->add_ra(5);
+ item->add_ra(6);
item = msg1.add_item();
item->set_a(1);
- item->add_ra(1); item->add_ra(3);
+ item->add_ra(1);
+ item->add_ra(3);
item = msg1.add_item();
item->set_a(2);
- item->add_ra(6); item->add_ra(7); item->add_ra(8);
+ item->add_ra(6);
+ item->add_ra(7);
+ item->add_ra(8);
item = msg2.add_item();
item->set_a(4);
- item->add_ra(6); item->add_ra(5);
+ item->add_ra(6);
+ item->add_ra(5);
item = msg2.add_item();
item->set_a(2);
- item->add_ra(6); item->add_ra(8); item->add_ra(7);
+ item->add_ra(6);
+ item->add_ra(8);
+ item->add_ra(7);
item = msg2.add_item();
item->set_a(1);
- item->add_ra(1); item->add_ra(3);
+ item->add_ra(1);
+ item->add_ra(3);
item = msg2.add_item();
item->set_a(3);
- item->add_ra(3); item->add_ra(2); item->add_ra(1);
+ item->add_ra(3);
+ item->add_ra(2);
+ item->add_ra(1);
msg1.add_rv(3);
msg1.add_rv(4);
@@ -1308,9 +1346,12 @@
msg2.add_rv(0);
msg2.add_rv(7);
- msg1.add_rw("nothing"); msg2.add_rw("nothing");
- msg1.add_rw("should"); msg2.add_rw("should");
- msg1.add_rw("change"); msg2.add_rw("change");
+ msg1.add_rw("nothing");
+ msg2.add_rw("nothing");
+ msg1.add_rw("should");
+ msg2.add_rw("should");
+ msg1.add_rw("change");
+ msg2.add_rw("change");
// Compare
util::MessageDifferencer differencer1;
@@ -1711,9 +1752,8 @@
: public util::MessageDifferencer::MapKeyComparator {
public:
typedef util::MessageDifferencer::SpecificField SpecificField;
- virtual bool IsMatch(
- const Message &message1, const Message &message2,
- const std::vector<SpecificField>& parent_fields) const {
+ virtual bool IsMatch(const Message& message1, const Message& message2,
+ const std::vector<SpecificField>& parent_fields) const {
const Reflection* reflection1 = message1.GetReflection();
const Reflection* reflection2 = message2.GetReflection();
// FieldDescriptor for item.ra
@@ -1746,8 +1786,8 @@
item->set_b("hello");
util::MessageDifferencer differencer;
ValueProductMapKeyComparator key_comparator;
- differencer.TreatAsMapUsingKeyComparator(
- GetFieldDescriptor(msg1, "item"), &key_comparator);
+ differencer.TreatAsMapUsingKeyComparator(GetFieldDescriptor(msg1, "item"),
+ &key_comparator);
std::string output;
differencer.ReportDifferencesToString(&output);
// Though the above two messages have different values for item.ra, they
@@ -1936,19 +1976,19 @@
const FieldDescriptor* c = GetFieldDescriptor(msg1, "c");
const FieldDescriptor* rc = GetFieldDescriptor(msg1, "rc");
- { // Ignore c
+ { // Ignore c
util::MessageDifferencer differencer;
differencer.IgnoreField(c);
EXPECT_FALSE(differencer.Compare(msg1, msg2));
}
- { // Ignore rc
+ { // Ignore rc
util::MessageDifferencer differencer;
differencer.IgnoreField(rc);
EXPECT_FALSE(differencer.Compare(msg1, msg2));
}
- { // Ignore both
+ { // Ignore both
util::MessageDifferencer differencer;
differencer.IgnoreField(c);
differencer.IgnoreField(rc);
@@ -2176,8 +2216,7 @@
const FieldDescriptor* field, int index_1,
int index_2,
const util::FieldContext* field_context) {
- if (field_context)
- parent_fields_ = *(field_context->parent_fields());
+ if (field_context) parent_fields_ = *(field_context->parent_fields());
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
return RECURSE;
} else {
@@ -2229,10 +2268,10 @@
unknown2_ = empty2_.mutable_unknown_fields();
}
- ~ComparisonTest() { }
+ ~ComparisonTest() {}
void SetSpecialFieldOption(const Message& message,
- util::MessageDifferencer* d) {
+ util::MessageDifferencer* d) {
if (!ignored_field_.empty()) {
d->IgnoreField(GetFieldDescriptor(message, ignored_field_));
}
@@ -2281,19 +2320,15 @@
std::string RunUn() { return Run(empty1_, empty2_); }
- void use_equivalency() {
- use_equivalency_ = true;
- }
+ void use_equivalency() { use_equivalency_ = true; }
- void repeated_field_as_set() {
- repeated_field_as_set_ = true;
- }
+ void repeated_field_as_set() { repeated_field_as_set_ = true; }
void field_as_set(const std::string& field) { set_field_ = field; }
void field_as_map(const string& field, const std::string& key) {
map_field_ = field;
- map_key_ = key;
+ map_key_ = key;
}
void ignore_field(const std::string& field) { ignored_field_ = field; }
@@ -2332,44 +2367,40 @@
TEST_F(ComparisonTest, AdditionTest) {
proto1_.clear_optional_int32();
- EXPECT_EQ("added: optional_int32: 101\n",
- Run());
+ EXPECT_EQ("added: optional_int32: 101\n", Run());
}
TEST_F(ComparisonTest, Addition_OrderTest) {
orderings_proto1_.clear_my_int();
- EXPECT_EQ("added: my_int: 1\n",
- RunOrder());
+ EXPECT_EQ("added: my_int: 1\n", RunOrder());
}
TEST_F(ComparisonTest, DeletionTest) {
proto2_.clear_optional_int32();
- EXPECT_EQ("deleted: optional_int32: 101\n",
- Run());
+ EXPECT_EQ("deleted: optional_int32: 101\n", Run());
}
TEST_F(ComparisonTest, Deletion_OrderTest) {
orderings_proto2_.clear_my_string();
- EXPECT_EQ("deleted: my_string: \"foo\"\n",
- RunOrder());
+ EXPECT_EQ("deleted: my_string: \"foo\"\n", RunOrder());
}
TEST_F(ComparisonTest, RepeatedDeletionTest) {
proto2_.clear_repeated_int32();
- EXPECT_EQ("deleted: repeated_int32[0]: 201\n"
- "deleted: repeated_int32[1]: 301\n",
- Run());
+ EXPECT_EQ(
+ "deleted: repeated_int32[0]: 201\n"
+ "deleted: repeated_int32[1]: 301\n",
+ Run());
}
TEST_F(ComparisonTest, ModificationTest) {
proto1_.set_optional_int32(-1);
- EXPECT_EQ("modified: optional_int32: -1 -> 101\n",
- Run());
+ EXPECT_EQ("modified: optional_int32: -1 -> 101\n", Run());
}
// Basic equivalency tests.
@@ -2378,8 +2409,7 @@
proto1_.clear_optional_int32();
- EXPECT_EQ("modified: optional_int32: 0 -> 101\n",
- Run());
+ EXPECT_EQ("modified: optional_int32: 0 -> 101\n", Run());
}
TEST_F(ComparisonTest, EquivalencyDeletionTest) {
@@ -2387,45 +2417,39 @@
proto2_.clear_optional_int32();
- EXPECT_EQ("modified: optional_int32: 101 -> 0\n",
- Run());
+ EXPECT_EQ("modified: optional_int32: 101 -> 0\n", Run());
}
// Group tests.
TEST_F(ComparisonTest, GroupAdditionTest) {
proto1_.mutable_optionalgroup()->clear_a();
- EXPECT_EQ("added: optionalgroup.a: 117\n",
- Run());
+ EXPECT_EQ("added: optionalgroup.a: 117\n", Run());
}
TEST_F(ComparisonTest, GroupDeletionTest) {
proto2_.mutable_optionalgroup()->clear_a();
- EXPECT_EQ("deleted: optionalgroup.a: 117\n",
- Run());
+ EXPECT_EQ("deleted: optionalgroup.a: 117\n", Run());
}
TEST_F(ComparisonTest, GroupModificationTest) {
proto1_.mutable_optionalgroup()->set_a(2);
- EXPECT_EQ("modified: optionalgroup.a: 2 -> 117\n",
- Run());
+ EXPECT_EQ("modified: optionalgroup.a: 2 -> 117\n", Run());
}
TEST_F(ComparisonTest, GroupFullAdditionTest) {
proto1_.clear_optionalgroup();
// Note the difference in the output between this and GroupAdditionTest.
- EXPECT_EQ("added: optionalgroup: { a: 117 }\n",
- Run());
+ EXPECT_EQ("added: optionalgroup: { a: 117 }\n", Run());
}
TEST_F(ComparisonTest, GroupFullDeletionTest) {
proto2_.clear_optionalgroup();
- EXPECT_EQ("deleted: optionalgroup: { a: 117 }\n",
- Run());
+ EXPECT_EQ("deleted: optionalgroup: { a: 117 }\n", Run());
}
TEST_F(ComparisonTest, RepeatedSetOptionTest) {
@@ -2440,11 +2464,12 @@
proto1_.add_repeatedgroup()->set_a(907);
proto1_.add_repeatedgroup()->set_a(909);
- EXPECT_EQ("moved: repeatedgroup[2] -> repeatedgroup[1] : { a: 907 }\n"
- "moved: repeatedgroup[3] -> repeatedgroup[0] : { a: 909 }\n"
- "deleted: repeatedgroup[0]: { a: 317 }\n"
- "deleted: repeatedgroup[1]: { a: 904 }\n",
- Run());
+ EXPECT_EQ(
+ "moved: repeatedgroup[2] -> repeatedgroup[1] : { a: 907 }\n"
+ "moved: repeatedgroup[3] -> repeatedgroup[0] : { a: 909 }\n"
+ "deleted: repeatedgroup[0]: { a: 317 }\n"
+ "deleted: repeatedgroup[1]: { a: 904 }\n",
+ Run());
}
TEST_F(ComparisonTest, RepeatedSetOptionTest_Ex) {
@@ -2463,12 +2488,13 @@
proto1ex_.AddExtension(protobuf_unittest::repeated_nested_message_extension)
->set_bb(909);
- EXPECT_EQ("moved: (protobuf_unittest.repeated_nested_message_extension)[2] ->"
- " (protobuf_unittest.repeated_nested_message_extension)[0] :"
- " { bb: 909 }\n"
- "deleted: (protobuf_unittest.repeated_nested_message_extension)[0]:"
- " { bb: 904 }\n",
- RunEx());
+ EXPECT_EQ(
+ "moved: (protobuf_unittest.repeated_nested_message_extension)[2] ->"
+ " (protobuf_unittest.repeated_nested_message_extension)[0] :"
+ " { bb: 909 }\n"
+ "deleted: (protobuf_unittest.repeated_nested_message_extension)[0]:"
+ " { bb: 904 }\n",
+ RunEx());
}
TEST_F(ComparisonTest, RepeatedMapFieldTest_Group) {
@@ -2485,11 +2511,12 @@
proto2_.add_repeatedgroup()->set_a(318); // added
proto2_.add_repeatedgroup()->set_a(907); // moved to
- EXPECT_EQ("moved: repeatedgroup[3] -> repeatedgroup[0] : { a: 909 }\n"
- "added: repeatedgroup[1]: { a: 318 }\n"
- "deleted: repeatedgroup[0]: { a: 317 }\n"
- "deleted: repeatedgroup[1]: { a: 904 }\n",
- Run());
+ EXPECT_EQ(
+ "moved: repeatedgroup[3] -> repeatedgroup[0] : { a: 909 }\n"
+ "added: repeatedgroup[1]: { a: 318 }\n"
+ "deleted: repeatedgroup[0]: { a: 317 }\n"
+ "deleted: repeatedgroup[1]: { a: 904 }\n",
+ Run());
}
TEST_F(ComparisonTest, RepeatedMapFieldTest_MessageKey) {
@@ -2507,10 +2534,11 @@
item = msg1.add_item();
item->mutable_m()->set_c(2);
item->set_b("second");
- item = msg1.add_item(); item->set_b("null"); // empty key moved
+ item = msg1.add_item();
+ item->set_b("null"); // empty key moved
item = msg1.add_item();
item->mutable_m()->set_c(3);
- item->set_b("third"); // deletion
+ item->set_b("third"); // deletion
item = msg1.add_item();
item->mutable_m()->set_c(2);
item->set_b("second"); // duplicated key ( deletion )
@@ -2522,8 +2550,9 @@
item->set_b("fourth"); // addition
item = msg2.add_item();
item->mutable_m()->set_c(0);
- item->set_b("fist"); // move with change
- item = msg2.add_item(); item->set_b("null");
+ item->set_b("fist"); // move with change
+ item = msg2.add_item();
+ item->set_b("null");
EXPECT_EQ(
"modified: item[0].b -> item[2].b: \"first\" -> \"fist\"\n"
@@ -2542,33 +2571,45 @@
protobuf_unittest::TestDiffMessage msg2;
protobuf_unittest::TestDiffMessage::Item* item = msg1.add_item();
- item->add_ra(1); item->add_ra(2); item->add_ra(3);
+ item->add_ra(1);
+ item->add_ra(2);
+ item->add_ra(3);
item = msg1.add_item();
- item->add_ra(5); item->add_ra(6);
+ item->add_ra(5);
+ item->add_ra(6);
item = msg1.add_item();
- item->add_ra(1); item->add_ra(3);
+ item->add_ra(1);
+ item->add_ra(3);
item = msg1.add_item();
- item->add_ra(6); item->add_ra(7); item->add_ra(8);
+ item->add_ra(6);
+ item->add_ra(7);
+ item->add_ra(8);
item = msg2.add_item();
- item->add_ra(6); item->add_ra(5);
+ item->add_ra(6);
+ item->add_ra(5);
item = msg2.add_item();
- item->add_ra(6); item->add_ra(8);
+ item->add_ra(6);
+ item->add_ra(8);
item = msg2.add_item();
- item->add_ra(1); item->add_ra(3);
+ item->add_ra(1);
+ item->add_ra(3);
item = msg2.add_item();
- item->add_ra(3); item->add_ra(2); item->add_ra(1);
+ item->add_ra(3);
+ item->add_ra(2);
+ item->add_ra(1);
// Compare
- EXPECT_EQ("moved: item[0].ra[0] -> item[3].ra[2] : 1\n"
- "moved: item[0].ra[2] -> item[3].ra[0] : 3\n"
- "moved: item[0] -> item[3] : { ra: 1 ra: 2 ra: 3 }\n"
- "moved: item[1].ra[0] -> item[0].ra[1] : 5\n"
- "moved: item[1].ra[1] -> item[0].ra[0] : 6\n"
- "moved: item[1] -> item[0] : { ra: 5 ra: 6 }\n"
- "added: item[1]: { ra: 6 ra: 8 }\n"
- "deleted: item[3]: { ra: 6 ra: 7 ra: 8 }\n",
- Run(msg1, msg2));
+ EXPECT_EQ(
+ "moved: item[0].ra[0] -> item[3].ra[2] : 1\n"
+ "moved: item[0].ra[2] -> item[3].ra[0] : 3\n"
+ "moved: item[0] -> item[3] : { ra: 1 ra: 2 ra: 3 }\n"
+ "moved: item[1].ra[0] -> item[0].ra[1] : 5\n"
+ "moved: item[1].ra[1] -> item[0].ra[0] : 6\n"
+ "moved: item[1] -> item[0] : { ra: 5 ra: 6 }\n"
+ "added: item[1]: { ra: 6 ra: 8 }\n"
+ "deleted: item[3]: { ra: 6 ra: 7 ra: 8 }\n",
+ Run(msg1, msg2));
}
TEST_F(ComparisonTest, RepeatedMapFieldTest_RepeatedKey) {
@@ -2592,12 +2633,12 @@
item->add_rb("a");
item->set_b("fist");
-
- EXPECT_EQ("modified: item[0].b -> item[1].b: \"first\" -> \"fist\"\n"
- "moved: item[0].rb[0] -> item[1].rb[1] : \"a\"\n"
- "moved: item[0].rb[1] -> item[1].rb[0] : \"b\"\n"
- "added: item[0]: { b: \"second\" rb: \"c\" }\n",
- Run(msg1, msg2));
+ EXPECT_EQ(
+ "modified: item[0].b -> item[1].b: \"first\" -> \"fist\"\n"
+ "moved: item[0].rb[0] -> item[1].rb[1] : \"a\"\n"
+ "moved: item[0].rb[1] -> item[1].rb[0] : \"b\"\n"
+ "added: item[0]: { b: \"second\" rb: \"c\" }\n",
+ Run(msg1, msg2));
}
TEST_F(ComparisonTest, RepeatedMapFieldTest_RepeatedMessageKey) {
@@ -2607,9 +2648,14 @@
protobuf_unittest::TestDiffMessage msg2;
protobuf_unittest::TestDiffMessage::Item* item = msg1.add_item();
protobuf_unittest::TestField* key = item->add_rm();
- key->set_c(2); key->add_rc(10); key->add_rc(10);
- item = msg1.add_item(); key = item->add_rm();
- key->set_c(0); key->add_rc(1); key->add_rc(2);
+ key->set_c(2);
+ key->add_rc(10);
+ key->add_rc(10);
+ item = msg1.add_item();
+ key = item->add_rm();
+ key->set_c(0);
+ key->add_rc(1);
+ key->add_rc(2);
key = item->add_rm();
key->set_c(0);
item->add_rb("first");
@@ -2618,9 +2664,10 @@
item->CopyFrom(msg1.item(1));
item->add_rb("second");
- EXPECT_EQ("added: item[0].rb[1]: \"second\"\n"
- "deleted: item[0]: { rm { c: 2 rc: 10 rc: 10 } }\n",
- Run(msg1, msg2));
+ EXPECT_EQ(
+ "added: item[0].rb[1]: \"second\"\n"
+ "deleted: item[0]: { rm { c: 2 rc: 10 rc: 10 } }\n",
+ Run(msg1, msg2));
}
TEST_F(ComparisonTest, RepeatedSetOptionTest_Unknown) {
@@ -2632,9 +2679,10 @@
unknown2_->AddGroup(245)->AddFixed32(248, 1);
// We expect it behaves the same as normal comparison.
- EXPECT_EQ("modified: 245[0].248[0]: 0x00000001 -> 0x00000003\n"
- "added: 245[1]: { ... }\n",
- RunUn());
+ EXPECT_EQ(
+ "modified: 245[0].248[0]: 0x00000001 -> 0x00000003\n"
+ "added: 245[1]: { ... }\n",
+ RunUn());
}
TEST_F(ComparisonTest, Matching_Unknown) {
@@ -2646,9 +2694,10 @@
unknown2_->AddGroup(246)->AddFixed32(248, 4);
// report_match is false so only added/modified fields are expected.
- EXPECT_EQ("added: 242[0]: \"cat\"\n"
- "added: 246[0]: { ... }\n",
- RunUn());
+ EXPECT_EQ(
+ "added: 242[0]: \"cat\"\n"
+ "added: 246[0]: { ... }\n",
+ RunUn());
}
TEST_F(ComparisonTest, RepeatedSetFieldTest) {
@@ -2663,55 +2712,50 @@
proto1_.add_repeatedgroup()->set_a(907);
proto1_.add_repeatedgroup()->set_a(909);
- EXPECT_EQ("moved: repeatedgroup[2] -> repeatedgroup[1] : { a: 907 }\n"
- "moved: repeatedgroup[3] -> repeatedgroup[0] : { a: 909 }\n"
- "deleted: repeatedgroup[0]: { a: 317 }\n"
- "deleted: repeatedgroup[1]: { a: 904 }\n",
- Run());
+ EXPECT_EQ(
+ "moved: repeatedgroup[2] -> repeatedgroup[1] : { a: 907 }\n"
+ "moved: repeatedgroup[3] -> repeatedgroup[0] : { a: 909 }\n"
+ "deleted: repeatedgroup[0]: { a: 317 }\n"
+ "deleted: repeatedgroup[1]: { a: 904 }\n",
+ Run());
}
// Embedded message tests.
TEST_F(ComparisonTest, EmbeddedAdditionTest) {
proto1_.mutable_optional_nested_message()->clear_bb();
- EXPECT_EQ("added: optional_nested_message.bb: 118\n",
- Run());
+ EXPECT_EQ("added: optional_nested_message.bb: 118\n", Run());
}
TEST_F(ComparisonTest, EmbeddedDeletionTest) {
proto2_.mutable_optional_nested_message()->clear_bb();
- EXPECT_EQ("deleted: optional_nested_message.bb: 118\n",
- Run());
+ EXPECT_EQ("deleted: optional_nested_message.bb: 118\n", Run());
}
TEST_F(ComparisonTest, EmbeddedModificationTest) {
proto1_.mutable_optional_nested_message()->set_bb(2);
- EXPECT_EQ("modified: optional_nested_message.bb: 2 -> 118\n",
- Run());
+ EXPECT_EQ("modified: optional_nested_message.bb: 2 -> 118\n", Run());
}
TEST_F(ComparisonTest, EmbeddedFullAdditionTest) {
proto1_.clear_optional_nested_message();
- EXPECT_EQ("added: optional_nested_message: { bb: 118 }\n",
- Run());
+ EXPECT_EQ("added: optional_nested_message: { bb: 118 }\n", Run());
}
TEST_F(ComparisonTest, EmbeddedPartialAdditionTest) {
proto1_.clear_optional_nested_message();
proto2_.mutable_optional_nested_message()->clear_bb();
- EXPECT_EQ("added: optional_nested_message: { }\n",
- Run());
+ EXPECT_EQ("added: optional_nested_message: { }\n", Run());
}
TEST_F(ComparisonTest, EmbeddedFullDeletionTest) {
proto2_.clear_optional_nested_message();
- EXPECT_EQ("deleted: optional_nested_message: { bb: 118 }\n",
- Run());
+ EXPECT_EQ("deleted: optional_nested_message: { bb: 118 }\n", Run());
}
// Repeated element tests.
@@ -2730,10 +2774,11 @@
proto2_.add_repeated_int32(502);
proto2_.add_repeated_int32(504);
- EXPECT_EQ("modified: repeated_int32[1]: 501 -> 509\n"
- "modified: repeated_int32[3]: 503 -> 504\n"
- "deleted: repeated_int32[4]: 500\n",
- Run());
+ EXPECT_EQ(
+ "modified: repeated_int32[1]: 501 -> 509\n"
+ "modified: repeated_int32[3]: 503 -> 504\n"
+ "deleted: repeated_int32[4]: 500\n",
+ Run());
}
TEST_F(ComparisonTest, BasicRepeatedTest_SetOption) {
@@ -2753,13 +2798,14 @@
proto2_.add_repeated_int32(502);
proto2_.add_repeated_int32(504);
- EXPECT_EQ("moved: repeated_int32[1] -> repeated_int32[3] : 502\n"
- "moved: repeated_int32[3] -> repeated_int32[0] : 500\n"
- "added: repeated_int32[1]: 509\n"
- "added: repeated_int32[4]: 504\n"
- "deleted: repeated_int32[0]: 501\n"
- "deleted: repeated_int32[4]: 500\n",
- Run());
+ EXPECT_EQ(
+ "moved: repeated_int32[1] -> repeated_int32[3] : 502\n"
+ "moved: repeated_int32[3] -> repeated_int32[0] : 500\n"
+ "added: repeated_int32[1]: 509\n"
+ "added: repeated_int32[4]: 504\n"
+ "deleted: repeated_int32[0]: 501\n"
+ "deleted: repeated_int32[4]: 500\n",
+ Run());
}
TEST_F(ComparisonTest, BasicRepeatedTest_SetField) {
@@ -2779,13 +2825,14 @@
proto2_.add_repeated_int32(502);
proto2_.add_repeated_int32(504);
- EXPECT_EQ("moved: repeated_int32[1] -> repeated_int32[3] : 502\n"
- "moved: repeated_int32[3] -> repeated_int32[0] : 500\n"
- "added: repeated_int32[1]: 509\n"
- "added: repeated_int32[4]: 504\n"
- "deleted: repeated_int32[0]: 501\n"
- "deleted: repeated_int32[4]: 500\n",
- Run());
+ EXPECT_EQ(
+ "moved: repeated_int32[1] -> repeated_int32[3] : 502\n"
+ "moved: repeated_int32[3] -> repeated_int32[0] : 500\n"
+ "added: repeated_int32[1]: 509\n"
+ "added: repeated_int32[4]: 504\n"
+ "deleted: repeated_int32[0]: 501\n"
+ "deleted: repeated_int32[4]: 500\n",
+ Run());
}
// Multiple action tests.
@@ -2793,18 +2840,20 @@
proto1_.clear_optional_int32();
proto2_.clear_optional_int64();
- EXPECT_EQ("added: optional_int32: 101\n"
- "deleted: optional_int64: 102\n",
- Run());
+ EXPECT_EQ(
+ "added: optional_int32: 101\n"
+ "deleted: optional_int64: 102\n",
+ Run());
}
TEST_F(ComparisonTest, AddDelete_FieldOrderingTest) {
orderings_proto1_.ClearExtension(unittest::my_extension_string);
orderings_proto2_.clear_my_int();
- EXPECT_EQ("deleted: my_int: 1\n"
- "added: (protobuf_unittest.my_extension_string): \"bar\"\n",
- RunOrder());
+ EXPECT_EQ(
+ "deleted: my_int: 1\n"
+ "added: (protobuf_unittest.my_extension_string): \"bar\"\n",
+ RunOrder());
}
TEST_F(ComparisonTest, AllThreeTest) {
@@ -2812,10 +2861,11 @@
proto2_.clear_optional_float();
proto2_.set_optional_string("hello world!");
- EXPECT_EQ("added: optional_int32: 101\n"
- "deleted: optional_float: 111\n"
- "modified: optional_string: \"115\" -> \"hello world!\"\n",
- Run());
+ EXPECT_EQ(
+ "added: optional_int32: 101\n"
+ "deleted: optional_float: 111\n"
+ "modified: optional_string: \"115\" -> \"hello world!\"\n",
+ Run());
}
TEST_F(ComparisonTest, SandwhichTest) {
@@ -2824,10 +2874,11 @@
proto2_.clear_optional_uint64();
- EXPECT_EQ("added: optional_int64: 102\n"
- "added: optional_uint32: 103\n"
- "deleted: optional_uint64: 104\n",
- Run());
+ EXPECT_EQ(
+ "added: optional_int64: 102\n"
+ "added: optional_uint32: 103\n"
+ "deleted: optional_uint64: 104\n",
+ Run());
}
TEST_F(ComparisonTest, IgnoredNoChangeTest) {
@@ -2837,9 +2888,10 @@
ignore_field("v");
- EXPECT_EQ("ignored: v\n"
- "added: w: \"foo\"\n",
- RunDiff());
+ EXPECT_EQ(
+ "ignored: v\n"
+ "added: w: \"foo\"\n",
+ RunDiff());
}
TEST_F(ComparisonTest, IgnoredAddTest) {
@@ -2848,9 +2900,10 @@
ignore_field("v");
- EXPECT_EQ("ignored: v\n"
- "added: w: \"foo\"\n",
- RunDiff());
+ EXPECT_EQ(
+ "ignored: v\n"
+ "added: w: \"foo\"\n",
+ RunDiff());
}
TEST_F(ComparisonTest, IgnoredDeleteTest) {
@@ -2859,9 +2912,10 @@
ignore_field("v");
- EXPECT_EQ("ignored: v\n"
- "added: w: \"foo\"\n",
- RunDiff());
+ EXPECT_EQ(
+ "ignored: v\n"
+ "added: w: \"foo\"\n",
+ RunDiff());
}
TEST_F(ComparisonTest, IgnoredModifyTest) {
@@ -2871,9 +2925,10 @@
ignore_field("v");
- EXPECT_EQ("ignored: v\n"
- "added: w: \"foo\"\n",
- RunDiff());
+ EXPECT_EQ(
+ "ignored: v\n"
+ "added: w: \"foo\"\n",
+ RunDiff());
}
TEST_F(ComparisonTest, IgnoredRepeatedAddTest) {
@@ -2888,9 +2943,10 @@
ignore_field("rv");
- EXPECT_EQ("ignored: rv\n"
- "added: w: \"foo\"\n",
- RunDiff());
+ EXPECT_EQ(
+ "ignored: rv\n"
+ "added: w: \"foo\"\n",
+ RunDiff());
}
TEST_F(ComparisonTest, IgnoredRepeatedDeleteTest) {
@@ -2905,9 +2961,10 @@
ignore_field("rv");
- EXPECT_EQ("ignored: rv\n"
- "added: w: \"foo\"\n",
- RunDiff());
+ EXPECT_EQ(
+ "ignored: rv\n"
+ "added: w: \"foo\"\n",
+ RunDiff());
}
TEST_F(ComparisonTest, IgnoredRepeatedModifyTest) {
@@ -2921,9 +2978,10 @@
ignore_field("rv");
- EXPECT_EQ("ignored: rv\n"
- "added: w: \"foo\"\n",
- RunDiff());
+ EXPECT_EQ(
+ "ignored: rv\n"
+ "added: w: \"foo\"\n",
+ RunDiff());
}
TEST_F(ComparisonTest, IgnoredWholeNestedMessage) {
@@ -2934,9 +2992,10 @@
ignore_field("m");
- EXPECT_EQ("added: w: \"foo\"\n"
- "ignored: m\n",
- RunDiff());
+ EXPECT_EQ(
+ "added: w: \"foo\"\n"
+ "ignored: m\n",
+ RunDiff());
}
TEST_F(ComparisonTest, IgnoredNestedField) {
@@ -2947,9 +3006,10 @@
ignore_field("m.c");
- EXPECT_EQ("added: w: \"foo\"\n"
- "ignored: m.c\n",
- RunDiff());
+ EXPECT_EQ(
+ "added: w: \"foo\"\n"
+ "ignored: m.c\n",
+ RunDiff());
}
TEST_F(ComparisonTest, IgnoredRepeatedNested) {
@@ -2962,10 +3022,11 @@
ignore_field("rm.c");
- EXPECT_EQ("ignored: rm[0].c\n"
- "ignored: rm[1].c\n"
- "added: w: \"foo\"\n",
- RunDiff());
+ EXPECT_EQ(
+ "ignored: rm[0].c\n"
+ "ignored: rm[1].c\n"
+ "added: w: \"foo\"\n",
+ RunDiff());
}
TEST_F(ComparisonTest, IgnoredNestedRepeated) {
@@ -2977,9 +3038,10 @@
ignore_field("m.rc");
- EXPECT_EQ("added: w: \"foo\"\n"
- "ignored: m.rc\n",
- RunDiff());
+ EXPECT_EQ(
+ "added: w: \"foo\"\n"
+ "ignored: m.rc\n",
+ RunDiff());
}
TEST_F(ComparisonTest, ExtensionTest) {
@@ -3111,8 +3173,8 @@
unittest::TestMap map_reflection1;
// By setting via reflection, data exists in repeated field.
- ASSERT_TRUE(parser.ParseFromString(
- "map_int32_foreign_message { key: 1 }", &map_reflection1));
+ ASSERT_TRUE(parser.ParseFromString("map_int32_foreign_message { key: 1 }",
+ &map_reflection1));
// During copy, data is synced from repeated field to map.
unittest::TestMap map_reflection2 = map_reflection1;
@@ -3224,11 +3286,9 @@
typedef util::MessageDifferencer MessageDifferencer;
protected:
- MatchingTest() {
- }
+ MatchingTest() {}
- ~MatchingTest() {
- }
+ ~MatchingTest() {}
std::string RunWithResult(MessageDifferencer* differencer,
const Message& msg1, const Message& msg2,
@@ -3385,7 +3445,7 @@
"moved: item[0].rm[1].rc[2] -> item[0].rm[0].rc[0] : 7\n"
"moved: item[0].rm[1] -> item[0].rm[0] : { c: 4 rc: 5 rc: 6 rc: 7 }\n"
"matched: item[0] : { rm { c: 1 rc: 2 rc: 3 }"
- " rm { c: 4 rc: 5 rc: 6 rc: 7 } }\n"
+ " rm { c: 4 rc: 5 rc: 6 rc: 7 } }\n"
"matched: item[1].rm[0].c : 8\n"
"moved: item[1].rm[0].rc[0] -> item[1].rm[0].rc[1] : 10\n"
"moved: item[1].rm[0].rc[1] -> item[1].rm[0].rc[2] : 11\n"
@@ -3464,13 +3524,13 @@
"added: item[0].rm[0].rc[1]: 8\n"
"deleted: item[0].rm[1].rc[1]: 7\n"
"modified: item[0].rm[1] -> item[0].rm[0]: { c: 5 rc: 6 rc: 7 rc: 8 } ->"
- " { c: 5 rc: 8 rc: 8 rc: 6 }\n"
+ " { c: 5 rc: 8 rc: 8 rc: 6 }\n"
"added: item[0].rm[1]: { c: 3 rc: 2 rc: 4 }\n"
"deleted: item[0].rm[0]: { c: 2 rc: 3 rc: 4 }\n"
"modified: item[0]: { a: 1 rm { c: 2 rc: 3 rc: 4 }"
- " rm { c: 5 rc: 6 rc: 7 rc: 8 } } ->"
- " { a: 1 rm { c: 5 rc: 8 rc: 8 rc: 6 }"
- " rm { c: 3 rc: 2 rc: 4 } }\n"
+ " rm { c: 5 rc: 6 rc: 7 rc: 8 } } ->"
+ " { a: 1 rm { c: 5 rc: 8 rc: 8 rc: 6 }"
+ " rm { c: 3 rc: 2 rc: 4 } }\n"
"matched: item[1].a : 9\n"
"matched: item[1].rm[0].c : 10\n"
"moved: item[1].rm[0].rc[0] -> item[1].rm[0].rc[1] : 11\n"
@@ -3513,20 +3573,20 @@
EXPECT_EQ(
"matched: (protobuf_unittest.repeated_nested_message_extension)[0].bb ->"
- " (protobuf_unittest.repeated_nested_message_extension)[2].bb : 7\n"
+ " (protobuf_unittest.repeated_nested_message_extension)[2].bb : 7\n"
"moved: (protobuf_unittest.repeated_nested_message_extension)[0] ->"
- " (protobuf_unittest.repeated_nested_message_extension)[2] :"
- " { bb: 7 }\n"
+ " (protobuf_unittest.repeated_nested_message_extension)[2] :"
+ " { bb: 7 }\n"
"matched: (protobuf_unittest.repeated_nested_message_extension)[1].bb :"
- " 13\n"
+ " 13\n"
"matched: (protobuf_unittest.repeated_nested_message_extension)[1] :"
- " { bb: 13 }\n"
+ " { bb: 13 }\n"
"matched: (protobuf_unittest.repeated_nested_message_extension)[2].bb ->"
- " (protobuf_unittest.repeated_nested_message_extension)[0].bb :"
- " 11\n"
+ " (protobuf_unittest.repeated_nested_message_extension)[0].bb :"
+ " 11\n"
"moved: (protobuf_unittest.repeated_nested_message_extension)[2] ->"
- " (protobuf_unittest.repeated_nested_message_extension)[0] :"
- " { bb: 11 }\n",
+ " (protobuf_unittest.repeated_nested_message_extension)[0] :"
+ " { bb: 11 }\n",
RunWithResult(&differencer, msg1, msg2, true));
}
diff --git a/src/google/protobuf/util/time_util.cc b/src/google/protobuf/util/time_util.cc
index 8f9d939..68a3e67 100644
--- a/src/google/protobuf/util/time_util.cc
+++ b/src/google/protobuf/util/time_util.cc
@@ -45,8 +45,8 @@
namespace protobuf {
namespace util {
-using google::protobuf::Timestamp;
using google::protobuf::Duration;
+using google::protobuf::Timestamp;
namespace {
static const int kNanosPerSecond = 1000000000;
diff --git a/src/google/protobuf/util/time_util.h b/src/google/protobuf/util/time_util.h
index bbda538..756e23b 100644
--- a/src/google/protobuf/util/time_util.h
+++ b/src/google/protobuf/util/time_util.h
@@ -224,15 +224,15 @@
return result -= d2;
}
// Multiplicative operators
-template<typename T>
+template <typename T>
inline Duration operator*(Duration d, T r) {
return d *= r;
}
-template<typename T>
+template <typename T>
inline Duration operator*(T r, Duration d) {
return d *= r;
}
-template<typename T>
+template <typename T>
inline Duration operator/(Duration d, T r) {
return d /= r;
}
diff --git a/src/google/protobuf/util/time_util_test.cc b/src/google/protobuf/util/time_util_test.cc
index 285740a..9d6c564 100644
--- a/src/google/protobuf/util/time_util_test.cc
+++ b/src/google/protobuf/util/time_util_test.cc
@@ -32,8 +32,8 @@
#include <ctime>
-#include <google/protobuf/timestamp.pb.h>
#include <google/protobuf/duration.pb.h>
+#include <google/protobuf/timestamp.pb.h>
#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
@@ -41,8 +41,8 @@
namespace protobuf {
namespace util {
-using google::protobuf::Timestamp;
using google::protobuf::Duration;
+using google::protobuf::Timestamp;
namespace {
diff --git a/src/google/protobuf/util/type_resolver_util.cc b/src/google/protobuf/util/type_resolver_util.cc
index 5c71918..b652f9f 100644
--- a/src/google/protobuf/util/type_resolver_util.cc
+++ b/src/google/protobuf/util/type_resolver_util.cc
@@ -40,6 +40,10 @@
#include <google/protobuf/stubs/status.h>
+// clang-format off
+#include <google/protobuf/port_def.inc>
+// clang-format on
+
namespace google {
namespace protobuf {
namespace util {
diff --git a/src/google/protobuf/util/type_resolver_util_test.cc b/src/google/protobuf/util/type_resolver_util_test.cc
index 42fb7f6..c453955 100644
--- a/src/google/protobuf/util/type_resolver_util_test.cc
+++ b/src/google/protobuf/util/type_resolver_util_test.cc
@@ -88,8 +88,8 @@
if (field == NULL) {
return false;
}
- return field->cardinality() == cardinality &&
- field->kind() == kind && field->number() == number;
+ return field->cardinality() == cardinality && field->kind() == kind &&
+ field->number() == number;
}
bool CheckFieldTypeUrl(const Type& type, const std::string& name,
@@ -177,156 +177,158 @@
TEST_F(DescriptorPoolTypeResolverTest, TestAllTypes) {
Type type;
- ASSERT_TRUE(resolver_->ResolveMessageType(
- GetTypeUrl<protobuf_unittest::TestAllTypes>(), &type).ok());
+ ASSERT_TRUE(resolver_
+ ->ResolveMessageType(
+ GetTypeUrl<protobuf_unittest::TestAllTypes>(), &type)
+ .ok());
// Check all optional fields.
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_INT32, "optional_int32", 1));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_INT64, "optional_int64", 2));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_UINT32, "optional_uint32", 3));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_UINT64, "optional_uint64", 4));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_SINT32, "optional_sint32", 5));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_SINT64, "optional_sint64", 6));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_FIXED32, "optional_fixed32", 7));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_FIXED64, "optional_fixed64", 8));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_SFIXED32, "optional_sfixed32", 9));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_SFIXED64, "optional_sfixed64", 10));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_FLOAT, "optional_float", 11));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_DOUBLE, "optional_double", 12));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_BOOL, "optional_bool", 13));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_STRING, "optional_string", 14));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_BYTES, "optional_bytes", 15));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_INT32,
+ "optional_int32", 1));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_INT64,
+ "optional_int64", 2));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_UINT32,
+ "optional_uint32", 3));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_UINT64,
+ "optional_uint64", 4));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_SINT32,
+ "optional_sint32", 5));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_SINT64,
+ "optional_sint64", 6));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_FIXED32,
+ "optional_fixed32", 7));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_FIXED64,
+ "optional_fixed64", 8));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_SFIXED32,
+ "optional_sfixed32", 9));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_SFIXED64,
+ "optional_sfixed64", 10));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_FLOAT,
+ "optional_float", 11));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_DOUBLE,
+ "optional_double", 12));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_BOOL,
+ "optional_bool", 13));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_STRING,
+ "optional_string", 14));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_BYTES,
+ "optional_bytes", 15));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_GROUP, "optionalgroup", 16));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_GROUP,
+ "optionalgroup", 16));
EXPECT_TRUE(CheckFieldTypeUrl(
type, "optionalgroup",
GetTypeUrl<protobuf_unittest::TestAllTypes::OptionalGroup>()));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_MESSAGE, "optional_nested_message", 18));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_MESSAGE, "optional_foreign_message", 19));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_MESSAGE,
+ "optional_nested_message", 18));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_MESSAGE,
+ "optional_foreign_message", 19));
EXPECT_TRUE(CheckFieldTypeUrl(
type, "optional_nested_message",
GetTypeUrl<protobuf_unittest::TestAllTypes::NestedMessage>()));
- EXPECT_TRUE(CheckFieldTypeUrl(
- type, "optional_foreign_message",
- GetTypeUrl<protobuf_unittest::ForeignMessage>()));
+ EXPECT_TRUE(CheckFieldTypeUrl(type, "optional_foreign_message",
+ GetTypeUrl<protobuf_unittest::ForeignMessage>()));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_ENUM, "optional_nested_enum", 21));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_ENUM, "optional_foreign_enum", 22));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_ENUM,
+ "optional_nested_enum", 21));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_ENUM,
+ "optional_foreign_enum", 22));
- EXPECT_TRUE(CheckFieldTypeUrl(
- type, "optional_nested_enum",
- GetTypeUrl("protobuf_unittest.TestAllTypes.NestedEnum")));
- EXPECT_TRUE(CheckFieldTypeUrl(
- type, "optional_foreign_enum",
- GetTypeUrl("protobuf_unittest.ForeignEnum")));
+ EXPECT_TRUE(
+ CheckFieldTypeUrl(type, "optional_nested_enum",
+ GetTypeUrl("protobuf_unittest.TestAllTypes.NestedEnum")));
+ EXPECT_TRUE(CheckFieldTypeUrl(type, "optional_foreign_enum",
+ GetTypeUrl("protobuf_unittest.ForeignEnum")));
// Check all repeated fields.
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_INT32, "repeated_int32", 31));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_INT64, "repeated_int64", 32));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_UINT32, "repeated_uint32", 33));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_UINT64, "repeated_uint64", 34));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_SINT32, "repeated_sint32", 35));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_SINT64, "repeated_sint64", 36));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_FIXED32, "repeated_fixed32", 37));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_FIXED64, "repeated_fixed64", 38));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_SFIXED32, "repeated_sfixed32", 39));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_SFIXED64, "repeated_sfixed64", 40));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_FLOAT, "repeated_float", 41));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_DOUBLE, "repeated_double", 42));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_BOOL, "repeated_bool", 43));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_STRING, "repeated_string", 44));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_BYTES, "repeated_bytes", 45));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_INT32,
+ "repeated_int32", 31));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_INT64,
+ "repeated_int64", 32));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_UINT32,
+ "repeated_uint32", 33));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_UINT64,
+ "repeated_uint64", 34));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_SINT32,
+ "repeated_sint32", 35));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_SINT64,
+ "repeated_sint64", 36));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_FIXED32,
+ "repeated_fixed32", 37));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_FIXED64,
+ "repeated_fixed64", 38));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_SFIXED32,
+ "repeated_sfixed32", 39));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_SFIXED64,
+ "repeated_sfixed64", 40));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_FLOAT,
+ "repeated_float", 41));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_DOUBLE,
+ "repeated_double", 42));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_BOOL,
+ "repeated_bool", 43));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_STRING,
+ "repeated_string", 44));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_BYTES,
+ "repeated_bytes", 45));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_GROUP, "repeatedgroup", 46));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_GROUP,
+ "repeatedgroup", 46));
EXPECT_TRUE(CheckFieldTypeUrl(
type, "repeatedgroup",
GetTypeUrl<protobuf_unittest::TestAllTypes::RepeatedGroup>()));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_MESSAGE, "repeated_nested_message", 48));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_MESSAGE, "repeated_foreign_message", 49));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_MESSAGE,
+ "repeated_nested_message", 48));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_MESSAGE,
+ "repeated_foreign_message", 49));
EXPECT_TRUE(CheckFieldTypeUrl(
type, "repeated_nested_message",
GetTypeUrl<protobuf_unittest::TestAllTypes::NestedMessage>()));
- EXPECT_TRUE(CheckFieldTypeUrl(
- type, "repeated_foreign_message",
- GetTypeUrl<protobuf_unittest::ForeignMessage>()));
+ EXPECT_TRUE(CheckFieldTypeUrl(type, "repeated_foreign_message",
+ GetTypeUrl<protobuf_unittest::ForeignMessage>()));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_ENUM, "repeated_nested_enum", 51));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_ENUM, "repeated_foreign_enum", 52));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_ENUM,
+ "repeated_nested_enum", 51));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_ENUM,
+ "repeated_foreign_enum", 52));
- EXPECT_TRUE(CheckFieldTypeUrl(
- type, "repeated_nested_enum",
- GetTypeUrl("protobuf_unittest.TestAllTypes.NestedEnum")));
- EXPECT_TRUE(CheckFieldTypeUrl(
- type, "repeated_foreign_enum",
- GetTypeUrl("protobuf_unittest.ForeignEnum")));
+ EXPECT_TRUE(
+ CheckFieldTypeUrl(type, "repeated_nested_enum",
+ GetTypeUrl("protobuf_unittest.TestAllTypes.NestedEnum")));
+ EXPECT_TRUE(CheckFieldTypeUrl(type, "repeated_foreign_enum",
+ GetTypeUrl("protobuf_unittest.ForeignEnum")));
}
TEST_F(DescriptorPoolTypeResolverTest, TestPackedField) {
Type type;
- ASSERT_TRUE(resolver_->ResolveMessageType(
- GetTypeUrl<protobuf_unittest::TestPackedTypes>(), &type).ok());
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_INT32, "packed_int32", 90));
+ ASSERT_TRUE(resolver_
+ ->ResolveMessageType(
+ GetTypeUrl<protobuf_unittest::TestPackedTypes>(), &type)
+ .ok());
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_INT32,
+ "packed_int32", 90));
EXPECT_TRUE(IsPacked(type, "packed_int32"));
}
TEST_F(DescriptorPoolTypeResolverTest, TestOneof) {
Type type;
- ASSERT_TRUE(resolver_->ResolveMessageType(
- GetTypeUrl<protobuf_unittest::TestAllTypes>(), &type).ok());
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_UINT32, "oneof_uint32", 111));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_MESSAGE, "oneof_nested_message", 112));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_STRING, "oneof_string", 113));
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL,
- Field::TYPE_BYTES, "oneof_bytes", 114));
+ ASSERT_TRUE(resolver_
+ ->ResolveMessageType(
+ GetTypeUrl<protobuf_unittest::TestAllTypes>(), &type)
+ .ok());
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_UINT32,
+ "oneof_uint32", 111));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_MESSAGE,
+ "oneof_nested_message", 112));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_STRING,
+ "oneof_string", 113));
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_OPTIONAL, Field::TYPE_BYTES,
+ "oneof_bytes", 114));
EXPECT_TRUE(FieldInOneof(type, "oneof_uint32", "oneof_field"));
EXPECT_TRUE(FieldInOneof(type, "oneof_nested_message", "oneof_field"));
EXPECT_TRUE(FieldInOneof(type, "oneof_string", "oneof_field"));
@@ -335,17 +337,21 @@
TEST_F(DescriptorPoolTypeResolverTest, TestMap) {
Type type;
- ASSERT_TRUE(resolver_->ResolveMessageType(
- GetTypeUrl<protobuf_unittest::TestMap>(), &type).ok());
- EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED,
- Field::TYPE_MESSAGE, "map_int32_int32", 1));
+ ASSERT_TRUE(
+ resolver_
+ ->ResolveMessageType(GetTypeUrl<protobuf_unittest::TestMap>(), &type)
+ .ok());
+ EXPECT_TRUE(HasField(type, Field::CARDINALITY_REPEATED, Field::TYPE_MESSAGE,
+ "map_int32_int32", 1));
EXPECT_TRUE(CheckFieldTypeUrl(
type, "map_int32_int32",
GetTypeUrl("protobuf_unittest.TestMap.MapInt32Int32Entry")));
- ASSERT_TRUE(resolver_->ResolveMessageType(
- GetTypeUrl("protobuf_unittest.TestMap.MapInt32Int32Entry"),
- &type).ok());
+ ASSERT_TRUE(
+ resolver_
+ ->ResolveMessageType(
+ GetTypeUrl("protobuf_unittest.TestMap.MapInt32Int32Entry"), &type)
+ .ok());
EXPECT_TRUE(HasBoolOption(type.options(), "map_entry", true));
}
@@ -377,8 +383,11 @@
TEST_F(DescriptorPoolTypeResolverTest, TestEnum) {
Enum type;
- ASSERT_TRUE(resolver_->ResolveEnumType(
- GetTypeUrl("protobuf_unittest.TestAllTypes.NestedEnum"), &type).ok());
+ ASSERT_TRUE(
+ resolver_
+ ->ResolveEnumType(
+ GetTypeUrl("protobuf_unittest.TestAllTypes.NestedEnum"), &type)
+ .ok());
EnumHasValue(type, "FOO", 1);
EnumHasValue(type, "BAR", 2);
EnumHasValue(type, "BAZ", 3);
@@ -413,14 +422,16 @@
TEST_F(DescriptorPoolTypeResolverTest, TestJsonName) {
Type type;
- ASSERT_TRUE(resolver_->ResolveMessageType(
- GetTypeUrl<protobuf_unittest::TestAllTypes>(), &type)
+ ASSERT_TRUE(resolver_
+ ->ResolveMessageType(
+ GetTypeUrl<protobuf_unittest::TestAllTypes>(), &type)
.ok());
EXPECT_EQ("optionalInt32", FindField(type, "optional_int32")->json_name());
- ASSERT_TRUE(resolver_->ResolveMessageType(
- GetTypeUrl<proto3::TestCustomJsonName>(), &type)
- .ok());
+ ASSERT_TRUE(
+ resolver_
+ ->ResolveMessageType(GetTypeUrl<proto3::TestCustomJsonName>(), &type)
+ .ok());
EXPECT_EQ("@value", FindField(type, "value")->json_name());
}
diff --git a/src/google/protobuf/wire_format.cc b/src/google/protobuf/wire_format.cc
index 7a25207..fe0714b 100644
--- a/src/google/protobuf/wire_format.cc
+++ b/src/google/protobuf/wire_format.cc
@@ -68,8 +68,8 @@
// ===================================================================
-bool UnknownFieldSetFieldSkipper::SkipField(
- io::CodedInputStream* input, uint32 tag) {
+bool UnknownFieldSetFieldSkipper::SkipField(io::CodedInputStream* input,
+ uint32 tag) {
return WireFormat::SkipField(input, tag, unknown_fields_);
}
@@ -77,8 +77,7 @@
return WireFormat::SkipMessage(input, unknown_fields_);
}
-void UnknownFieldSetFieldSkipper::SkipUnknownEnum(
- int field_number, int value) {
+void UnknownFieldSetFieldSkipper::SkipUnknownEnum(int field_number, int value) {
unknown_fields_->AddVarint(field_number, value);
}
@@ -116,15 +115,16 @@
}
case WireFormatLite::WIRETYPE_START_GROUP: {
if (!input->IncrementRecursionDepth()) return false;
- if (!SkipMessage(input, (unknown_fields == NULL) ?
- NULL : unknown_fields->AddGroup(number))) {
+ if (!SkipMessage(input, (unknown_fields == NULL)
+ ? NULL
+ : unknown_fields->AddGroup(number))) {
return false;
}
input->DecrementRecursionDepth();
// Check that the ending tag matched the starting tag.
- if (!input->LastTagWas(WireFormatLite::MakeTag(
- WireFormatLite::GetTagFieldNumber(tag),
- WireFormatLite::WIRETYPE_END_GROUP))) {
+ if (!input->LastTagWas(
+ WireFormatLite::MakeTag(WireFormatLite::GetTagFieldNumber(tag),
+ WireFormatLite::WIRETYPE_END_GROUP))) {
return false;
}
return true;
@@ -188,63 +188,61 @@
return true;
}
-
void WireFormat::SerializeUnknownFields(const UnknownFieldSet& unknown_fields,
io::CodedOutputStream* output) {
for (int i = 0; i < unknown_fields.field_count(); i++) {
const UnknownField& field = unknown_fields.field(i);
switch (field.type()) {
case UnknownField::TYPE_VARINT:
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_VARINT));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_VARINT));
output->WriteVarint64(field.varint());
break;
case UnknownField::TYPE_FIXED32:
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_FIXED32));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_FIXED32));
output->WriteLittleEndian32(field.fixed32());
break;
case UnknownField::TYPE_FIXED64:
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_FIXED64));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_FIXED64));
output->WriteLittleEndian64(field.fixed64());
break;
case UnknownField::TYPE_LENGTH_DELIMITED:
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
output->WriteVarint32(field.length_delimited().size());
output->WriteRawMaybeAliased(field.length_delimited().data(),
field.length_delimited().size());
break;
case UnknownField::TYPE_GROUP:
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_START_GROUP));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_START_GROUP));
SerializeUnknownFields(field.group(), output);
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_END_GROUP));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_END_GROUP));
break;
}
}
}
uint8* WireFormat::SerializeUnknownFieldsToArray(
- const UnknownFieldSet& unknown_fields,
- uint8* target) {
+ const UnknownFieldSet& unknown_fields, uint8* target) {
for (int i = 0; i < unknown_fields.field_count(); i++) {
const UnknownField& field = unknown_fields.field(i);
switch (field.type()) {
case UnknownField::TYPE_VARINT:
- target = WireFormatLite::WriteInt64ToArray(
- field.number(), field.varint(), target);
+ target = WireFormatLite::WriteInt64ToArray(field.number(),
+ field.varint(), target);
break;
case UnknownField::TYPE_FIXED32:
- target = WireFormatLite::WriteFixed32ToArray(
- field.number(), field.fixed32(), target);
+ target = WireFormatLite::WriteFixed32ToArray(field.number(),
+ field.fixed32(), target);
break;
case UnknownField::TYPE_FIXED64:
- target = WireFormatLite::WriteFixed64ToArray(
- field.number(), field.fixed64(), target);
+ target = WireFormatLite::WriteFixed64ToArray(field.number(),
+ field.fixed64(), target);
break;
case UnknownField::TYPE_LENGTH_DELIMITED:
target = WireFormatLite::WriteBytesToArray(
@@ -263,8 +261,7 @@
}
void WireFormat::SerializeUnknownMessageSetItems(
- const UnknownFieldSet& unknown_fields,
- io::CodedOutputStream* output) {
+ const UnknownFieldSet& unknown_fields, io::CodedOutputStream* output) {
for (int i = 0; i < unknown_fields.field_count(); i++) {
const UnknownField& field = unknown_fields.field(i);
// The only unknown fields that are allowed to exist in a MessageSet are
@@ -288,8 +285,7 @@
}
uint8* WireFormat::SerializeUnknownMessageSetItemsToArray(
- const UnknownFieldSet& unknown_fields,
- uint8* target) {
+ const UnknownFieldSet& unknown_fields, uint8* target) {
for (int i = 0; i < unknown_fields.field_count(); i++) {
const UnknownField& field = unknown_fields.field(i);
@@ -303,8 +299,8 @@
// Write type ID.
target = io::CodedOutputStream::WriteTagToArray(
WireFormatLite::kMessageSetTypeIdTag, target);
- target = io::CodedOutputStream::WriteVarint32ToArray(
- field.number(), target);
+ target =
+ io::CodedOutputStream::WriteVarint32ToArray(field.number(), target);
// Write message.
target = io::CodedOutputStream::WriteTagToArray(
@@ -328,39 +324,33 @@
switch (field.type()) {
case UnknownField::TYPE_VARINT:
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_VARINT));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_VARINT));
size += io::CodedOutputStream::VarintSize64(field.varint());
break;
case UnknownField::TYPE_FIXED32:
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_FIXED32));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_FIXED32));
size += sizeof(int32);
break;
case UnknownField::TYPE_FIXED64:
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_FIXED64));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_FIXED64));
size += sizeof(int64);
break;
case UnknownField::TYPE_LENGTH_DELIMITED:
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
size += io::CodedOutputStream::VarintSize32(
field.length_delimited().size());
size += field.length_delimited().size();
break;
case UnknownField::TYPE_GROUP:
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_START_GROUP));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_START_GROUP));
size += ComputeUnknownFieldsSize(field.group());
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_END_GROUP));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_END_GROUP));
break;
}
}
@@ -396,7 +386,7 @@
const Descriptor* descriptor = message->GetDescriptor();
const Reflection* message_reflection = message->GetReflection();
- while(true) {
+ while (true) {
uint32 tag = input->ReadTag();
if (tag == 0) {
// End of input. This is a valid place to end, so return true.
@@ -420,15 +410,14 @@
if (input->GetExtensionPool() == NULL) {
field = message_reflection->FindKnownExtensionByNumber(field_number);
} else {
- field = input->GetExtensionPool()
- ->FindExtensionByNumber(descriptor, field_number);
+ field = input->GetExtensionPool()->FindExtensionByNumber(
+ descriptor, field_number);
}
}
// If that failed, but we're a MessageSet, and this is the tag for a
// MessageSet item, then parse that.
- if (field == NULL &&
- descriptor->options().message_set_wire_format() &&
+ if (field == NULL && descriptor->options().message_set_wire_format() &&
tag == WireFormatLite::kMessageSetItemStartTag) {
if (!ParseAndMergeMessageSetItem(input, message)) {
return false;
@@ -448,8 +437,8 @@
UnknownFieldSet* unknown_fields) {
uint32 length;
if (!input->ReadVarint32(&length)) return false;
- return input->ReadString(
- unknown_fields->AddLengthDelimited(field_number), length);
+ return input->ReadString(unknown_fields->AddLengthDelimited(field_number),
+ length);
}
bool WireFormat::ParseAndMergeMessageSetField(uint32 field_number,
@@ -480,9 +469,8 @@
bool WireFormat::ParseAndMergeField(
uint32 tag,
- const FieldDescriptor* field, // May be NULL for unknown
- Message* message,
- io::CodedInputStream* input) {
+ const FieldDescriptor* field, // May be NULL for unknown
+ Message* message, io::CodedInputStream* input) {
const Reflection* message_reflection = message->GetReflection();
enum { UNKNOWN, NORMAL_FORMAT, PACKED_FORMAT } value_format;
@@ -494,7 +482,7 @@
value_format = NORMAL_FORMAT;
} else if (field->is_packable() &&
WireFormatLite::GetTagWireType(tag) ==
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
value_format = PACKED_FORMAT;
} else {
// We don't recognize this field. Either the field number is unknown
@@ -512,30 +500,31 @@
switch (field->type()) {
#define HANDLE_PACKED_TYPE(TYPE, CPPTYPE, CPPTYPE_METHOD) \
- case FieldDescriptor::TYPE_##TYPE: { \
- while (input->BytesUntilLimit() > 0) { \
- CPPTYPE value; \
- if (!WireFormatLite::ReadPrimitive< \
- CPPTYPE, WireFormatLite::TYPE_##TYPE>(input, &value)) \
- return false; \
- message_reflection->Add##CPPTYPE_METHOD(message, field, value); \
- } \
- break; \
- }
+ case FieldDescriptor::TYPE_##TYPE: { \
+ while (input->BytesUntilLimit() > 0) { \
+ CPPTYPE value; \
+ if (!WireFormatLite::ReadPrimitive<CPPTYPE, \
+ WireFormatLite::TYPE_##TYPE>(input, \
+ &value)) \
+ return false; \
+ message_reflection->Add##CPPTYPE_METHOD(message, field, value); \
+ } \
+ break; \
+ }
- HANDLE_PACKED_TYPE( INT32, int32, Int32)
- HANDLE_PACKED_TYPE( INT64, int64, Int64)
- HANDLE_PACKED_TYPE(SINT32, int32, Int32)
- HANDLE_PACKED_TYPE(SINT64, int64, Int64)
+ HANDLE_PACKED_TYPE(INT32, int32, Int32)
+ HANDLE_PACKED_TYPE(INT64, int64, Int64)
+ HANDLE_PACKED_TYPE(SINT32, int32, Int32)
+ HANDLE_PACKED_TYPE(SINT64, int64, Int64)
HANDLE_PACKED_TYPE(UINT32, uint32, UInt32)
HANDLE_PACKED_TYPE(UINT64, uint64, UInt64)
- HANDLE_PACKED_TYPE( FIXED32, uint32, UInt32)
- HANDLE_PACKED_TYPE( FIXED64, uint64, UInt64)
- HANDLE_PACKED_TYPE(SFIXED32, int32, Int32)
- HANDLE_PACKED_TYPE(SFIXED64, int64, Int64)
+ HANDLE_PACKED_TYPE(FIXED32, uint32, UInt32)
+ HANDLE_PACKED_TYPE(FIXED64, uint64, UInt64)
+ HANDLE_PACKED_TYPE(SFIXED32, int32, Int32)
+ HANDLE_PACKED_TYPE(SFIXED64, int64, Int64)
- HANDLE_PACKED_TYPE(FLOAT , float , Float )
+ HANDLE_PACKED_TYPE(FLOAT, float, Float)
HANDLE_PACKED_TYPE(DOUBLE, double, Double)
HANDLE_PACKED_TYPE(BOOL, bool, Bool)
@@ -545,7 +534,8 @@
while (input->BytesUntilLimit() > 0) {
int value;
if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
- input, &value)) return false;
+ input, &value))
+ return false;
if (message->GetDescriptor()->file()->syntax() ==
FileDescriptor::SYNTAX_PROTO3) {
message_reflection->AddEnumValue(message, field, value);
@@ -558,10 +548,8 @@
// The enum value is not one of the known values. Add it to the
// UnknownFieldSet.
int64 sign_extended_value = static_cast<int64>(value);
- message_reflection->MutableUnknownFields(message)
- ->AddVarint(
- WireFormatLite::GetTagFieldNumber(tag),
- sign_extended_value);
+ message_reflection->MutableUnknownFields(message)->AddVarint(
+ WireFormatLite::GetTagFieldNumber(tag), sign_extended_value);
}
}
}
@@ -584,32 +572,32 @@
// Non-packed value (value_format == NORMAL_FORMAT)
switch (field->type()) {
#define HANDLE_TYPE(TYPE, CPPTYPE, CPPTYPE_METHOD) \
- case FieldDescriptor::TYPE_##TYPE: { \
- CPPTYPE value; \
- if (!WireFormatLite::ReadPrimitive< \
- CPPTYPE, WireFormatLite::TYPE_##TYPE>(input, &value)) \
- return false; \
- if (field->is_repeated()) { \
- message_reflection->Add##CPPTYPE_METHOD(message, field, value); \
- } else { \
- message_reflection->Set##CPPTYPE_METHOD(message, field, value); \
- } \
- break; \
- }
+ case FieldDescriptor::TYPE_##TYPE: { \
+ CPPTYPE value; \
+ if (!WireFormatLite::ReadPrimitive<CPPTYPE, WireFormatLite::TYPE_##TYPE>( \
+ input, &value)) \
+ return false; \
+ if (field->is_repeated()) { \
+ message_reflection->Add##CPPTYPE_METHOD(message, field, value); \
+ } else { \
+ message_reflection->Set##CPPTYPE_METHOD(message, field, value); \
+ } \
+ break; \
+ }
- HANDLE_TYPE( INT32, int32, Int32)
- HANDLE_TYPE( INT64, int64, Int64)
- HANDLE_TYPE(SINT32, int32, Int32)
- HANDLE_TYPE(SINT64, int64, Int64)
+ HANDLE_TYPE(INT32, int32, Int32)
+ HANDLE_TYPE(INT64, int64, Int64)
+ HANDLE_TYPE(SINT32, int32, Int32)
+ HANDLE_TYPE(SINT64, int64, Int64)
HANDLE_TYPE(UINT32, uint32, UInt32)
HANDLE_TYPE(UINT64, uint64, UInt64)
- HANDLE_TYPE( FIXED32, uint32, UInt32)
- HANDLE_TYPE( FIXED64, uint64, UInt64)
- HANDLE_TYPE(SFIXED32, int32, Int32)
- HANDLE_TYPE(SFIXED64, int64, Int64)
+ HANDLE_TYPE(FIXED32, uint32, UInt32)
+ HANDLE_TYPE(FIXED64, uint64, UInt64)
+ HANDLE_TYPE(SFIXED32, int32, Int32)
+ HANDLE_TYPE(SFIXED64, int64, Int64)
- HANDLE_TYPE(FLOAT , float , Float )
+ HANDLE_TYPE(FLOAT, float, Float)
HANDLE_TYPE(DOUBLE, double, Double)
HANDLE_TYPE(BOOL, bool, Bool)
@@ -618,7 +606,8 @@
case FieldDescriptor::TYPE_ENUM: {
int value;
if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
- input, &value)) return false;
+ input, &value))
+ return false;
if (field->is_repeated()) {
message_reflection->AddEnumValue(message, field, value);
} else {
@@ -633,9 +622,9 @@
std::string value;
if (!WireFormatLite::ReadString(input, &value)) return false;
if (strict_utf8_check) {
- if (!WireFormatLite::VerifyUtf8String(
- value.data(), value.length(), WireFormatLite::PARSE,
- field->full_name().c_str())) {
+ if (!WireFormatLite::VerifyUtf8String(value.data(), value.length(),
+ WireFormatLite::PARSE,
+ field->full_name().c_str())) {
return false;
}
} else {
@@ -696,9 +685,8 @@
return true;
}
-bool WireFormat::ParseAndMergeMessageSetItem(
- io::CodedInputStream* input,
- Message* message) {
+bool WireFormat::ParseAndMergeMessageSetItem(io::CodedInputStream* input,
+ Message* message) {
struct MSReflective {
bool ParseField(int type_id, io::CodedInputStream* input) {
const FieldDescriptor* field =
@@ -720,9 +708,8 @@
// ===================================================================
-void WireFormat::SerializeWithCachedSizes(
- const Message& message,
- int size, io::CodedOutputStream* output) {
+void WireFormat::SerializeWithCachedSizes(const Message& message, int size,
+ io::CodedOutputStream* output) {
const Descriptor* descriptor = message.GetDescriptor();
const Reflection* message_reflection = message.GetReflection();
int expected_endpoint = output->ByteCount() + size;
@@ -746,14 +733,14 @@
SerializeUnknownMessageSetItems(
message_reflection->GetUnknownFields(message), output);
} else {
- SerializeUnknownFields(
- message_reflection->GetUnknownFields(message), output);
+ SerializeUnknownFields(message_reflection->GetUnknownFields(message),
+ output);
}
GOOGLE_CHECK_EQ(output->ByteCount(), expected_endpoint)
- << ": Protocol message serialized to a size different from what was "
- "originally expected. Perhaps it was modified by another thread "
- "during serialization?";
+ << ": Protocol message serialized to a size different from what was "
+ "originally expected. Perhaps it was modified by another thread "
+ "during serialization?";
}
static void SerializeMapKeyWithCachedSizes(const FieldDescriptor* field,
@@ -879,10 +866,9 @@
SerializeMapValueRefWithCachedSizes(value_field, value, output);
}
-void WireFormat::SerializeFieldWithCachedSizes(
- const FieldDescriptor* field,
- const Message& message,
- io::CodedOutputStream* output) {
+void WireFormat::SerializeFieldWithCachedSizes(const FieldDescriptor* field,
+ const Message& message,
+ io::CodedOutputStream* output) {
const Reflection* message_reflection = message.GetReflection();
if (field->is_extension() &&
@@ -956,67 +942,68 @@
const bool is_packed = field->is_packed();
if (is_packed && count > 0) {
WireFormatLite::WriteTag(field->number(),
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+ WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
const size_t data_size = FieldDataOnlyByteSize(field, message);
output->WriteVarint32(data_size);
}
for (int j = 0; j < count; j++) {
switch (field->type()) {
-#define HANDLE_PRIMITIVE_TYPE(TYPE, CPPTYPE, TYPE_METHOD, CPPTYPE_METHOD) \
- case FieldDescriptor::TYPE_##TYPE: { \
- const CPPTYPE value = field->is_repeated() ? \
- message_reflection->GetRepeated##CPPTYPE_METHOD( \
- message, field, j) : \
- message_reflection->Get##CPPTYPE_METHOD( \
- message, field); \
- if (is_packed) { \
- WireFormatLite::Write##TYPE_METHOD##NoTag(value, output); \
- } else { \
- WireFormatLite::Write##TYPE_METHOD(field->number(), value, output); \
- } \
- break; \
- }
+#define HANDLE_PRIMITIVE_TYPE(TYPE, CPPTYPE, TYPE_METHOD, CPPTYPE_METHOD) \
+ case FieldDescriptor::TYPE_##TYPE: { \
+ const CPPTYPE value = \
+ field->is_repeated() \
+ ? message_reflection->GetRepeated##CPPTYPE_METHOD(message, field, \
+ j) \
+ : message_reflection->Get##CPPTYPE_METHOD(message, field); \
+ if (is_packed) { \
+ WireFormatLite::Write##TYPE_METHOD##NoTag(value, output); \
+ } else { \
+ WireFormatLite::Write##TYPE_METHOD(field->number(), value, output); \
+ } \
+ break; \
+ }
- HANDLE_PRIMITIVE_TYPE( INT32, int32, Int32, Int32)
- HANDLE_PRIMITIVE_TYPE( INT64, int64, Int64, Int64)
- HANDLE_PRIMITIVE_TYPE(SINT32, int32, SInt32, Int32)
- HANDLE_PRIMITIVE_TYPE(SINT64, int64, SInt64, Int64)
+ HANDLE_PRIMITIVE_TYPE(INT32, int32, Int32, Int32)
+ HANDLE_PRIMITIVE_TYPE(INT64, int64, Int64, Int64)
+ HANDLE_PRIMITIVE_TYPE(SINT32, int32, SInt32, Int32)
+ HANDLE_PRIMITIVE_TYPE(SINT64, int64, SInt64, Int64)
HANDLE_PRIMITIVE_TYPE(UINT32, uint32, UInt32, UInt32)
HANDLE_PRIMITIVE_TYPE(UINT64, uint64, UInt64, UInt64)
- HANDLE_PRIMITIVE_TYPE( FIXED32, uint32, Fixed32, UInt32)
- HANDLE_PRIMITIVE_TYPE( FIXED64, uint64, Fixed64, UInt64)
- HANDLE_PRIMITIVE_TYPE(SFIXED32, int32, SFixed32, Int32)
- HANDLE_PRIMITIVE_TYPE(SFIXED64, int64, SFixed64, Int64)
+ HANDLE_PRIMITIVE_TYPE(FIXED32, uint32, Fixed32, UInt32)
+ HANDLE_PRIMITIVE_TYPE(FIXED64, uint64, Fixed64, UInt64)
+ HANDLE_PRIMITIVE_TYPE(SFIXED32, int32, SFixed32, Int32)
+ HANDLE_PRIMITIVE_TYPE(SFIXED64, int64, SFixed64, Int64)
- HANDLE_PRIMITIVE_TYPE(FLOAT , float , Float , Float )
+ HANDLE_PRIMITIVE_TYPE(FLOAT, float, Float, Float)
HANDLE_PRIMITIVE_TYPE(DOUBLE, double, Double, Double)
HANDLE_PRIMITIVE_TYPE(BOOL, bool, Bool, Bool)
#undef HANDLE_PRIMITIVE_TYPE
-#define HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD) \
- case FieldDescriptor::TYPE_##TYPE: \
- WireFormatLite::Write##TYPE_METHOD( \
- field->number(), \
- field->is_repeated() ? \
- (map_entries.empty() ? \
- message_reflection->GetRepeated##CPPTYPE_METHOD( \
- message, field, j) : \
- *map_entries[j]) : \
- message_reflection->Get##CPPTYPE_METHOD(message, field), \
- output); \
- break;
+#define HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD) \
+ case FieldDescriptor::TYPE_##TYPE: \
+ WireFormatLite::Write##TYPE_METHOD( \
+ field->number(), \
+ field->is_repeated() \
+ ? (map_entries.empty() \
+ ? message_reflection->GetRepeated##CPPTYPE_METHOD(message, \
+ field, j) \
+ : *map_entries[j]) \
+ : message_reflection->Get##CPPTYPE_METHOD(message, field), \
+ output); \
+ break;
- HANDLE_TYPE(GROUP , Group , Message)
+ HANDLE_TYPE(GROUP, Group, Message)
HANDLE_TYPE(MESSAGE, Message, Message)
#undef HANDLE_TYPE
case FieldDescriptor::TYPE_ENUM: {
- const EnumValueDescriptor* value = field->is_repeated() ?
- message_reflection->GetRepeatedEnum(message, field, j) :
- message_reflection->GetEnum(message, field);
+ const EnumValueDescriptor* value =
+ field->is_repeated()
+ ? message_reflection->GetRepeatedEnum(message, field, j)
+ : message_reflection->GetEnum(message, field);
if (is_packed) {
WireFormatLite::WriteEnumNoTag(value->number(), output);
} else {
@@ -1064,8 +1051,7 @@
}
void WireFormat::SerializeMessageSetItemWithCachedSizes(
- const FieldDescriptor* field,
- const Message& message,
+ const FieldDescriptor* field, const Message& message,
io::CodedOutputStream* output) {
const Reflection* message_reflection = message.GetReflection();
@@ -1112,18 +1098,17 @@
if (descriptor->options().message_set_wire_format()) {
our_size += ComputeUnknownMessageSetItemsSize(
- message_reflection->GetUnknownFields(message));
+ message_reflection->GetUnknownFields(message));
} else {
- our_size += ComputeUnknownFieldsSize(
- message_reflection->GetUnknownFields(message));
+ our_size +=
+ ComputeUnknownFieldsSize(message_reflection->GetUnknownFields(message));
}
return our_size;
}
-size_t WireFormat::FieldByteSize(
- const FieldDescriptor* field,
- const Message& message) {
+size_t WireFormat::FieldByteSize(const FieldDescriptor* field,
+ const Message& message) {
const Reflection* message_reflection = message.GetReflection();
if (field->is_extension() &&
@@ -1240,9 +1225,8 @@
return 0;
}
-size_t WireFormat::FieldDataOnlyByteSize(
- const FieldDescriptor* field,
- const Message& message) {
+size_t WireFormat::FieldDataOnlyByteSize(const FieldDescriptor* field,
+ const Message& message) {
const Reflection* message_reflection = message.GetReflection();
size_t data_size = 0;
@@ -1278,43 +1262,43 @@
}
switch (field->type()) {
-#define HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD) \
- case FieldDescriptor::TYPE_##TYPE: \
- if (field->is_repeated()) { \
- for (int j = 0; j < count; j++) { \
- data_size += WireFormatLite::TYPE_METHOD##Size( \
- message_reflection->GetRepeated##CPPTYPE_METHOD( \
- message, field, j)); \
- } \
- } else { \
- data_size += WireFormatLite::TYPE_METHOD##Size( \
- message_reflection->Get##CPPTYPE_METHOD(message, field)); \
- } \
- break;
+#define HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD) \
+ case FieldDescriptor::TYPE_##TYPE: \
+ if (field->is_repeated()) { \
+ for (int j = 0; j < count; j++) { \
+ data_size += WireFormatLite::TYPE_METHOD##Size( \
+ message_reflection->GetRepeated##CPPTYPE_METHOD(message, field, \
+ j)); \
+ } \
+ } else { \
+ data_size += WireFormatLite::TYPE_METHOD##Size( \
+ message_reflection->Get##CPPTYPE_METHOD(message, field)); \
+ } \
+ break;
-#define HANDLE_FIXED_TYPE(TYPE, TYPE_METHOD) \
- case FieldDescriptor::TYPE_##TYPE: \
- data_size += count * WireFormatLite::k##TYPE_METHOD##Size; \
- break;
+#define HANDLE_FIXED_TYPE(TYPE, TYPE_METHOD) \
+ case FieldDescriptor::TYPE_##TYPE: \
+ data_size += count * WireFormatLite::k##TYPE_METHOD##Size; \
+ break;
- HANDLE_TYPE( INT32, Int32, Int32)
- HANDLE_TYPE( INT64, Int64, Int64)
- HANDLE_TYPE(SINT32, SInt32, Int32)
- HANDLE_TYPE(SINT64, SInt64, Int64)
+ HANDLE_TYPE(INT32, Int32, Int32)
+ HANDLE_TYPE(INT64, Int64, Int64)
+ HANDLE_TYPE(SINT32, SInt32, Int32)
+ HANDLE_TYPE(SINT64, SInt64, Int64)
HANDLE_TYPE(UINT32, UInt32, UInt32)
HANDLE_TYPE(UINT64, UInt64, UInt64)
- HANDLE_FIXED_TYPE( FIXED32, Fixed32)
- HANDLE_FIXED_TYPE( FIXED64, Fixed64)
+ HANDLE_FIXED_TYPE(FIXED32, Fixed32)
+ HANDLE_FIXED_TYPE(FIXED64, Fixed64)
HANDLE_FIXED_TYPE(SFIXED32, SFixed32)
HANDLE_FIXED_TYPE(SFIXED64, SFixed64)
- HANDLE_FIXED_TYPE(FLOAT , Float )
+ HANDLE_FIXED_TYPE(FLOAT, Float)
HANDLE_FIXED_TYPE(DOUBLE, Double)
HANDLE_FIXED_TYPE(BOOL, Bool)
- HANDLE_TYPE(GROUP , Group , Message)
+ HANDLE_TYPE(GROUP, Group, Message)
HANDLE_TYPE(MESSAGE, Message, Message)
#undef HANDLE_TYPE
#undef HANDLE_FIXED_TYPE
@@ -1323,11 +1307,11 @@
if (field->is_repeated()) {
for (int j = 0; j < count; j++) {
data_size += WireFormatLite::EnumSize(
- message_reflection->GetRepeatedEnum(message, field, j)->number());
+ message_reflection->GetRepeatedEnum(message, field, j)->number());
}
} else {
data_size += WireFormatLite::EnumSize(
- message_reflection->GetEnum(message, field)->number());
+ message_reflection->GetEnum(message, field)->number());
}
break;
}
@@ -1352,9 +1336,8 @@
return data_size;
}
-size_t WireFormat::MessageSetItemByteSize(
- const FieldDescriptor* field,
- const Message& message) {
+size_t WireFormat::MessageSetItemByteSize(const FieldDescriptor* field,
+ const Message& message) {
const Reflection* message_reflection = message.GetReflection();
size_t our_size = WireFormatLite::kMessageSetItemTagsSize;
diff --git a/src/google/protobuf/wire_format_lite.cc b/src/google/protobuf/wire_format_lite.cc
index db058c2..5189a91 100644
--- a/src/google/protobuf/wire_format_lite.cc
+++ b/src/google/protobuf/wire_format_lite.cc
@@ -50,7 +50,6 @@
namespace protobuf {
namespace internal {
-
#if !defined(_MSC_VER) || _MSC_VER >= 1900
// Old version of MSVC doesn't like definitions of inline constants, GCC
// requires them.
@@ -63,64 +62,63 @@
// IBM xlC requires prefixing constants with WireFormatLite::
const size_t WireFormatLite::kMessageSetItemTagsSize =
- io::CodedOutputStream::StaticVarintSize32<
- WireFormatLite::kMessageSetItemStartTag>::value +
- io::CodedOutputStream::StaticVarintSize32<
- WireFormatLite::kMessageSetItemEndTag>::value +
- io::CodedOutputStream::StaticVarintSize32<
- WireFormatLite::kMessageSetTypeIdTag>::value +
- io::CodedOutputStream::StaticVarintSize32<
- WireFormatLite::kMessageSetMessageTag>::value;
+ io::CodedOutputStream::StaticVarintSize32<
+ WireFormatLite::kMessageSetItemStartTag>::value +
+ io::CodedOutputStream::StaticVarintSize32<
+ WireFormatLite::kMessageSetItemEndTag>::value +
+ io::CodedOutputStream::StaticVarintSize32<
+ WireFormatLite::kMessageSetTypeIdTag>::value +
+ io::CodedOutputStream::StaticVarintSize32<
+ WireFormatLite::kMessageSetMessageTag>::value;
const WireFormatLite::CppType
-WireFormatLite::kFieldTypeToCppTypeMap[MAX_FIELD_TYPE + 1] = {
- static_cast<CppType>(0), // 0 is reserved for errors
+ WireFormatLite::kFieldTypeToCppTypeMap[MAX_FIELD_TYPE + 1] = {
+ static_cast<CppType>(0), // 0 is reserved for errors
- CPPTYPE_DOUBLE, // TYPE_DOUBLE
- CPPTYPE_FLOAT, // TYPE_FLOAT
- CPPTYPE_INT64, // TYPE_INT64
- CPPTYPE_UINT64, // TYPE_UINT64
- CPPTYPE_INT32, // TYPE_INT32
- CPPTYPE_UINT64, // TYPE_FIXED64
- CPPTYPE_UINT32, // TYPE_FIXED32
- CPPTYPE_BOOL, // TYPE_BOOL
- CPPTYPE_STRING, // TYPE_STRING
- CPPTYPE_MESSAGE, // TYPE_GROUP
- CPPTYPE_MESSAGE, // TYPE_MESSAGE
- CPPTYPE_STRING, // TYPE_BYTES
- CPPTYPE_UINT32, // TYPE_UINT32
- CPPTYPE_ENUM, // TYPE_ENUM
- CPPTYPE_INT32, // TYPE_SFIXED32
- CPPTYPE_INT64, // TYPE_SFIXED64
- CPPTYPE_INT32, // TYPE_SINT32
- CPPTYPE_INT64, // TYPE_SINT64
+ CPPTYPE_DOUBLE, // TYPE_DOUBLE
+ CPPTYPE_FLOAT, // TYPE_FLOAT
+ CPPTYPE_INT64, // TYPE_INT64
+ CPPTYPE_UINT64, // TYPE_UINT64
+ CPPTYPE_INT32, // TYPE_INT32
+ CPPTYPE_UINT64, // TYPE_FIXED64
+ CPPTYPE_UINT32, // TYPE_FIXED32
+ CPPTYPE_BOOL, // TYPE_BOOL
+ CPPTYPE_STRING, // TYPE_STRING
+ CPPTYPE_MESSAGE, // TYPE_GROUP
+ CPPTYPE_MESSAGE, // TYPE_MESSAGE
+ CPPTYPE_STRING, // TYPE_BYTES
+ CPPTYPE_UINT32, // TYPE_UINT32
+ CPPTYPE_ENUM, // TYPE_ENUM
+ CPPTYPE_INT32, // TYPE_SFIXED32
+ CPPTYPE_INT64, // TYPE_SFIXED64
+ CPPTYPE_INT32, // TYPE_SINT32
+ CPPTYPE_INT64, // TYPE_SINT64
};
const WireFormatLite::WireType
-WireFormatLite::kWireTypeForFieldType[MAX_FIELD_TYPE + 1] = {
- static_cast<WireFormatLite::WireType>(-1), // invalid
- WireFormatLite::WIRETYPE_FIXED64, // TYPE_DOUBLE
- WireFormatLite::WIRETYPE_FIXED32, // TYPE_FLOAT
- WireFormatLite::WIRETYPE_VARINT, // TYPE_INT64
- WireFormatLite::WIRETYPE_VARINT, // TYPE_UINT64
- WireFormatLite::WIRETYPE_VARINT, // TYPE_INT32
- WireFormatLite::WIRETYPE_FIXED64, // TYPE_FIXED64
- WireFormatLite::WIRETYPE_FIXED32, // TYPE_FIXED32
- WireFormatLite::WIRETYPE_VARINT, // TYPE_BOOL
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED, // TYPE_STRING
- WireFormatLite::WIRETYPE_START_GROUP, // TYPE_GROUP
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED, // TYPE_MESSAGE
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED, // TYPE_BYTES
- WireFormatLite::WIRETYPE_VARINT, // TYPE_UINT32
- WireFormatLite::WIRETYPE_VARINT, // TYPE_ENUM
- WireFormatLite::WIRETYPE_FIXED32, // TYPE_SFIXED32
- WireFormatLite::WIRETYPE_FIXED64, // TYPE_SFIXED64
- WireFormatLite::WIRETYPE_VARINT, // TYPE_SINT32
- WireFormatLite::WIRETYPE_VARINT, // TYPE_SINT64
+ WireFormatLite::kWireTypeForFieldType[MAX_FIELD_TYPE + 1] = {
+ static_cast<WireFormatLite::WireType>(-1), // invalid
+ WireFormatLite::WIRETYPE_FIXED64, // TYPE_DOUBLE
+ WireFormatLite::WIRETYPE_FIXED32, // TYPE_FLOAT
+ WireFormatLite::WIRETYPE_VARINT, // TYPE_INT64
+ WireFormatLite::WIRETYPE_VARINT, // TYPE_UINT64
+ WireFormatLite::WIRETYPE_VARINT, // TYPE_INT32
+ WireFormatLite::WIRETYPE_FIXED64, // TYPE_FIXED64
+ WireFormatLite::WIRETYPE_FIXED32, // TYPE_FIXED32
+ WireFormatLite::WIRETYPE_VARINT, // TYPE_BOOL
+ WireFormatLite::WIRETYPE_LENGTH_DELIMITED, // TYPE_STRING
+ WireFormatLite::WIRETYPE_START_GROUP, // TYPE_GROUP
+ WireFormatLite::WIRETYPE_LENGTH_DELIMITED, // TYPE_MESSAGE
+ WireFormatLite::WIRETYPE_LENGTH_DELIMITED, // TYPE_BYTES
+ WireFormatLite::WIRETYPE_VARINT, // TYPE_UINT32
+ WireFormatLite::WIRETYPE_VARINT, // TYPE_ENUM
+ WireFormatLite::WIRETYPE_FIXED32, // TYPE_SFIXED32
+ WireFormatLite::WIRETYPE_FIXED64, // TYPE_SFIXED64
+ WireFormatLite::WIRETYPE_VARINT, // TYPE_SINT32
+ WireFormatLite::WIRETYPE_VARINT, // TYPE_SINT64
};
-bool WireFormatLite::SkipField(
- io::CodedInputStream* input, uint32 tag) {
+bool WireFormatLite::SkipField(io::CodedInputStream* input, uint32 tag) {
// Field number 0 is illegal.
if (WireFormatLite::GetTagFieldNumber(tag) == 0) return false;
switch (WireFormatLite::GetTagWireType(tag)) {
@@ -145,9 +143,9 @@
if (!SkipMessage(input)) return false;
input->DecrementRecursionDepth();
// Check that the ending tag matched the starting tag.
- if (!input->LastTagWas(WireFormatLite::MakeTag(
- WireFormatLite::GetTagFieldNumber(tag),
- WireFormatLite::WIRETYPE_END_GROUP))) {
+ if (!input->LastTagWas(
+ WireFormatLite::MakeTag(WireFormatLite::GetTagFieldNumber(tag),
+ WireFormatLite::WIRETYPE_END_GROUP))) {
return false;
}
return true;
@@ -166,8 +164,8 @@
}
}
-bool WireFormatLite::SkipField(
- io::CodedInputStream* input, uint32 tag, io::CodedOutputStream* output) {
+bool WireFormatLite::SkipField(io::CodedInputStream* input, uint32 tag,
+ io::CodedOutputStream* output) {
// Field number 0 is illegal.
if (WireFormatLite::GetTagFieldNumber(tag) == 0) return false;
switch (WireFormatLite::GetTagWireType(tag)) {
@@ -202,9 +200,9 @@
if (!SkipMessage(input, output)) return false;
input->DecrementRecursionDepth();
// Check that the ending tag matched the starting tag.
- if (!input->LastTagWas(WireFormatLite::MakeTag(
- WireFormatLite::GetTagFieldNumber(tag),
- WireFormatLite::WIRETYPE_END_GROUP))) {
+ if (!input->LastTagWas(
+ WireFormatLite::MakeTag(WireFormatLite::GetTagFieldNumber(tag),
+ WireFormatLite::WIRETYPE_END_GROUP))) {
return false;
}
return true;
@@ -245,7 +243,7 @@
}
bool WireFormatLite::SkipMessage(io::CodedInputStream* input,
- io::CodedOutputStream* output) {
+ io::CodedOutputStream* output) {
while (true) {
uint32 tag = input->ReadTag();
if (tag == 0) {
@@ -265,8 +263,7 @@
}
}
-bool FieldSkipper::SkipField(
- io::CodedInputStream* input, uint32 tag) {
+bool FieldSkipper::SkipField(io::CodedInputStream* input, uint32 tag) {
return WireFormatLite::SkipField(input, tag);
}
@@ -274,13 +271,12 @@
return WireFormatLite::SkipMessage(input);
}
-void FieldSkipper::SkipUnknownEnum(
- int /* field_number */, int /* value */) {
+void FieldSkipper::SkipUnknownEnum(int /* field_number */, int /* value */) {
// Nothing.
}
-bool CodedOutputStreamFieldSkipper::SkipField(
- io::CodedInputStream* input, uint32 tag) {
+bool CodedOutputStreamFieldSkipper::SkipField(io::CodedInputStream* input,
+ uint32 tag) {
return WireFormatLite::SkipField(input, tag, unknown_fields_);
}
@@ -288,8 +284,8 @@
return WireFormatLite::SkipMessage(input, unknown_fields_);
}
-void CodedOutputStreamFieldSkipper::SkipUnknownEnum(
- int field_number, int value) {
+void CodedOutputStreamFieldSkipper::SkipUnknownEnum(int field_number,
+ int value) {
unknown_fields_->WriteVarint32(field_number);
unknown_fields_->WriteVarint64(value);
}
@@ -314,11 +310,8 @@
}
bool WireFormatLite::ReadPackedEnumPreserveUnknowns(
- io::CodedInputStream* input,
- int field_number,
- bool (*is_valid)(int),
- io::CodedOutputStream* unknown_fields_stream,
- RepeatedField<int>* values) {
+ io::CodedInputStream* input, int field_number, bool (*is_valid)(int),
+ io::CodedOutputStream* unknown_fields_stream, RepeatedField<int>* values) {
uint32 length;
if (!input->ReadVarint32(&length)) return false;
io::CodedInputStream::Limit limit = input->PushLimit(length);
@@ -385,7 +378,7 @@
int to_do = std::min(kAtATime, n - i);
uint8* ptr = buf;
for (int j = 0; j < to_do; j++) {
- EncodeFixedSizeValue(a[i+j], ptr);
+ EncodeFixedSizeValue(a[i + j], ptr);
ptr += sizeof(a[0]);
}
output->WriteRaw(buf, to_do * sizeof(a[0]));
@@ -399,12 +392,12 @@
}
void WireFormatLite::WriteDoubleArray(const double* a, int n,
- io::CodedOutputStream* output) {
+ io::CodedOutputStream* output) {
WriteArray<double>(a, n, output);
}
void WireFormatLite::WriteFixed32Array(const uint32* a, int n,
- io::CodedOutputStream* output) {
+ io::CodedOutputStream* output) {
WriteArray<uint32>(a, n, output);
}
@@ -414,12 +407,12 @@
}
void WireFormatLite::WriteSFixed32Array(const int32* a, int n,
- io::CodedOutputStream* output) {
+ io::CodedOutputStream* output) {
WriteArray<int32>(a, n, output);
}
void WireFormatLite::WriteSFixed64Array(const int64* a, int n,
- io::CodedOutputStream* output) {
+ io::CodedOutputStream* output) {
WriteArray<int64>(a, n, output);
}
@@ -533,16 +526,14 @@
}
-void WireFormatLite::WriteGroup(int field_number,
- const MessageLite& value,
+void WireFormatLite::WriteGroup(int field_number, const MessageLite& value,
io::CodedOutputStream* output) {
WriteTag(field_number, WIRETYPE_START_GROUP, output);
value.SerializeWithCachedSizes(output);
WriteTag(field_number, WIRETYPE_END_GROUP, output);
}
-void WireFormatLite::WriteMessage(int field_number,
- const MessageLite& value,
+void WireFormatLite::WriteMessage(int field_number, const MessageLite& value,
io::CodedOutputStream* output) {
WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
const int size = value.GetCachedSize();
@@ -587,7 +578,7 @@
std::string* value) {
uint32 length;
return input->ReadVarint32(&length) &&
- input->InternalReadStringInline(value, length);
+ input->InternalReadStringInline(value, length);
}
bool WireFormatLite::ReadBytes(io::CodedInputStream* input,
@@ -615,9 +606,7 @@
<< "bytes. " << stacktrace;
}
-bool WireFormatLite::VerifyUtf8String(const char* data,
- int size,
- Operation op,
+bool WireFormatLite::VerifyUtf8String(const char* data, int size, Operation op,
const char* field_name) {
if (!IsStructurallyValidUTF8(data, size)) {
const char* operation_str = NULL;
@@ -628,7 +617,7 @@
case SERIALIZE:
operation_str = "serializing";
break;
- // no default case: have the compiler warn if a case is not covered.
+ // no default case: have the compiler warn if a case is not covered.
}
PrintUTF8ErrorLog(field_name, operation_str, false);
return false;
@@ -638,18 +627,18 @@
// this code is deliberately written such that clang makes it into really
// efficient SSE code.
-template<bool ZigZag, bool SignExtended, typename T>
+template <bool ZigZag, bool SignExtended, typename T>
static size_t VarintSize(const T* data, const int n) {
#if __cplusplus >= 201103L
static_assert(sizeof(T) == 4, "This routine only works for 32 bit integers");
// is_unsigned<T> => !ZigZag
- static_assert((std::is_unsigned<T>::value ^ ZigZag) ||
- std::is_signed<T>::value,
- "Cannot ZigZag encode unsigned types");
+ static_assert(
+ (std::is_unsigned<T>::value ^ ZigZag) || std::is_signed<T>::value,
+ "Cannot ZigZag encode unsigned types");
// is_unsigned<T> => !SignExtended
- static_assert((std::is_unsigned<T>::value ^ SignExtended) ||
- std::is_signed<T>::value,
- "Cannot SignExtended unsigned types");
+ static_assert(
+ (std::is_unsigned<T>::value ^ SignExtended) || std::is_signed<T>::value,
+ "Cannot SignExtended unsigned types");
static_assert(!(SignExtended && ZigZag),
"Cannot SignExtended and ZigZag on the same type");
#endif
@@ -675,7 +664,7 @@
return sum;
}
-template<bool ZigZag, typename T>
+template <bool ZigZag, typename T>
static size_t VarintSize64(const T* data, const int n) {
#if __cplusplus >= 201103L
static_assert(sizeof(T) == 8, "This routine only works for 64 bit integers");
@@ -771,7 +760,7 @@
// enable this.
#define USE_SSE_FOR_64_BIT_INTEGER_ARRAYS 0
#if USE_SSE_FOR_64_BIT_INTEGER_ARRAYS
-size_t WireFormatLite::Int64Size (const RepeatedField< int64>& value) {
+size_t WireFormatLite::Int64Size(const RepeatedField<int64>& value) {
return VarintSize64<false>(value.data(), value.size());
}
@@ -779,13 +768,13 @@
return VarintSize64<false>(value.data(), value.size());
}
-size_t WireFormatLite::SInt64Size(const RepeatedField< int64>& value) {
+size_t WireFormatLite::SInt64Size(const RepeatedField<int64>& value) {
return VarintSize64<true>(value.data(), value.size());
}
#else
-size_t WireFormatLite::Int64Size (const RepeatedField< int64>& value) {
+size_t WireFormatLite::Int64Size(const RepeatedField<int64>& value) {
size_t out = 0;
const int n = value.size();
for (int i = 0; i < n; i++) {
@@ -803,7 +792,7 @@
return out;
}
-size_t WireFormatLite::SInt64Size(const RepeatedField< int64>& value) {
+size_t WireFormatLite::SInt64Size(const RepeatedField<int64>& value) {
size_t out = 0;
const int n = value.size();
for (int i = 0; i < n; i++) {
diff --git a/src/google/protobuf/wire_format_lite.h b/src/google/protobuf/wire_format_lite.h
index 2468163..e0972d9 100644
--- a/src/google/protobuf/wire_format_lite.h
+++ b/src/google/protobuf/wire_format_lite.h
@@ -909,8 +909,7 @@
template <>
inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_INT32>(
- io::CodedInputStream* input,
- int32* value) {
+ io::CodedInputStream* input, int32* value) {
uint32 temp;
if (!input->ReadVarint32(&temp)) return false;
*value = static_cast<int32>(temp);
@@ -918,8 +917,7 @@
}
template <>
inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_INT64>(
- io::CodedInputStream* input,
- int64* value) {
+ io::CodedInputStream* input, int64* value) {
uint64 temp;
if (!input->ReadVarint64(&temp)) return false;
*value = static_cast<int64>(temp);
@@ -927,20 +925,17 @@
}
template <>
inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_UINT32>(
- io::CodedInputStream* input,
- uint32* value) {
+ io::CodedInputStream* input, uint32* value) {
return input->ReadVarint32(value);
}
template <>
inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_UINT64>(
- io::CodedInputStream* input,
- uint64* value) {
+ io::CodedInputStream* input, uint64* value) {
return input->ReadVarint64(value);
}
template <>
inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_SINT32>(
- io::CodedInputStream* input,
- int32* value) {
+ io::CodedInputStream* input, int32* value) {
uint32 temp;
if (!input->ReadVarint32(&temp)) return false;
*value = ZigZagDecode32(temp);
@@ -948,8 +943,7 @@
}
template <>
inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SINT64>(
- io::CodedInputStream* input,
- int64* value) {
+ io::CodedInputStream* input, int64* value) {
uint64 temp;
if (!input->ReadVarint64(&temp)) return false;
*value = ZigZagDecode64(temp);
@@ -957,20 +951,17 @@
}
template <>
inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_FIXED32>(
- io::CodedInputStream* input,
- uint32* value) {
+ io::CodedInputStream* input, uint32* value) {
return input->ReadLittleEndian32(value);
}
template <>
inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_FIXED64>(
- io::CodedInputStream* input,
- uint64* value) {
+ io::CodedInputStream* input, uint64* value) {
return input->ReadLittleEndian64(value);
}
template <>
inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_SFIXED32>(
- io::CodedInputStream* input,
- int32* value) {
+ io::CodedInputStream* input, int32* value) {
uint32 temp;
if (!input->ReadLittleEndian32(&temp)) return false;
*value = static_cast<int32>(temp);
@@ -978,8 +969,7 @@
}
template <>
inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SFIXED64>(
- io::CodedInputStream* input,
- int64* value) {
+ io::CodedInputStream* input, int64* value) {
uint64 temp;
if (!input->ReadLittleEndian64(&temp)) return false;
*value = static_cast<int64>(temp);
@@ -987,8 +977,7 @@
}
template <>
inline bool WireFormatLite::ReadPrimitive<float, WireFormatLite::TYPE_FLOAT>(
- io::CodedInputStream* input,
- float* value) {
+ io::CodedInputStream* input, float* value) {
uint32 temp;
if (!input->ReadLittleEndian32(&temp)) return false;
*value = DecodeFloat(temp);
@@ -996,8 +985,7 @@
}
template <>
inline bool WireFormatLite::ReadPrimitive<double, WireFormatLite::TYPE_DOUBLE>(
- io::CodedInputStream* input,
- double* value) {
+ io::CodedInputStream* input, double* value) {
uint64 temp;
if (!input->ReadLittleEndian64(&temp)) return false;
*value = DecodeDouble(temp);
@@ -1005,8 +993,7 @@
}
template <>
inline bool WireFormatLite::ReadPrimitive<bool, WireFormatLite::TYPE_BOOL>(
- io::CodedInputStream* input,
- bool* value) {
+ io::CodedInputStream* input, bool* value) {
uint64 temp;
if (!input->ReadVarint64(&temp)) return false;
*value = temp != 0;
@@ -1014,8 +1001,7 @@
}
template <>
inline bool WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
- io::CodedInputStream* input,
- int* value) {
+ io::CodedInputStream* input, int* value) {
uint32 temp;
if (!input->ReadVarint32(&temp)) return false;
*value = static_cast<int>(temp);
@@ -1023,54 +1009,48 @@
}
template <>
-inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
- uint32, WireFormatLite::TYPE_FIXED32>(
- const uint8* buffer,
- uint32* value) {
+inline const uint8*
+WireFormatLite::ReadPrimitiveFromArray<uint32, WireFormatLite::TYPE_FIXED32>(
+ const uint8* buffer, uint32* value) {
return io::CodedInputStream::ReadLittleEndian32FromArray(buffer, value);
}
template <>
-inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
- uint64, WireFormatLite::TYPE_FIXED64>(
- const uint8* buffer,
- uint64* value) {
+inline const uint8*
+WireFormatLite::ReadPrimitiveFromArray<uint64, WireFormatLite::TYPE_FIXED64>(
+ const uint8* buffer, uint64* value) {
return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
}
template <>
-inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
- int32, WireFormatLite::TYPE_SFIXED32>(
- const uint8* buffer,
- int32* value) {
+inline const uint8*
+WireFormatLite::ReadPrimitiveFromArray<int32, WireFormatLite::TYPE_SFIXED32>(
+ const uint8* buffer, int32* value) {
uint32 temp;
buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
*value = static_cast<int32>(temp);
return buffer;
}
template <>
-inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
- int64, WireFormatLite::TYPE_SFIXED64>(
- const uint8* buffer,
- int64* value) {
+inline const uint8*
+WireFormatLite::ReadPrimitiveFromArray<int64, WireFormatLite::TYPE_SFIXED64>(
+ const uint8* buffer, int64* value) {
uint64 temp;
buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
*value = static_cast<int64>(temp);
return buffer;
}
template <>
-inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
- float, WireFormatLite::TYPE_FLOAT>(
- const uint8* buffer,
- float* value) {
+inline const uint8*
+WireFormatLite::ReadPrimitiveFromArray<float, WireFormatLite::TYPE_FLOAT>(
+ const uint8* buffer, float* value) {
uint32 temp;
buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
*value = DecodeFloat(temp);
return buffer;
}
template <>
-inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
- double, WireFormatLite::TYPE_DOUBLE>(
- const uint8* buffer,
- double* value) {
+inline const uint8*
+WireFormatLite::ReadPrimitiveFromArray<double, WireFormatLite::TYPE_DOUBLE>(
+ const uint8* buffer, double* value) {
uint64 temp;
buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
*value = DecodeDouble(temp);
@@ -1080,9 +1060,7 @@
template <typename CType, enum WireFormatLite::FieldType DeclaredType>
inline bool WireFormatLite::ReadRepeatedPrimitive(
int, // tag_size, unused.
- uint32 tag,
- io::CodedInputStream* input,
- RepeatedField<CType>* values) {
+ uint32 tag, io::CodedInputStream* input, RepeatedField<CType>* values) {
CType value;
if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
values->Add(value);
@@ -1097,14 +1075,11 @@
template <typename CType, enum WireFormatLite::FieldType DeclaredType>
inline bool WireFormatLite::ReadRepeatedFixedSizePrimitive(
- int tag_size,
- uint32 tag,
- io::CodedInputStream* input,
+ int tag_size, uint32 tag, io::CodedInputStream* input,
RepeatedField<CType>* values) {
GOOGLE_DCHECK_EQ(UInt32Size(tag), static_cast<size_t>(tag_size));
CType value;
- if (!ReadPrimitive<CType, DeclaredType>(input, &value))
- return false;
+ if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
values->Add(value);
// For fixed size values, repeated values can be read more quickly by
@@ -1129,8 +1104,8 @@
(std::min)(values->Capacity() - values->size(), size / per_value_size);
int num_read = 0;
while (num_read < elements_available &&
- (buffer = io::CodedInputStream::ExpectTagFromArray(
- buffer, tag)) != NULL) {
+ (buffer = io::CodedInputStream::ExpectTagFromArray(buffer, tag)) !=
+ NULL) {
buffer = ReadPrimitiveFromArray<CType, DeclaredType>(buffer, &value);
values->AddAlreadyReserved(value);
++num_read;
@@ -1145,18 +1120,16 @@
// Specializations of ReadRepeatedPrimitive for the fixed size types, which use
// the optimized code path.
-#define READ_REPEATED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE) \
-template <> \
-inline bool WireFormatLite::ReadRepeatedPrimitive< \
- CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
- int tag_size, \
- uint32 tag, \
- io::CodedInputStream* input, \
- RepeatedField<CPPTYPE>* values) { \
- return ReadRepeatedFixedSizePrimitive< \
- CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
- tag_size, tag, input, values); \
-}
+#define READ_REPEATED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE) \
+ template <> \
+ inline bool WireFormatLite::ReadRepeatedPrimitive< \
+ CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
+ int tag_size, uint32 tag, io::CodedInputStream* input, \
+ RepeatedField<CPPTYPE>* values) { \
+ return ReadRepeatedFixedSizePrimitive<CPPTYPE, \
+ WireFormatLite::DECLARED_TYPE>( \
+ tag_size, tag, input, values); \
+ }
READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint32, TYPE_FIXED32)
READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint64, TYPE_FIXED64)
@@ -1169,12 +1142,10 @@
template <typename CType, enum WireFormatLite::FieldType DeclaredType>
bool WireFormatLite::ReadRepeatedPrimitiveNoInline(
- int tag_size,
- uint32 tag,
- io::CodedInputStream* input,
+ int tag_size, uint32 tag, io::CodedInputStream* input,
RepeatedField<CType>* value) {
- return ReadRepeatedPrimitive<CType, DeclaredType>(
- tag_size, tag, input, value);
+ return ReadRepeatedPrimitive<CType, DeclaredType>(tag_size, tag, input,
+ value);
}
template <typename CType, enum WireFormatLite::FieldType DeclaredType>
@@ -1255,14 +1226,14 @@
// Specializations of ReadPackedPrimitive for the fixed size types, which use
// an optimized code path.
#define READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE) \
-template <> \
-inline bool WireFormatLite::ReadPackedPrimitive< \
- CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
- io::CodedInputStream* input, \
- RepeatedField<CPPTYPE>* values) { \
- return ReadPackedFixedSizePrimitive< \
- CPPTYPE, WireFormatLite::DECLARED_TYPE>(input, values); \
-}
+ template <> \
+ inline bool \
+ WireFormatLite::ReadPackedPrimitive<CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
+ io::CodedInputStream * input, RepeatedField<CPPTYPE> * values) { \
+ return ReadPackedFixedSizePrimitive<CPPTYPE, \
+ WireFormatLite::DECLARED_TYPE>( \
+ input, values); \
+ }
READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint32, TYPE_FIXED32)
READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint64, TYPE_FIXED64)
@@ -1280,10 +1251,10 @@
}
-template<typename MessageType>
-inline bool WireFormatLite::ReadGroup(
- int field_number, io::CodedInputStream* input,
- MessageType* value) {
+template <typename MessageType>
+inline bool WireFormatLite::ReadGroup(int field_number,
+ io::CodedInputStream* input,
+ MessageType* value) {
if (!input->IncrementRecursionDepth()) return false;
if (!value->MergePartialFromCodedStream(input)) return false;
input->UnsafeDecrementRecursionDepth();
@@ -1293,9 +1264,9 @@
}
return true;
}
-template<typename MessageType>
-inline bool WireFormatLite::ReadMessage(
- io::CodedInputStream* input, MessageType* value) {
+template <typename MessageType>
+inline bool WireFormatLite::ReadMessage(io::CodedInputStream* input,
+ MessageType* value) {
int length;
if (!input->ReadVarintSizeAsInt(&length)) return false;
std::pair<io::CodedInputStream::Limit, int> p =
@@ -1372,7 +1343,7 @@
// See comment on ReadGroupNoVirtual to understand the need for this template
// parameter name.
-template<typename MessageType_WorkAroundCppLookupDefect>
+template <typename MessageType_WorkAroundCppLookupDefect>
inline void WireFormatLite::WriteGroupNoVirtual(
int field_number, const MessageType_WorkAroundCppLookupDefect& value,
io::CodedOutputStream* output) {
@@ -1380,7 +1351,7 @@
value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
WriteTag(field_number, WIRETYPE_END_GROUP, output);
}
-template<typename MessageType_WorkAroundCppLookupDefect>
+template <typename MessageType_WorkAroundCppLookupDefect>
inline void WireFormatLite::WriteMessageNoVirtual(
int field_number, const MessageType_WorkAroundCppLookupDefect& value,
io::CodedOutputStream* output) {
@@ -1392,8 +1363,7 @@
// ===================================================================
-inline uint8* WireFormatLite::WriteTagToArray(int field_number,
- WireType type,
+inline uint8* WireFormatLite::WriteTagToArray(int field_number, WireType type,
uint8* target) {
return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type),
target);
@@ -1405,8 +1375,8 @@
}
inline uint8* WireFormatLite::WriteInt64NoTagToArray(int64 value,
uint8* target) {
- return io::CodedOutputStream::WriteVarint64ToArray(
- static_cast<uint64>(value), target);
+ return io::CodedOutputStream::WriteVarint64ToArray(static_cast<uint64>(value),
+ target);
}
inline uint8* WireFormatLite::WriteUInt32NoTagToArray(uint32 value,
uint8* target) {
@@ -1454,19 +1424,16 @@
return io::CodedOutputStream::WriteLittleEndian64ToArray(EncodeDouble(value),
target);
}
-inline uint8* WireFormatLite::WriteBoolNoTagToArray(bool value,
- uint8* target) {
+inline uint8* WireFormatLite::WriteBoolNoTagToArray(bool value, uint8* target) {
return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target);
}
-inline uint8* WireFormatLite::WriteEnumNoTagToArray(int value,
- uint8* target) {
+inline uint8* WireFormatLite::WriteEnumNoTagToArray(int value, uint8* target) {
return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
}
-template<typename T>
+template <typename T>
inline uint8* WireFormatLite::WritePrimitiveNoTagToArray(
- const RepeatedField<T>& value,
- uint8* (*Writer)(T, uint8*), uint8* target) {
+ const RepeatedField<T>& value, uint8* (*Writer)(T, uint8*), uint8* target) {
const int n = value.size();
GOOGLE_DCHECK_GT(n, 0);
@@ -1479,12 +1446,11 @@
return target;
}
-template<typename T>
+template <typename T>
inline uint8* WireFormatLite::WriteFixedNoTagToArray(
- const RepeatedField<T>& value,
- uint8* (*Writer)(T, uint8*), uint8* target) {
+ const RepeatedField<T>& value, uint8* (*Writer)(T, uint8*), uint8* target) {
#if defined(PROTOBUF_LITTLE_ENDIAN)
- (void) Writer;
+ (void)Writer;
const int n = value.size();
GOOGLE_DCHECK_GT(n, 0);
@@ -1499,11 +1465,11 @@
}
inline uint8* WireFormatLite::WriteInt32NoTagToArray(
- const RepeatedField< int32>& value, uint8* target) {
+ const RepeatedField<int32>& value, uint8* target) {
return WritePrimitiveNoTagToArray(value, WriteInt32NoTagToArray, target);
}
inline uint8* WireFormatLite::WriteInt64NoTagToArray(
- const RepeatedField< int64>& value, uint8* target) {
+ const RepeatedField<int64>& value, uint8* target) {
return WritePrimitiveNoTagToArray(value, WriteInt64NoTagToArray, target);
}
inline uint8* WireFormatLite::WriteUInt32NoTagToArray(
@@ -1515,11 +1481,11 @@
return WritePrimitiveNoTagToArray(value, WriteUInt64NoTagToArray, target);
}
inline uint8* WireFormatLite::WriteSInt32NoTagToArray(
- const RepeatedField< int32>& value, uint8* target) {
+ const RepeatedField<int32>& value, uint8* target) {
return WritePrimitiveNoTagToArray(value, WriteSInt32NoTagToArray, target);
}
inline uint8* WireFormatLite::WriteSInt64NoTagToArray(
- const RepeatedField< int64>& value, uint8* target) {
+ const RepeatedField<int64>& value, uint8* target) {
return WritePrimitiveNoTagToArray(value, WriteSInt64NoTagToArray, target);
}
inline uint8* WireFormatLite::WriteFixed32NoTagToArray(
@@ -1531,15 +1497,15 @@
return WriteFixedNoTagToArray(value, WriteFixed64NoTagToArray, target);
}
inline uint8* WireFormatLite::WriteSFixed32NoTagToArray(
- const RepeatedField< int32>& value, uint8* target) {
+ const RepeatedField<int32>& value, uint8* target) {
return WriteFixedNoTagToArray(value, WriteSFixed32NoTagToArray, target);
}
inline uint8* WireFormatLite::WriteSFixed64NoTagToArray(
- const RepeatedField< int64>& value, uint8* target) {
+ const RepeatedField<int64>& value, uint8* target) {
return WriteFixedNoTagToArray(value, WriteSFixed64NoTagToArray, target);
}
inline uint8* WireFormatLite::WriteFloatNoTagToArray(
- const RepeatedField< float>& value, uint8* target) {
+ const RepeatedField<float>& value, uint8* target) {
return WriteFixedNoTagToArray(value, WriteFloatNoTagToArray, target);
}
inline uint8* WireFormatLite::WriteDoubleNoTagToArray(
@@ -1547,103 +1513,88 @@
return WriteFixedNoTagToArray(value, WriteDoubleNoTagToArray, target);
}
inline uint8* WireFormatLite::WriteBoolNoTagToArray(
- const RepeatedField< bool>& value, uint8* target) {
+ const RepeatedField<bool>& value, uint8* target) {
return WritePrimitiveNoTagToArray(value, WriteBoolNoTagToArray, target);
}
inline uint8* WireFormatLite::WriteEnumNoTagToArray(
- const RepeatedField< int>& value, uint8* target) {
+ const RepeatedField<int>& value, uint8* target) {
return WritePrimitiveNoTagToArray(value, WriteEnumNoTagToArray, target);
}
-inline uint8* WireFormatLite::WriteInt32ToArray(int field_number,
- int32 value,
+inline uint8* WireFormatLite::WriteInt32ToArray(int field_number, int32 value,
uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
return WriteInt32NoTagToArray(value, target);
}
-inline uint8* WireFormatLite::WriteInt64ToArray(int field_number,
- int64 value,
+inline uint8* WireFormatLite::WriteInt64ToArray(int field_number, int64 value,
uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
return WriteInt64NoTagToArray(value, target);
}
-inline uint8* WireFormatLite::WriteUInt32ToArray(int field_number,
- uint32 value,
+inline uint8* WireFormatLite::WriteUInt32ToArray(int field_number, uint32 value,
uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
return WriteUInt32NoTagToArray(value, target);
}
-inline uint8* WireFormatLite::WriteUInt64ToArray(int field_number,
- uint64 value,
+inline uint8* WireFormatLite::WriteUInt64ToArray(int field_number, uint64 value,
uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
return WriteUInt64NoTagToArray(value, target);
}
-inline uint8* WireFormatLite::WriteSInt32ToArray(int field_number,
- int32 value,
+inline uint8* WireFormatLite::WriteSInt32ToArray(int field_number, int32 value,
uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
return WriteSInt32NoTagToArray(value, target);
}
-inline uint8* WireFormatLite::WriteSInt64ToArray(int field_number,
- int64 value,
+inline uint8* WireFormatLite::WriteSInt64ToArray(int field_number, int64 value,
uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
return WriteSInt64NoTagToArray(value, target);
}
inline uint8* WireFormatLite::WriteFixed32ToArray(int field_number,
- uint32 value,
- uint8* target) {
+ uint32 value, uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
return WriteFixed32NoTagToArray(value, target);
}
inline uint8* WireFormatLite::WriteFixed64ToArray(int field_number,
- uint64 value,
- uint8* target) {
+ uint64 value, uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
return WriteFixed64NoTagToArray(value, target);
}
inline uint8* WireFormatLite::WriteSFixed32ToArray(int field_number,
- int32 value,
- uint8* target) {
+ int32 value, uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
return WriteSFixed32NoTagToArray(value, target);
}
inline uint8* WireFormatLite::WriteSFixed64ToArray(int field_number,
- int64 value,
- uint8* target) {
+ int64 value, uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
return WriteSFixed64NoTagToArray(value, target);
}
-inline uint8* WireFormatLite::WriteFloatToArray(int field_number,
- float value,
+inline uint8* WireFormatLite::WriteFloatToArray(int field_number, float value,
uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
return WriteFloatNoTagToArray(value, target);
}
-inline uint8* WireFormatLite::WriteDoubleToArray(int field_number,
- double value,
+inline uint8* WireFormatLite::WriteDoubleToArray(int field_number, double value,
uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
return WriteDoubleNoTagToArray(value, target);
}
-inline uint8* WireFormatLite::WriteBoolToArray(int field_number,
- bool value,
+inline uint8* WireFormatLite::WriteBoolToArray(int field_number, bool value,
uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
return WriteBoolNoTagToArray(value, target);
}
-inline uint8* WireFormatLite::WriteEnumToArray(int field_number,
- int value,
+inline uint8* WireFormatLite::WriteEnumToArray(int field_number, int value,
uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
return WriteEnumNoTagToArray(value, target);
}
-template<typename T>
+template <typename T>
inline uint8* WireFormatLite::WritePrimitiveToArray(
- int field_number,
- const RepeatedField<T>& value,
+ int field_number, const RepeatedField<T>& value,
uint8* (*Writer)(int, T, uint8*), uint8* target) {
const int n = value.size();
if (n == 0) {
@@ -1660,11 +1611,11 @@
}
inline uint8* WireFormatLite::WriteInt32ToArray(
- int field_number, const RepeatedField< int32>& value, uint8* target) {
+ int field_number, const RepeatedField<int32>& value, uint8* target) {
return WritePrimitiveToArray(field_number, value, WriteInt32ToArray, target);
}
inline uint8* WireFormatLite::WriteInt64ToArray(
- int field_number, const RepeatedField< int64>& value, uint8* target) {
+ int field_number, const RepeatedField<int64>& value, uint8* target) {
return WritePrimitiveToArray(field_number, value, WriteInt64ToArray, target);
}
inline uint8* WireFormatLite::WriteUInt32ToArray(
@@ -1676,47 +1627,49 @@
return WritePrimitiveToArray(field_number, value, WriteUInt64ToArray, target);
}
inline uint8* WireFormatLite::WriteSInt32ToArray(
- int field_number, const RepeatedField< int32>& value, uint8* target) {
+ int field_number, const RepeatedField<int32>& value, uint8* target) {
return WritePrimitiveToArray(field_number, value, WriteSInt32ToArray, target);
}
inline uint8* WireFormatLite::WriteSInt64ToArray(
- int field_number, const RepeatedField< int64>& value, uint8* target) {
+ int field_number, const RepeatedField<int64>& value, uint8* target) {
return WritePrimitiveToArray(field_number, value, WriteSInt64ToArray, target);
}
inline uint8* WireFormatLite::WriteFixed32ToArray(
int field_number, const RepeatedField<uint32>& value, uint8* target) {
- return WritePrimitiveToArray(
- field_number, value, WriteFixed32ToArray, target);
+ return WritePrimitiveToArray(field_number, value, WriteFixed32ToArray,
+ target);
}
inline uint8* WireFormatLite::WriteFixed64ToArray(
int field_number, const RepeatedField<uint64>& value, uint8* target) {
- return WritePrimitiveToArray(
- field_number, value, WriteFixed64ToArray, target);
+ return WritePrimitiveToArray(field_number, value, WriteFixed64ToArray,
+ target);
}
inline uint8* WireFormatLite::WriteSFixed32ToArray(
- int field_number, const RepeatedField< int32>& value, uint8* target) {
- return WritePrimitiveToArray(
- field_number, value, WriteSFixed32ToArray, target);
+ int field_number, const RepeatedField<int32>& value, uint8* target) {
+ return WritePrimitiveToArray(field_number, value, WriteSFixed32ToArray,
+ target);
}
inline uint8* WireFormatLite::WriteSFixed64ToArray(
- int field_number, const RepeatedField< int64>& value, uint8* target) {
- return WritePrimitiveToArray(
- field_number, value, WriteSFixed64ToArray, target);
+ int field_number, const RepeatedField<int64>& value, uint8* target) {
+ return WritePrimitiveToArray(field_number, value, WriteSFixed64ToArray,
+ target);
}
inline uint8* WireFormatLite::WriteFloatToArray(
- int field_number, const RepeatedField< float>& value, uint8* target) {
+ int field_number, const RepeatedField<float>& value, uint8* target) {
return WritePrimitiveToArray(field_number, value, WriteFloatToArray, target);
}
inline uint8* WireFormatLite::WriteDoubleToArray(
int field_number, const RepeatedField<double>& value, uint8* target) {
return WritePrimitiveToArray(field_number, value, WriteDoubleToArray, target);
}
-inline uint8* WireFormatLite::WriteBoolToArray(
- int field_number, const RepeatedField< bool>& value, uint8* target) {
+inline uint8* WireFormatLite::WriteBoolToArray(int field_number,
+ const RepeatedField<bool>& value,
+ uint8* target) {
return WritePrimitiveToArray(field_number, value, WriteBoolToArray, target);
}
-inline uint8* WireFormatLite::WriteEnumToArray(
- int field_number, const RepeatedField< int>& value, uint8* target) {
+inline uint8* WireFormatLite::WriteEnumToArray(int field_number,
+ const RepeatedField<int>& value,
+ uint8* target) {
return WritePrimitiveToArray(field_number, value, WriteEnumToArray, target);
}
inline uint8* WireFormatLite::WriteStringToArray(int field_number,
@@ -1749,7 +1702,7 @@
int field_number, const MessageType& value, uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
target = io::CodedOutputStream::WriteVarint32ToArray(
- static_cast<uint32>(value.GetCachedSize()), target);
+ static_cast<uint32>(value.GetCachedSize()), target);
return value.InternalSerializeWithCachedSizesToArray(target);
}
@@ -1770,9 +1723,9 @@
uint8* target) {
target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
target = io::CodedOutputStream::WriteVarint32ToArray(
- static_cast<uint32>(
- value.MessageType_WorkAroundCppLookupDefect::GetCachedSize()),
- target);
+ static_cast<uint32>(
+ value.MessageType_WorkAroundCppLookupDefect::GetCachedSize()),
+ target);
return value.MessageType_WorkAroundCppLookupDefect::
InternalSerializeWithCachedSizesToArray(target);
}
@@ -1809,23 +1762,23 @@
}
-template<typename MessageType>
+template <typename MessageType>
inline size_t WireFormatLite::GroupSize(const MessageType& value) {
return value.ByteSizeLong();
}
-template<typename MessageType>
+template <typename MessageType>
inline size_t WireFormatLite::MessageSize(const MessageType& value) {
return LengthDelimitedSize(value.ByteSizeLong());
}
// See comment on ReadGroupNoVirtual to understand the need for this template
// parameter name.
-template<typename MessageType_WorkAroundCppLookupDefect>
+template <typename MessageType_WorkAroundCppLookupDefect>
inline size_t WireFormatLite::GroupSizeNoVirtual(
const MessageType_WorkAroundCppLookupDefect& value) {
return value.MessageType_WorkAroundCppLookupDefect::ByteSizeLong();
}
-template<typename MessageType_WorkAroundCppLookupDefect>
+template <typename MessageType_WorkAroundCppLookupDefect>
inline size_t WireFormatLite::MessageSizeNoVirtual(
const MessageType_WorkAroundCppLookupDefect& value) {
return LengthDelimitedSize(
@@ -1837,8 +1790,8 @@
// but is not technically correct--if length is too large to fit in a uint32
// then it will be silently truncated. We will need to fix this if we ever
// decide to start supporting serialized messages greater than 2 GiB in size.
- return length + io::CodedOutputStream::VarintSize32(
- static_cast<uint32>(length));
+ return length +
+ io::CodedOutputStream::VarintSize32(static_cast<uint32>(length));
}
template <typename MS>
@@ -1885,8 +1838,8 @@
uint32 length;
if (!input->ReadVarint32(&length)) return false;
if (static_cast<int32>(length) < 0) return false;
- uint32 size = static_cast<uint32>(length +
- io::CodedOutputStream::VarintSize32(length));
+ uint32 size = static_cast<uint32>(
+ length + io::CodedOutputStream::VarintSize32(length));
message_data.resize(size);
auto ptr = reinterpret_cast<uint8*>(&message_data[0]);
ptr = io::CodedOutputStream::WriteVarint32ToArray(length, ptr);
diff --git a/src/google/protobuf/wire_format_unittest.cc b/src/google/protobuf/wire_format_unittest.cc
index 762aa66..cf0ccdc 100644
--- a/src/google/protobuf/wire_format_unittest.cc
+++ b/src/google/protobuf/wire_format_unittest.cc
@@ -33,14 +33,14 @@
// Sanjay Ghemawat, Jeff Dean, and others.
#include <google/protobuf/wire_format.h>
-#include <google/protobuf/descriptor.h>
-#include <google/protobuf/io/zero_copy_stream_impl.h>
-#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/test_util.h>
#include <google/protobuf/unittest.pb.h>
-#include <google/protobuf/unittest_proto3_arena.pb.h>
#include <google/protobuf/unittest_mset.pb.h>
#include <google/protobuf/unittest_mset_wire_format.pb.h>
-#include <google/protobuf/test_util.h>
+#include <google/protobuf/unittest_proto3_arena.pb.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+#include <google/protobuf/descriptor.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
@@ -232,8 +232,7 @@
unittest::TestAllExtensions message;
TestUtil::SetAllExtensions(&message);
- EXPECT_EQ(message.ByteSize(),
- WireFormat::ByteSize(message));
+ EXPECT_EQ(message.ByteSize(), WireFormat::ByteSize(message));
message.Clear();
EXPECT_EQ(0, message.ByteSize());
EXPECT_EQ(0, WireFormat::ByteSize(message));
@@ -253,8 +252,7 @@
unittest::TestPackedExtensions message;
TestUtil::SetPackedExtensions(&message);
- EXPECT_EQ(message.ByteSize(),
- WireFormat::ByteSize(message));
+ EXPECT_EQ(message.ByteSize(), WireFormat::ByteSize(message));
message.Clear();
EXPECT_EQ(0, message.ByteSize());
EXPECT_EQ(0, WireFormat::ByteSize(message));
@@ -264,8 +262,7 @@
unittest::TestOneof2 message;
TestUtil::SetOneof1(&message);
- EXPECT_EQ(message.ByteSize(),
- WireFormat::ByteSize(message));
+ EXPECT_EQ(message.ByteSize(), WireFormat::ByteSize(message));
message.Clear();
EXPECT_EQ(0, message.ByteSize());
@@ -425,12 +422,16 @@
TEST(WireFormatTest, SerializeMessageSet) {
// Set up a TestMessageSet with two known messages and an unknown one.
proto2_wireformat_unittest::TestMessageSet message_set;
- message_set.MutableExtension(
- unittest::TestMessageSetExtension1::message_set_extension)->set_i(123);
- message_set.MutableExtension(
- unittest::TestMessageSetExtension2::message_set_extension)->set_str("foo");
- message_set.mutable_unknown_fields()->AddLengthDelimited(
- kUnknownTypeId, "bar");
+ message_set
+ .MutableExtension(
+ unittest::TestMessageSetExtension1::message_set_extension)
+ ->set_i(123);
+ message_set
+ .MutableExtension(
+ unittest::TestMessageSetExtension2::message_set_extension)
+ ->set_str("foo");
+ message_set.mutable_unknown_fields()->AddLengthDelimited(kUnknownTypeId,
+ "bar");
std::string data;
ASSERT_TRUE(message_set.SerializeToString(&data));
@@ -443,11 +444,11 @@
ASSERT_EQ(3, raw.item_size());
EXPECT_EQ(
- unittest::TestMessageSetExtension1::descriptor()->extension(0)->number(),
- raw.item(0).type_id());
+ unittest::TestMessageSetExtension1::descriptor()->extension(0)->number(),
+ raw.item(0).type_id());
EXPECT_EQ(
- unittest::TestMessageSetExtension2::descriptor()->extension(0)->number(),
- raw.item(1).type_id());
+ unittest::TestMessageSetExtension2::descriptor()->extension(0)->number(),
+ raw.item(1).type_id());
EXPECT_EQ(kUnknownTypeId, raw.item(2).type_id());
unittest::TestMessageSetExtension1 message1;
@@ -468,12 +469,16 @@
// above.
proto2_wireformat_unittest::TestMessageSet message_set;
- message_set.MutableExtension(
- unittest::TestMessageSetExtension1::message_set_extension)->set_i(123);
- message_set.MutableExtension(
- unittest::TestMessageSetExtension2::message_set_extension)->set_str("foo");
- message_set.mutable_unknown_fields()->AddLengthDelimited(
- kUnknownTypeId, "bar");
+ message_set
+ .MutableExtension(
+ unittest::TestMessageSetExtension1::message_set_extension)
+ ->set_i(123);
+ message_set
+ .MutableExtension(
+ unittest::TestMessageSetExtension2::message_set_extension)
+ ->set_str("foo");
+ message_set.mutable_unknown_fields()->AddLengthDelimited(kUnknownTypeId,
+ "bar");
int size = message_set.ByteSize();
EXPECT_EQ(size, message_set.GetCachedSize());
@@ -519,8 +524,9 @@
{
unittest::RawMessageSet::Item* item = raw.add_item();
- item->set_type_id(
- unittest::TestMessageSetExtension1::descriptor()->extension(0)->number());
+ item->set_type_id(unittest::TestMessageSetExtension1::descriptor()
+ ->extension(0)
+ ->number());
unittest::TestMessageSetExtension1 message;
message.set_i(123);
message.SerializeToString(item->mutable_message());
@@ -528,8 +534,9 @@
{
unittest::RawMessageSet::Item* item = raw.add_item();
- item->set_type_id(
- unittest::TestMessageSetExtension2::descriptor()->extension(0)->number());
+ item->set_type_id(unittest::TestMessageSetExtension2::descriptor()
+ ->extension(0)
+ ->number());
unittest::TestMessageSetExtension2 message;
message.set_str("foo");
message.SerializeToString(item->mutable_message());
@@ -548,10 +555,16 @@
proto2_wireformat_unittest::TestMessageSet message_set;
ASSERT_TRUE(message_set.ParseFromString(data));
- EXPECT_EQ(123, message_set.GetExtension(
- unittest::TestMessageSetExtension1::message_set_extension).i());
- EXPECT_EQ("foo", message_set.GetExtension(
- unittest::TestMessageSetExtension2::message_set_extension).str());
+ EXPECT_EQ(123,
+ message_set
+ .GetExtension(
+ unittest::TestMessageSetExtension1::message_set_extension)
+ .i());
+ EXPECT_EQ("foo",
+ message_set
+ .GetExtension(
+ unittest::TestMessageSetExtension2::message_set_extension)
+ .str());
ASSERT_EQ(1, message_set.unknown_fields().field_count());
ASSERT_EQ(UnknownField::TYPE_LENGTH_DELIMITED,
@@ -592,8 +605,11 @@
proto2_wireformat_unittest::TestMessageSet message_set;
ASSERT_TRUE(message_set.ParseFromString(data));
- EXPECT_EQ(123, message_set.GetExtension(
- unittest::TestMessageSetExtension1::message_set_extension).i());
+ EXPECT_EQ(123,
+ message_set
+ .GetExtension(
+ unittest::TestMessageSetExtension1::message_set_extension)
+ .i());
}
{
// Test parse the message via Reflection.
@@ -603,8 +619,11 @@
EXPECT_TRUE(WireFormat::ParseAndMergePartial(&input, &message_set));
EXPECT_TRUE(input.ConsumedEntireMessage());
- EXPECT_EQ(123, message_set.GetExtension(
- unittest::TestMessageSetExtension1::message_set_extension).i());
+ EXPECT_EQ(123,
+ message_set
+ .GetExtension(
+ unittest::TestMessageSetExtension1::message_set_extension)
+ .i());
}
}
@@ -699,11 +718,11 @@
TEST(WireFormatTest, UnknownFieldRecursionLimit) {
unittest::TestEmptyMessage message;
message.mutable_unknown_fields()
- ->AddGroup(1234)
- ->AddGroup(1234)
- ->AddGroup(1234)
- ->AddGroup(1234)
- ->AddVarint(1234, 123);
+ ->AddGroup(1234)
+ ->AddGroup(1234)
+ ->AddGroup(1234)
+ ->AddGroup(1234)
+ ->AddVarint(1234, 123);
std::string data;
message.SerializeToString(&data);
@@ -733,27 +752,27 @@
#define ZigZagEncode64(x) WireFormatLite::ZigZagEncode64(x)
#define ZigZagDecode64(x) WireFormatLite::ZigZagDecode64(x)
- EXPECT_EQ(0u, ZigZagEncode32( 0));
+ EXPECT_EQ(0u, ZigZagEncode32(0));
EXPECT_EQ(1u, ZigZagEncode32(-1));
- EXPECT_EQ(2u, ZigZagEncode32( 1));
+ EXPECT_EQ(2u, ZigZagEncode32(1));
EXPECT_EQ(3u, ZigZagEncode32(-2));
EXPECT_EQ(0x7FFFFFFEu, ZigZagEncode32(0x3FFFFFFF));
EXPECT_EQ(0x7FFFFFFFu, ZigZagEncode32(0xC0000000));
EXPECT_EQ(0xFFFFFFFEu, ZigZagEncode32(0x7FFFFFFF));
EXPECT_EQ(0xFFFFFFFFu, ZigZagEncode32(0x80000000));
- EXPECT_EQ( 0, ZigZagDecode32(0u));
+ EXPECT_EQ(0, ZigZagDecode32(0u));
EXPECT_EQ(-1, ZigZagDecode32(1u));
- EXPECT_EQ( 1, ZigZagDecode32(2u));
+ EXPECT_EQ(1, ZigZagDecode32(2u));
EXPECT_EQ(-2, ZigZagDecode32(3u));
EXPECT_EQ(0x3FFFFFFF, ZigZagDecode32(0x7FFFFFFEu));
EXPECT_EQ(0xC0000000, ZigZagDecode32(0x7FFFFFFFu));
EXPECT_EQ(0x7FFFFFFF, ZigZagDecode32(0xFFFFFFFEu));
EXPECT_EQ(0x80000000, ZigZagDecode32(0xFFFFFFFFu));
- EXPECT_EQ(0u, ZigZagEncode64( 0));
+ EXPECT_EQ(0u, ZigZagEncode64(0));
EXPECT_EQ(1u, ZigZagEncode64(-1));
- EXPECT_EQ(2u, ZigZagEncode64( 1));
+ EXPECT_EQ(2u, ZigZagEncode64(1));
EXPECT_EQ(3u, ZigZagEncode64(-2));
EXPECT_EQ(ULL(0x000000007FFFFFFE), ZigZagEncode64(LL(0x000000003FFFFFFF)));
EXPECT_EQ(ULL(0x000000007FFFFFFF), ZigZagEncode64(LL(0xFFFFFFFFC0000000)));
@@ -762,9 +781,9 @@
EXPECT_EQ(ULL(0xFFFFFFFFFFFFFFFE), ZigZagEncode64(LL(0x7FFFFFFFFFFFFFFF)));
EXPECT_EQ(ULL(0xFFFFFFFFFFFFFFFF), ZigZagEncode64(LL(0x8000000000000000)));
- EXPECT_EQ( 0, ZigZagDecode64(0u));
+ EXPECT_EQ(0, ZigZagDecode64(0u));
EXPECT_EQ(-1, ZigZagDecode64(1u));
- EXPECT_EQ( 1, ZigZagDecode64(2u));
+ EXPECT_EQ(1, ZigZagDecode64(2u));
EXPECT_EQ(-2, ZigZagDecode64(3u));
EXPECT_EQ(LL(0x000000003FFFFFFF), ZigZagDecode64(ULL(0x000000007FFFFFFE)));
EXPECT_EQ(LL(0xFFFFFFFFC0000000), ZigZagDecode64(ULL(0x000000007FFFFFFF)));
@@ -775,22 +794,22 @@
// Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1)
// were chosen semi-randomly via keyboard bashing.
- EXPECT_EQ( 0, ZigZagDecode32(ZigZagEncode32( 0)));
- EXPECT_EQ( 1, ZigZagDecode32(ZigZagEncode32( 1)));
- EXPECT_EQ( -1, ZigZagDecode32(ZigZagEncode32( -1)));
+ EXPECT_EQ(0, ZigZagDecode32(ZigZagEncode32(0)));
+ EXPECT_EQ(1, ZigZagDecode32(ZigZagEncode32(1)));
+ EXPECT_EQ(-1, ZigZagDecode32(ZigZagEncode32(-1)));
EXPECT_EQ(14927, ZigZagDecode32(ZigZagEncode32(14927)));
EXPECT_EQ(-3612, ZigZagDecode32(ZigZagEncode32(-3612)));
- EXPECT_EQ( 0, ZigZagDecode64(ZigZagEncode64( 0)));
- EXPECT_EQ( 1, ZigZagDecode64(ZigZagEncode64( 1)));
- EXPECT_EQ( -1, ZigZagDecode64(ZigZagEncode64( -1)));
+ EXPECT_EQ(0, ZigZagDecode64(ZigZagEncode64(0)));
+ EXPECT_EQ(1, ZigZagDecode64(ZigZagEncode64(1)));
+ EXPECT_EQ(-1, ZigZagDecode64(ZigZagEncode64(-1)));
EXPECT_EQ(14927, ZigZagDecode64(ZigZagEncode64(14927)));
EXPECT_EQ(-3612, ZigZagDecode64(ZigZagEncode64(-3612)));
- EXPECT_EQ(LL(856912304801416), ZigZagDecode64(ZigZagEncode64(
- LL(856912304801416))));
- EXPECT_EQ(LL(-75123905439571256), ZigZagDecode64(ZigZagEncode64(
- LL(-75123905439571256))));
+ EXPECT_EQ(LL(856912304801416),
+ ZigZagDecode64(ZigZagEncode64(LL(856912304801416))));
+ EXPECT_EQ(LL(-75123905439571256),
+ ZigZagDecode64(ZigZagEncode64(LL(-75123905439571256))));
}
TEST(WireFormatTest, RepeatedScalarsDifferentTagSizes) {
@@ -1029,8 +1048,8 @@
// contains exactly the given bytes, which may be invalid.
std::string MakeInvalidEmbeddedMessage(const char* bytes, int size) {
const FieldDescriptor* field =
- unittest::TestAllTypes::descriptor()->FindFieldByName(
- "optional_nested_message");
+ unittest::TestAllTypes::descriptor()->FindFieldByName(
+ "optional_nested_message");
GOOGLE_CHECK(field != NULL);
std::string result;
@@ -1052,8 +1071,7 @@
std::string MakeInvalidGroup(const char* bytes, int size,
bool include_end_tag) {
const FieldDescriptor* field =
- unittest::TestAllTypes::descriptor()->FindFieldByName(
- "optionalgroup");
+ unittest::TestAllTypes::descriptor()->FindFieldByName("optionalgroup");
GOOGLE_CHECK(field != NULL);
std::string result;
@@ -1066,7 +1084,7 @@
output.WriteString(std::string(bytes, size));
if (include_end_tag) {
output.WriteVarint32(WireFormatLite::MakeTag(
- field->number(), WireFormatLite::WIRETYPE_END_GROUP));
+ field->number(), WireFormatLite::WIRETYPE_END_GROUP));
}
}
@@ -1115,7 +1133,6 @@
}
}
-
TEST_F(WireFormatInvalidInputTest, InvalidGroup) {
unittest::TestAllTypes message;
@@ -1191,10 +1208,10 @@
// ReadValidUTF8String: fine.
// WriteAnyBytes: fine.
// ReadAnyBytes: fine.
-const char * kInvalidUTF8String = "Invalid UTF-8: \xA0\xB0\xC0\xD0";
+const char* kInvalidUTF8String = "Invalid UTF-8: \xA0\xB0\xC0\xD0";
// This used to be "Valid UTF-8: \x01\x02\u8C37\u6B4C", but MSVC seems to
// interpret \u differently from GCC.
-const char * kValidUTF8String = "Valid UTF-8: \x01\x02\350\260\267\346\255\214";
+const char* kValidUTF8String = "Valid UTF-8: \x01\x02\350\260\267\346\255\214";
template <typename T>
bool WriteMessage(const char* value, T* message, std::string* wire_buffer) {
diff --git a/src/google/protobuf/wrappers.pb.cc b/src/google/protobuf/wrappers.pb.cc
index c7277d9..bedf4e1 100644
--- a/src/google/protobuf/wrappers.pb.cc
+++ b/src/google/protobuf/wrappers.pb.cc
@@ -180,18 +180,6 @@
PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BytesValue_google_2fprotobuf_2fwrappers_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsBytesValue_google_2fprotobuf_2fwrappers_2eproto}, {}};
-void InitDefaults_google_2fprotobuf_2fwrappers_2eproto() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DoubleValue_google_2fprotobuf_2fwrappers_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FloatValue_google_2fprotobuf_2fwrappers_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Int64Value_google_2fprotobuf_2fwrappers_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UInt64Value_google_2fprotobuf_2fwrappers_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Int32Value_google_2fprotobuf_2fwrappers_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UInt32Value_google_2fprotobuf_2fwrappers_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BoolValue_google_2fprotobuf_2fwrappers_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_StringValue_google_2fprotobuf_2fwrappers_2eproto.base);
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BytesValue_google_2fprotobuf_2fwrappers_2eproto.base);
-}
-
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2fwrappers_2eproto[9];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2fwrappers_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fwrappers_2eproto = nullptr;
@@ -297,8 +285,7 @@
"\006proto3"
;
static ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fwrappers_2eproto = {
- false, InitDefaults_google_2fprotobuf_2fwrappers_2eproto,
- descriptor_table_protodef_google_2fprotobuf_2fwrappers_2eproto,
+ false, descriptor_table_protodef_google_2fprotobuf_2fwrappers_2eproto,
"google/protobuf/wrappers.proto", &assign_descriptors_table_google_2fprotobuf_2fwrappers_2eproto, 447,
};
@@ -306,6 +293,15 @@
static constexpr ::PROTOBUF_NAMESPACE_ID::internal::InitFunc deps[1] =
{
};
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DoubleValue_google_2fprotobuf_2fwrappers_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FloatValue_google_2fprotobuf_2fwrappers_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Int64Value_google_2fprotobuf_2fwrappers_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UInt64Value_google_2fprotobuf_2fwrappers_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Int32Value_google_2fprotobuf_2fwrappers_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UInt32Value_google_2fprotobuf_2fwrappers_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BoolValue_google_2fprotobuf_2fwrappers_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_StringValue_google_2fprotobuf_2fwrappers_2eproto.base);
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BytesValue_google_2fprotobuf_2fwrappers_2eproto.base);
::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_google_2fprotobuf_2fwrappers_2eproto, deps, 0);
}
@@ -385,16 +381,17 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* DoubleValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// double value = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 9) goto handle_unusual;
- set_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
+ value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
ptr += sizeof(double);
break;
}
@@ -402,15 +399,20 @@
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool DoubleValue::MergePartialFromCodedStream(
@@ -665,16 +667,17 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* FloatValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// float value = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 13) goto handle_unusual;
- set_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
ptr += sizeof(float);
break;
}
@@ -682,15 +685,20 @@
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool FloatValue::MergePartialFromCodedStream(
@@ -945,32 +953,38 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Int64Value::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// int64 value = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Int64Value::MergePartialFromCodedStream(
@@ -1227,32 +1241,38 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* UInt64Value::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// uint64 value = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool UInt64Value::MergePartialFromCodedStream(
@@ -1509,32 +1529,38 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Int32Value::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// int32 value = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Int32Value::MergePartialFromCodedStream(
@@ -1791,32 +1817,38 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* UInt32Value::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// uint32 value = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool UInt32Value::MergePartialFromCodedStream(
@@ -2073,32 +2105,38 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* BoolValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// bool value = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 8) goto handle_unusual;
- set_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool BoolValue::MergePartialFromCodedStream(
@@ -2360,32 +2398,38 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* StringValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// string value = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_value(), ptr, ctx, "google.protobuf.StringValue.value");
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool StringValue::MergePartialFromCodedStream(
@@ -2663,32 +2707,38 @@
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* BytesValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
switch (tag >> 3) {
// bytes value = 1;
case 1: {
if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) != 10) goto handle_unusual;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_value(), ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+ CHK_(ptr);
break;
}
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
- return ptr;
+ goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
- GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+ CHK_(ptr != nullptr);
break;
}
} // switch
} // while
+success:
return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool BytesValue::MergePartialFromCodedStream(
