| // 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; |
| } |
| } |
