|  | @@ -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;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 |