正在查看： CallApp v2.226 应用的 GeneratedMessageV3.java JAVA 源代码文件
本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。
页面标题
页面副标题
CallApp v2.226 - GeneratedMessageV3.java 源代码
package com.explorestack.protobuf;
import a1.d0;
import com.explorestack.protobuf.AbstractMessage;
import com.explorestack.protobuf.Descriptors;
import com.explorestack.protobuf.DynamicMessage;
import com.explorestack.protobuf.FieldSet;
import com.explorestack.protobuf.GeneratedMessage;
import com.explorestack.protobuf.GeneratedMessageLite;
import com.explorestack.protobuf.Internal;
import com.explorestack.protobuf.LazyField;
import com.explorestack.protobuf.Message;
import com.explorestack.protobuf.MessageReflection;
import com.explorestack.protobuf.UnknownFieldSet;
import com.explorestack.protobuf.WireFormat;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public abstract class GeneratedMessageV3 extends AbstractMessage implements Serializable {
protected static boolean alwaysUseFieldBuilders = false;
private static final long serialVersionUID = 1;
protected UnknownFieldSet unknownFields;
public static abstract class Builder<BuilderType extends Builder<BuilderType>> extends AbstractMessage.Builder<BuilderType> {
private BuilderParent builderParent;
private boolean isClean;
private Builder<BuilderType>.BuilderParentImpl meAsParent;
private UnknownFieldSet unknownFields;
public class BuilderParentImpl implements BuilderParent {
private BuilderParentImpl() {
}
@Override
public void markDirty() {
Builder.this.onChanged();
}
}
public Builder() {
this(null);
}
public Map<Descriptors.FieldDescriptor, Object> getAllFieldsMutable() {
TreeMap treeMap = new TreeMap();
List<Descriptors.FieldDescriptor> fields = internalGetFieldAccessorTable().descriptor.getFields();
int i = 0;
while (i < fields.size()) {
Descriptors.FieldDescriptor fieldDescriptor = fields.get(i);
Descriptors.OneofDescriptor containingOneof = fieldDescriptor.getContainingOneof();
if (containingOneof != null) {
i += containingOneof.getFieldCount() - 1;
if (hasOneof(containingOneof)) {
fieldDescriptor = getOneofFieldDescriptor(containingOneof);
treeMap.put(fieldDescriptor, getField(fieldDescriptor));
i++;
} else {
i++;
}
} else {
if (fieldDescriptor.isRepeated()) {
List list = (List) getField(fieldDescriptor);
if (!list.isEmpty()) {
treeMap.put(fieldDescriptor, list);
}
} else {
if (!hasField(fieldDescriptor)) {
}
treeMap.put(fieldDescriptor, getField(fieldDescriptor));
}
i++;
}
}
return treeMap;
}
private BuilderType setUnknownFieldsInternal(UnknownFieldSet unknownFieldSet) {
this.unknownFields = unknownFieldSet;
onChanged();
return this;
}
@Override
public void dispose() {
this.builderParent = null;
}
@Override
public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
return Collections.unmodifiableMap(getAllFieldsMutable());
}
public Descriptors.Descriptor getDescriptorForType() {
return internalGetFieldAccessorTable().descriptor;
}
@Override
public Object getField(Descriptors.FieldDescriptor fieldDescriptor) {
Object obj = internalGetFieldAccessorTable().getField(fieldDescriptor).get(this);
return fieldDescriptor.isRepeated() ? Collections.unmodifiableList((List) obj) : obj;
}
@Override
public Message.Builder getFieldBuilder(Descriptors.FieldDescriptor fieldDescriptor) {
return internalGetFieldAccessorTable().getField(fieldDescriptor).getBuilder(this);
}
@Override
public Descriptors.FieldDescriptor getOneofFieldDescriptor(Descriptors.OneofDescriptor oneofDescriptor) {
return internalGetFieldAccessorTable().getOneof(oneofDescriptor).get(this);
}
public BuilderParent getParentForChildren() {
if (this.meAsParent == null) {
this.meAsParent = new BuilderParentImpl();
}
return this.meAsParent;
}
@Override
public Object getRepeatedField(Descriptors.FieldDescriptor fieldDescriptor, int i) {
return internalGetFieldAccessorTable().getField(fieldDescriptor).getRepeated(this, i);
}
@Override
public Message.Builder getRepeatedFieldBuilder(Descriptors.FieldDescriptor fieldDescriptor, int i) {
return internalGetFieldAccessorTable().getField(fieldDescriptor).getRepeatedBuilder(this, i);
}
@Override
public int getRepeatedFieldCount(Descriptors.FieldDescriptor fieldDescriptor) {
return internalGetFieldAccessorTable().getField(fieldDescriptor).getRepeatedCount(this);
}
@Override
public final UnknownFieldSet getUnknownFields() {
return this.unknownFields;
}
@Override
public boolean hasField(Descriptors.FieldDescriptor fieldDescriptor) {
return internalGetFieldAccessorTable().getField(fieldDescriptor).has(this);
}
@Override
public boolean hasOneof(Descriptors.OneofDescriptor oneofDescriptor) {
return internalGetFieldAccessorTable().getOneof(oneofDescriptor).has(this);
}
public abstract FieldAccessorTable internalGetFieldAccessorTable();
public MapField internalGetMapField(int i) {
throw new RuntimeException("No map fields found in ".concat(getClass().getName()));
}
public MapField internalGetMutableMapField(int i) {
throw new RuntimeException("No map fields found in ".concat(getClass().getName()));
}
public boolean isClean() {
return this.isClean;
}
@Override
public boolean isInitialized() {
for (Descriptors.FieldDescriptor fieldDescriptor : getDescriptorForType().getFields()) {
if (fieldDescriptor.isRequired() && !hasField(fieldDescriptor)) {
return false;
}
if (fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE) {
if (fieldDescriptor.isRepeated()) {
Iterator it = ((List) getField(fieldDescriptor)).iterator();
while (it.hasNext()) {
if (!((Message) it.next()).isInitialized()) {
return false;
}
}
} else if (hasField(fieldDescriptor) && !((Message) getField(fieldDescriptor)).isInitialized()) {
return false;
}
}
}
return true;
}
@Override
public void markClean() {
this.isClean = true;
}
@Override
public Message.Builder newBuilderForField(Descriptors.FieldDescriptor fieldDescriptor) {
return internalGetFieldAccessorTable().getField(fieldDescriptor).newBuilder();
}
public void onBuilt() {
if (this.builderParent != null) {
markClean();
}
}
public final void onChanged() {
BuilderParent builderParent;
if (!this.isClean || (builderParent = this.builderParent) == null) {
return;
}
builderParent.markDirty();
this.isClean = false;
}
public BuilderType setUnknownFieldsProto3(UnknownFieldSet unknownFieldSet) {
return setUnknownFieldsInternal(unknownFieldSet);
}
public Builder(BuilderParent builderParent) {
this.unknownFields = UnknownFieldSet.getDefaultInstance();
this.builderParent = builderParent;
}
public BuilderType addRepeatedField(Descriptors.FieldDescriptor fieldDescriptor, Object obj) {
internalGetFieldAccessorTable().getField(fieldDescriptor).addRepeated(this, obj);
return this;
}
public BuilderType clearField(Descriptors.FieldDescriptor fieldDescriptor) {
internalGetFieldAccessorTable().getField(fieldDescriptor).clear(this);
return this;
}
public BuilderType setField(Descriptors.FieldDescriptor fieldDescriptor, Object obj) {
internalGetFieldAccessorTable().getField(fieldDescriptor).set(this, obj);
return this;
}
public BuilderType setRepeatedField(Descriptors.FieldDescriptor fieldDescriptor, int i, Object obj) {
internalGetFieldAccessorTable().getField(fieldDescriptor).setRepeated(this, i, obj);
return this;
}
public BuilderType setUnknownFields(UnknownFieldSet unknownFieldSet) {
return setUnknownFieldsInternal(unknownFieldSet);
}
@Override
public BuilderType clearOneof(Descriptors.OneofDescriptor oneofDescriptor) {
internalGetFieldAccessorTable().getOneof(oneofDescriptor).clear(this);
return this;
}
@Override
public BuilderType mergeUnknownFields(UnknownFieldSet unknownFieldSet) {
return setUnknownFields(UnknownFieldSet.newBuilder(this.unknownFields).mergeFrom(unknownFieldSet).build());
}
@Override
public BuilderType clear() {
this.unknownFields = UnknownFieldSet.getDefaultInstance();
onChanged();
return this;
}
@Override
public BuilderType mo62clone() {
BuilderType buildertype = (BuilderType) getDefaultInstanceForType().newBuilderForType();
buildertype.mergeFrom(buildPartial());
return buildertype;
}
}
public interface BuilderParent extends AbstractMessage.BuilderParent {
}
public static abstract class ExtendableBuilder<MessageType extends ExtendableMessage, BuilderType extends ExtendableBuilder<MessageType, BuilderType>> extends Builder<BuilderType> implements ExtendableMessageOrBuilder<MessageType> {
private FieldSet.Builder<Descriptors.FieldDescriptor> extensions;
public ExtendableBuilder() {
}
public FieldSet<Descriptors.FieldDescriptor> buildExtensions() {
FieldSet.Builder<Descriptors.FieldDescriptor> builder = this.extensions;
return builder == null ? FieldSet.emptySet() : builder.build();
}
private void ensureExtensionsIsMutable() {
if (this.extensions == null) {
this.extensions = FieldSet.newBuilder();
}
}
private void verifyContainingType(Descriptors.FieldDescriptor fieldDescriptor) {
if (fieldDescriptor.getContainingType() != getDescriptorForType()) {
throw new IllegalArgumentException("FieldDescriptor does not match message type.");
}
}
private void verifyExtensionContainingType(Extension<MessageType, ?> extension) {
if (extension.getDescriptor().getContainingType() == getDescriptorForType()) {
return;
}
throw new IllegalArgumentException("Extension is for type \"" + extension.getDescriptor().getContainingType().getFullName() + "\" which does not match message type \"" + getDescriptorForType().getFullName() + "\".");
}
public final <Type> BuilderType addExtension(ExtensionLite<MessageType, List<Type>> extensionLite, Type type) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
ensureExtensionsIsMutable();
this.extensions.addRepeatedField(checkNotLite.getDescriptor(), checkNotLite.singularToReflectionType(type));
onChanged();
return this;
}
public final BuilderType clearExtension(ExtensionLite<MessageType, ?> extensionLite) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
ensureExtensionsIsMutable();
this.extensions.clearField(checkNotLite.getDescriptor());
onChanged();
return this;
}
public boolean extensionsAreInitialized() {
FieldSet.Builder<Descriptors.FieldDescriptor> builder = this.extensions;
if (builder == null) {
return true;
}
return builder.isInitialized();
}
@Override
public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
Map allFieldsMutable = getAllFieldsMutable();
FieldSet.Builder<Descriptors.FieldDescriptor> builder = this.extensions;
if (builder != null) {
allFieldsMutable.putAll(builder.getAllFields());
}
return Collections.unmodifiableMap(allFieldsMutable);
}
@Override
public final <Type> Type getExtension(ExtensionLite<MessageType, Type> extensionLite) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
Descriptors.FieldDescriptor descriptor = checkNotLite.getDescriptor();
FieldSet.Builder<Descriptors.FieldDescriptor> builder = this.extensions;
Object field = builder == null ? null : builder.getField(descriptor);
return field == null ? descriptor.isRepeated() ? (Type) Collections.EMPTY_LIST : descriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE ? (Type) checkNotLite.getMessageDefaultInstance() : (Type) checkNotLite.fromReflectionType(descriptor.getDefaultValue()) : (Type) checkNotLite.fromReflectionType(field);
}
@Override
public final <Type> int getExtensionCount(ExtensionLite<MessageType, List<Type>> extensionLite) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
Descriptors.FieldDescriptor descriptor = checkNotLite.getDescriptor();
FieldSet.Builder<Descriptors.FieldDescriptor> builder = this.extensions;
if (builder == null) {
return 0;
}
return builder.getRepeatedFieldCount(descriptor);
}
@Override
public Object getField(Descriptors.FieldDescriptor fieldDescriptor) {
if (!fieldDescriptor.isExtension()) {
return super.getField(fieldDescriptor);
}
verifyContainingType(fieldDescriptor);
FieldSet.Builder<Descriptors.FieldDescriptor> builder = this.extensions;
Object field = builder == null ? null : builder.getField(fieldDescriptor);
return field == null ? fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE ? DynamicMessage.getDefaultInstance(fieldDescriptor.getMessageType()) : fieldDescriptor.getDefaultValue() : field;
}
@Override
public Message.Builder getFieldBuilder(Descriptors.FieldDescriptor fieldDescriptor) {
if (!fieldDescriptor.isExtension()) {
return super.getFieldBuilder(fieldDescriptor);
}
verifyContainingType(fieldDescriptor);
if (fieldDescriptor.getJavaType() != Descriptors.FieldDescriptor.JavaType.MESSAGE) {
throw new UnsupportedOperationException("getFieldBuilder() called on a non-Message type.");
}
ensureExtensionsIsMutable();
Object fieldAllowBuilders = this.extensions.getFieldAllowBuilders(fieldDescriptor);
if (fieldAllowBuilders == null) {
DynamicMessage.Builder newBuilder = DynamicMessage.newBuilder(fieldDescriptor.getMessageType());
this.extensions.setField(fieldDescriptor, newBuilder);
onChanged();
return newBuilder;
}
if (fieldAllowBuilders instanceof Message.Builder) {
return (Message.Builder) fieldAllowBuilders;
}
if (!(fieldAllowBuilders instanceof Message)) {
throw new UnsupportedOperationException("getRepeatedFieldBuilder() called on a non-Message type.");
}
Message.Builder builder = ((Message) fieldAllowBuilders).toBuilder();
this.extensions.setField(fieldDescriptor, builder);
onChanged();
return builder;
}
@Override
public Object getRepeatedField(Descriptors.FieldDescriptor fieldDescriptor, int i) {
if (!fieldDescriptor.isExtension()) {
return super.getRepeatedField(fieldDescriptor, i);
}
verifyContainingType(fieldDescriptor);
FieldSet.Builder<Descriptors.FieldDescriptor> builder = this.extensions;
if (builder != null) {
return builder.getRepeatedField(fieldDescriptor, i);
}
throw new IndexOutOfBoundsException();
}
@Override
public Message.Builder getRepeatedFieldBuilder(Descriptors.FieldDescriptor fieldDescriptor, int i) {
if (!fieldDescriptor.isExtension()) {
return super.getRepeatedFieldBuilder(fieldDescriptor, i);
}
verifyContainingType(fieldDescriptor);
ensureExtensionsIsMutable();
if (fieldDescriptor.getJavaType() != Descriptors.FieldDescriptor.JavaType.MESSAGE) {
throw new UnsupportedOperationException("getRepeatedFieldBuilder() called on a non-Message type.");
}
Object repeatedFieldAllowBuilders = this.extensions.getRepeatedFieldAllowBuilders(fieldDescriptor, i);
if (repeatedFieldAllowBuilders instanceof Message.Builder) {
return (Message.Builder) repeatedFieldAllowBuilders;
}
if (!(repeatedFieldAllowBuilders instanceof Message)) {
throw new UnsupportedOperationException("getRepeatedFieldBuilder() called on a non-Message type.");
}
Message.Builder builder = ((Message) repeatedFieldAllowBuilders).toBuilder();
this.extensions.setRepeatedField(fieldDescriptor, i, builder);
onChanged();
return builder;
}
@Override
public int getRepeatedFieldCount(Descriptors.FieldDescriptor fieldDescriptor) {
if (!fieldDescriptor.isExtension()) {
return super.getRepeatedFieldCount(fieldDescriptor);
}
verifyContainingType(fieldDescriptor);
FieldSet.Builder<Descriptors.FieldDescriptor> builder = this.extensions;
if (builder == null) {
return 0;
}
return builder.getRepeatedFieldCount(fieldDescriptor);
}
@Override
public final <Type> boolean hasExtension(ExtensionLite<MessageType, Type> extensionLite) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
FieldSet.Builder<Descriptors.FieldDescriptor> builder = this.extensions;
if (builder == null) {
return false;
}
return builder.hasField(checkNotLite.getDescriptor());
}
@Override
public boolean hasField(Descriptors.FieldDescriptor fieldDescriptor) {
if (!fieldDescriptor.isExtension()) {
return super.hasField(fieldDescriptor);
}
verifyContainingType(fieldDescriptor);
FieldSet.Builder<Descriptors.FieldDescriptor> builder = this.extensions;
if (builder == null) {
return false;
}
return builder.hasField(fieldDescriptor);
}
public void internalSetExtensionSet(FieldSet<Descriptors.FieldDescriptor> fieldSet) {
this.extensions = FieldSet.Builder.fromFieldSet(fieldSet);
}
@Override
public boolean isInitialized() {
return super.isInitialized() && extensionsAreInitialized();
}
public final void mergeExtensionFields(ExtendableMessage extendableMessage) {
if (extendableMessage.extensions != null) {
ensureExtensionsIsMutable();
this.extensions.mergeFrom(extendableMessage.extensions);
onChanged();
}
}
@Override
public Message.Builder newBuilderForField(Descriptors.FieldDescriptor fieldDescriptor) {
return fieldDescriptor.isExtension() ? DynamicMessage.newBuilder(fieldDescriptor.getMessageType()) : super.newBuilderForField(fieldDescriptor);
}
public final <Type> BuilderType setExtension(ExtensionLite<MessageType, Type> extensionLite, Type type) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
ensureExtensionsIsMutable();
this.extensions.setField(checkNotLite.getDescriptor(), checkNotLite.toReflectionType(type));
onChanged();
return this;
}
public ExtendableBuilder(BuilderParent builderParent) {
super(builderParent);
}
@Override
public BuilderType addRepeatedField(Descriptors.FieldDescriptor fieldDescriptor, Object obj) {
if (fieldDescriptor.isExtension()) {
verifyContainingType(fieldDescriptor);
ensureExtensionsIsMutable();
this.extensions.addRepeatedField(fieldDescriptor, obj);
onChanged();
return this;
}
return (BuilderType) super.addRepeatedField(fieldDescriptor, obj);
}
@Override
public BuilderType clearField(Descriptors.FieldDescriptor fieldDescriptor) {
if (fieldDescriptor.isExtension()) {
verifyContainingType(fieldDescriptor);
ensureExtensionsIsMutable();
this.extensions.clearField(fieldDescriptor);
onChanged();
return this;
}
return (BuilderType) super.clearField(fieldDescriptor);
}
@Override
public BuilderType setField(Descriptors.FieldDescriptor fieldDescriptor, Object obj) {
if (fieldDescriptor.isExtension()) {
verifyContainingType(fieldDescriptor);
ensureExtensionsIsMutable();
this.extensions.setField(fieldDescriptor, obj);
onChanged();
return this;
}
return (BuilderType) super.setField(fieldDescriptor, obj);
}
@Override
public BuilderType setRepeatedField(Descriptors.FieldDescriptor fieldDescriptor, int i, Object obj) {
if (fieldDescriptor.isExtension()) {
verifyContainingType(fieldDescriptor);
ensureExtensionsIsMutable();
this.extensions.setRepeatedField(fieldDescriptor, i, obj);
onChanged();
return this;
}
return (BuilderType) super.setRepeatedField(fieldDescriptor, i, obj);
}
@Override
public final <Type> boolean hasExtension(Extension<MessageType, Type> extension) {
return hasExtension((ExtensionLite) extension);
}
@Override
public BuilderType clear() {
this.extensions = null;
return (BuilderType) super.clear();
}
@Override
public final <Type> int getExtensionCount(Extension<MessageType, List<Type>> extension) {
return getExtensionCount((ExtensionLite) extension);
}
@Override
public final <Type> boolean hasExtension(GeneratedMessage.GeneratedExtension<MessageType, Type> generatedExtension) {
return hasExtension((ExtensionLite) generatedExtension);
}
public final <Type> BuilderType clearExtension(Extension<MessageType, ?> extension) {
return clearExtension((ExtensionLite) extension);
}
@Override
public final <Type> int getExtensionCount(GeneratedMessage.GeneratedExtension<MessageType, List<Type>> generatedExtension) {
return getExtensionCount((ExtensionLite) generatedExtension);
}
public <Type> BuilderType clearExtension(GeneratedMessage.GeneratedExtension<MessageType, ?> generatedExtension) {
return clearExtension((ExtensionLite) generatedExtension);
}
public final <Type> BuilderType setExtension(ExtensionLite<MessageType, List<Type>> extensionLite, int i, Type type) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
ensureExtensionsIsMutable();
this.extensions.setRepeatedField(checkNotLite.getDescriptor(), i, checkNotLite.singularToReflectionType(type));
onChanged();
return this;
}
public final <Type> BuilderType addExtension(Extension<MessageType, List<Type>> extension, Type type) {
return addExtension(extension, (Extension<MessageType, List<Type>>) type);
}
public <Type> BuilderType addExtension(GeneratedMessage.GeneratedExtension<MessageType, List<Type>> generatedExtension, Type type) {
return addExtension((ExtensionLite<MessageType, List<GeneratedMessage.GeneratedExtension<MessageType, List<Type>>>>) generatedExtension, (GeneratedMessage.GeneratedExtension<MessageType, List<Type>>) type);
}
@Override
public final <Type> Type getExtension(ExtensionLite<MessageType, List<Type>> extensionLite, int i) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
Descriptors.FieldDescriptor descriptor = checkNotLite.getDescriptor();
FieldSet.Builder<Descriptors.FieldDescriptor> builder = this.extensions;
if (builder != null) {
return (Type) checkNotLite.singularFromReflectionType(builder.getRepeatedField(descriptor, i));
}
throw new IndexOutOfBoundsException();
}
public final <Type> BuilderType setExtension(Extension<MessageType, Type> extension, Type type) {
return setExtension(extension, (Extension<MessageType, Type>) type);
}
public <Type> BuilderType setExtension(GeneratedMessage.GeneratedExtension<MessageType, Type> generatedExtension, Type type) {
return setExtension((ExtensionLite<MessageType, GeneratedMessage.GeneratedExtension<MessageType, Type>>) generatedExtension, (GeneratedMessage.GeneratedExtension<MessageType, Type>) type);
}
public final <Type> BuilderType setExtension(Extension<MessageType, List<Type>> extension, int i, Type type) {
return setExtension((ExtensionLite<MessageType, List<int>>) extension, i, (int) type);
}
@Override
public final <Type> Type getExtension(Extension<MessageType, Type> extension) {
return (Type) getExtension((ExtensionLite) extension);
}
public <Type> BuilderType setExtension(GeneratedMessage.GeneratedExtension<MessageType, List<Type>> generatedExtension, int i, Type type) {
return setExtension((ExtensionLite<MessageType, List<int>>) generatedExtension, i, (int) type);
}
@Override
public final <Type> Type getExtension(GeneratedMessage.GeneratedExtension<MessageType, Type> generatedExtension) {
return (Type) getExtension((ExtensionLite) generatedExtension);
}
@Override
public final <Type> Type getExtension(Extension<MessageType, List<Type>> extension, int i) {
return (Type) getExtension((ExtensionLite) extension, i);
}
@Override
public final <Type> Type getExtension(GeneratedMessage.GeneratedExtension<MessageType, List<Type>> generatedExtension, int i) {
return (Type) getExtension((ExtensionLite) generatedExtension, i);
}
}
public interface ExtendableMessageOrBuilder<MessageType extends ExtendableMessage> extends MessageOrBuilder {
@Override
Message getDefaultInstanceForType();
<Type> Type getExtension(Extension<MessageType, Type> extension);
<Type> Type getExtension(Extension<MessageType, List<Type>> extension, int i);
<Type> Type getExtension(ExtensionLite<MessageType, Type> extensionLite);
<Type> Type getExtension(ExtensionLite<MessageType, List<Type>> extensionLite, int i);
<Type> Type getExtension(GeneratedMessage.GeneratedExtension<MessageType, Type> generatedExtension);
<Type> Type getExtension(GeneratedMessage.GeneratedExtension<MessageType, List<Type>> generatedExtension, int i);
<Type> int getExtensionCount(Extension<MessageType, List<Type>> extension);
<Type> int getExtensionCount(ExtensionLite<MessageType, List<Type>> extensionLite);
<Type> int getExtensionCount(GeneratedMessage.GeneratedExtension<MessageType, List<Type>> generatedExtension);
<Type> boolean hasExtension(Extension<MessageType, Type> extension);
<Type> boolean hasExtension(ExtensionLite<MessageType, Type> extensionLite);
<Type> boolean hasExtension(GeneratedMessage.GeneratedExtension<MessageType, Type> generatedExtension);
}
public interface ExtensionDescriptorRetriever {
Descriptors.FieldDescriptor getDescriptor();
}
public static final class UnusedPrivateParameter {
static final UnusedPrivateParameter INSTANCE = new UnusedPrivateParameter();
private UnusedPrivateParameter() {
}
}
public GeneratedMessageV3() {
this.unknownFields = UnknownFieldSet.getDefaultInstance();
}
public static boolean canUseUnsafe() {
return UnsafeUtil.hasUnsafeArrayOperations() && UnsafeUtil.hasUnsafeByteBufferOperations();
}
public static <MessageType extends ExtendableMessage<MessageType>, T> Extension<MessageType, T> checkNotLite(ExtensionLite<MessageType, T> extensionLite) {
if (extensionLite.isLite()) {
throw new IllegalArgumentException("Expected non-lite extension.");
}
return (Extension) extensionLite;
}
public static int computeStringSize(int i, Object obj) {
return obj instanceof String ? CodedOutputStream.computeStringSize(i, (String) obj) : CodedOutputStream.computeBytesSize(i, (ByteString) obj);
}
public static int computeStringSizeNoTag(Object obj) {
return obj instanceof String ? CodedOutputStream.computeStringSizeNoTag((String) obj) : CodedOutputStream.computeBytesSizeNoTag((ByteString) obj);
}
public static Internal.BooleanList emptyBooleanList() {
return BooleanArrayList.emptyList();
}
public static Internal.DoubleList emptyDoubleList() {
return DoubleArrayList.emptyList();
}
public static Internal.FloatList emptyFloatList() {
return FloatArrayList.emptyList();
}
public static Internal.IntList emptyIntList() {
return IntArrayList.emptyList();
}
public static Internal.LongList emptyLongList() {
return LongArrayList.emptyList();
}
public static void enableAlwaysUseFieldBuildersForTesting() {
setAlwaysUseFieldBuildersForTesting(true);
}
public Map<Descriptors.FieldDescriptor, Object> getAllFieldsMutable(boolean z) {
TreeMap treeMap = new TreeMap();
List<Descriptors.FieldDescriptor> fields = internalGetFieldAccessorTable().descriptor.getFields();
int i = 0;
while (i < fields.size()) {
Descriptors.FieldDescriptor fieldDescriptor = fields.get(i);
Descriptors.OneofDescriptor containingOneof = fieldDescriptor.getContainingOneof();
if (containingOneof != null) {
i += containingOneof.getFieldCount() - 1;
if (hasOneof(containingOneof)) {
fieldDescriptor = getOneofFieldDescriptor(containingOneof);
if (z || fieldDescriptor.getJavaType() != Descriptors.FieldDescriptor.JavaType.STRING) {
treeMap.put(fieldDescriptor, getField(fieldDescriptor));
} else {
treeMap.put(fieldDescriptor, getFieldRaw(fieldDescriptor));
}
i++;
} else {
i++;
}
} else {
if (fieldDescriptor.isRepeated()) {
List list = (List) getField(fieldDescriptor);
if (!list.isEmpty()) {
treeMap.put(fieldDescriptor, list);
}
} else {
if (!hasField(fieldDescriptor)) {
}
if (z) {
}
treeMap.put(fieldDescriptor, getField(fieldDescriptor));
}
i++;
}
}
return treeMap;
}
public static java.lang.reflect.Method getMethodOrDie(Class cls, String str, Class... clsArr) {
try {
return cls.getMethod(str, clsArr);
} catch (NoSuchMethodException e) {
throw new RuntimeException("Generated message class \"" + cls.getName() + "\" missing method \"" + str + "\".", e);
}
}
public static Object invokeOrDie(java.lang.reflect.Method method, Object obj, Object... objArr) {
try {
return method.invoke(obj, objArr);
} catch (IllegalAccessException e) {
throw new RuntimeException("Couldn't use Java reflection to implement protocol message reflection.", e);
} catch (InvocationTargetException e2) {
Throwable cause = e2.getCause();
if (cause instanceof RuntimeException) {
throw ((RuntimeException) cause);
}
if (cause instanceof Error) {
throw ((Error) cause);
}
throw new RuntimeException("Unexpected exception thrown by generated accessor method.", cause);
}
}
private static <V> void maybeSerializeBooleanEntryTo(CodedOutputStream codedOutputStream, Map<Boolean, V> map, MapEntry<Boolean, V> mapEntry, int i, boolean z) throws IOException {
if (map.containsKey(Boolean.valueOf(z))) {
codedOutputStream.writeMessage(i, mapEntry.newBuilderForType().setKey(Boolean.valueOf(z)).setValue(map.get(Boolean.valueOf(z))).build());
}
}
public static Internal.IntList mutableCopy(Internal.IntList intList) {
int size = intList.size();
return intList.mutableCopyWithCapacity2(size == 0 ? 10 : size * 2);
}
public static Internal.BooleanList newBooleanList() {
return new BooleanArrayList();
}
public static Internal.DoubleList newDoubleList() {
return new DoubleArrayList();
}
public static Internal.FloatList newFloatList() {
return new FloatArrayList();
}
public static Internal.IntList newIntList() {
return new IntArrayList();
}
public static Internal.LongList newLongList() {
return new LongArrayList();
}
public static <M extends Message> M parseDelimitedWithIOException(Parser<M> parser, InputStream inputStream) throws IOException {
try {
return parser.parseDelimitedFrom(inputStream);
} catch (InvalidProtocolBufferException e) {
throw e.unwrapIOException();
}
}
public static <M extends Message> M parseWithIOException(Parser<M> parser, InputStream inputStream) throws IOException {
try {
return parser.parseFrom(inputStream);
} catch (InvalidProtocolBufferException e) {
throw e.unwrapIOException();
}
}
public static <V> void serializeBooleanMapTo(CodedOutputStream codedOutputStream, MapField<Boolean, V> mapField, MapEntry<Boolean, V> mapEntry, int i) throws IOException {
Map<Boolean, V> map = mapField.getMap();
if (!codedOutputStream.isSerializationDeterministic()) {
serializeMapTo(codedOutputStream, map, mapEntry, i);
} else {
maybeSerializeBooleanEntryTo(codedOutputStream, map, mapEntry, i, false);
maybeSerializeBooleanEntryTo(codedOutputStream, map, mapEntry, i, true);
}
}
public static <V> void serializeIntegerMapTo(CodedOutputStream codedOutputStream, MapField<Integer, V> mapField, MapEntry<Integer, V> mapEntry, int i) throws IOException {
Map<Integer, V> map = mapField.getMap();
if (!codedOutputStream.isSerializationDeterministic()) {
serializeMapTo(codedOutputStream, map, mapEntry, i);
return;
}
int size = map.size();
int[] iArr = new int[size];
Iterator<Integer> it = map.keySet().iterator();
int i2 = 0;
while (it.hasNext()) {
iArr[i2] = it.next().intValue();
i2++;
}
Arrays.sort(iArr);
for (int i3 = 0; i3 < size; i3++) {
int i4 = iArr[i3];
codedOutputStream.writeMessage(i, mapEntry.newBuilderForType().setKey(Integer.valueOf(i4)).setValue(map.get(Integer.valueOf(i4))).build());
}
}
public static <V> void serializeLongMapTo(CodedOutputStream codedOutputStream, MapField<Long, V> mapField, MapEntry<Long, V> mapEntry, int i) throws IOException {
Map<Long, V> map = mapField.getMap();
if (!codedOutputStream.isSerializationDeterministic()) {
serializeMapTo(codedOutputStream, map, mapEntry, i);
return;
}
int size = map.size();
long[] jArr = new long[size];
Iterator<Long> it = map.keySet().iterator();
int i2 = 0;
while (it.hasNext()) {
jArr[i2] = it.next().longValue();
i2++;
}
Arrays.sort(jArr);
for (int i3 = 0; i3 < size; i3++) {
long j = jArr[i3];
codedOutputStream.writeMessage(i, mapEntry.newBuilderForType().setKey(Long.valueOf(j)).setValue(map.get(Long.valueOf(j))).build());
}
}
private static <K, V> void serializeMapTo(CodedOutputStream codedOutputStream, Map<K, V> map, MapEntry<K, V> mapEntry, int i) throws IOException {
for (Map.Entry<K, V> entry : map.entrySet()) {
codedOutputStream.writeMessage(i, mapEntry.newBuilderForType().setKey(entry.getKey()).setValue(entry.getValue()).build());
}
}
public static <V> void serializeStringMapTo(CodedOutputStream codedOutputStream, MapField<String, V> mapField, MapEntry<String, V> mapEntry, int i) throws IOException {
Map<String, V> map = mapField.getMap();
if (!codedOutputStream.isSerializationDeterministic()) {
serializeMapTo(codedOutputStream, map, mapEntry, i);
return;
}
String[] strArr = (String[]) map.keySet().toArray(new String[map.size()]);
Arrays.sort(strArr);
for (String str : strArr) {
codedOutputStream.writeMessage(i, mapEntry.newBuilderForType().setKey(str).setValue(map.get(str)).build());
}
}
public static void setAlwaysUseFieldBuildersForTesting(boolean z) {
alwaysUseFieldBuilders = z;
}
public static void writeString(CodedOutputStream codedOutputStream, int i, Object obj) throws IOException {
if (obj instanceof String) {
codedOutputStream.writeString(i, (String) obj);
} else {
codedOutputStream.writeBytes(i, (ByteString) obj);
}
}
public static void writeStringNoTag(CodedOutputStream codedOutputStream, Object obj) throws IOException {
if (obj instanceof String) {
codedOutputStream.writeStringNoTag((String) obj);
} else {
codedOutputStream.writeBytesNoTag((ByteString) obj);
}
}
@Override
public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
return Collections.unmodifiableMap(getAllFieldsMutable(false));
}
public Map<Descriptors.FieldDescriptor, Object> getAllFieldsRaw() {
return Collections.unmodifiableMap(getAllFieldsMutable(true));
}
@Override
public Descriptors.Descriptor getDescriptorForType() {
return internalGetFieldAccessorTable().descriptor;
}
@Override
public Object getField(Descriptors.FieldDescriptor fieldDescriptor) {
return internalGetFieldAccessorTable().getField(fieldDescriptor).get(this);
}
public Object getFieldRaw(Descriptors.FieldDescriptor fieldDescriptor) {
return internalGetFieldAccessorTable().getField(fieldDescriptor).getRaw(this);
}
@Override
public Descriptors.FieldDescriptor getOneofFieldDescriptor(Descriptors.OneofDescriptor oneofDescriptor) {
return internalGetFieldAccessorTable().getOneof(oneofDescriptor).get(this);
}
@Override
public Parser<? extends GeneratedMessageV3> getParserForType() {
throw new UnsupportedOperationException("This is supposed to be overridden by subclasses.");
}
@Override
public Object getRepeatedField(Descriptors.FieldDescriptor fieldDescriptor, int i) {
return internalGetFieldAccessorTable().getField(fieldDescriptor).getRepeated(this, i);
}
@Override
public int getRepeatedFieldCount(Descriptors.FieldDescriptor fieldDescriptor) {
return internalGetFieldAccessorTable().getField(fieldDescriptor).getRepeatedCount(this);
}
@Override
public int getSerializedSize() {
int i = this.memoizedSize;
if (i != -1) {
return i;
}
int serializedSize = MessageReflection.getSerializedSize(this, getAllFieldsRaw());
this.memoizedSize = serializedSize;
return serializedSize;
}
public UnknownFieldSet getUnknownFields() {
throw new UnsupportedOperationException("This is supposed to be overridden by subclasses.");
}
@Override
public boolean hasField(Descriptors.FieldDescriptor fieldDescriptor) {
return internalGetFieldAccessorTable().getField(fieldDescriptor).has(this);
}
@Override
public boolean hasOneof(Descriptors.OneofDescriptor oneofDescriptor) {
return internalGetFieldAccessorTable().getOneof(oneofDescriptor).has(this);
}
public abstract FieldAccessorTable internalGetFieldAccessorTable();
public MapField internalGetMapField(int i) {
throw new RuntimeException("No map fields found in ".concat(getClass().getName()));
}
@Override
public boolean isInitialized() {
for (Descriptors.FieldDescriptor fieldDescriptor : getDescriptorForType().getFields()) {
if (fieldDescriptor.isRequired() && !hasField(fieldDescriptor)) {
return false;
}
if (fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE) {
if (fieldDescriptor.isRepeated()) {
Iterator it = ((List) getField(fieldDescriptor)).iterator();
while (it.hasNext()) {
if (!((Message) it.next()).isInitialized()) {
return false;
}
}
} else if (hasField(fieldDescriptor) && !((Message) getField(fieldDescriptor)).isInitialized()) {
return false;
}
}
}
return true;
}
public void makeExtensionsImmutable() {
}
public void mergeFromAndMakeImmutableInternal(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
Schema schemaFor = Protobuf.getInstance().schemaFor((Protobuf) this);
try {
schemaFor.mergeFrom(this, CodedInputStreamReader.forCodedInput(codedInputStream), extensionRegistryLite);
schemaFor.makeImmutable(this);
} catch (InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (IOException e2) {
throw new InvalidProtocolBufferException(e2).setUnfinishedMessage(this);
}
}
@Override
public Message.Builder newBuilderForType(final AbstractMessage.BuilderParent builderParent) {
return newBuilderForType(new BuilderParent() {
@Override
public void markDirty() {
builderParent.markDirty();
}
});
}
public abstract Message.Builder newBuilderForType(BuilderParent builderParent);
public Object newInstance(UnusedPrivateParameter unusedPrivateParameter) {
throw new UnsupportedOperationException("This method must be overridden by the subclass.");
}
public boolean parseUnknownField(CodedInputStream codedInputStream, UnknownFieldSet.Builder builder, ExtensionRegistryLite extensionRegistryLite, int i) throws IOException {
return codedInputStream.shouldDiscardUnknownFields() ? codedInputStream.skipField(i) : builder.mergeFieldFrom(i, codedInputStream);
}
public boolean parseUnknownFieldProto3(CodedInputStream codedInputStream, UnknownFieldSet.Builder builder, ExtensionRegistryLite extensionRegistryLite, int i) throws IOException {
return parseUnknownField(codedInputStream, builder, extensionRegistryLite, i);
}
public Object writeReplace() throws ObjectStreamException {
return new GeneratedMessageLite.SerializedForm(this);
}
@Override
public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
MessageReflection.writeMessageTo(this, getAllFieldsRaw(), codedOutputStream, false);
}
public static abstract class ExtendableMessage<MessageType extends ExtendableMessage> extends GeneratedMessageV3 implements ExtendableMessageOrBuilder<MessageType> {
private static final long serialVersionUID = 1;
private final FieldSet<Descriptors.FieldDescriptor> extensions;
public class ExtensionWriter {
private final Iterator<Map.Entry<Descriptors.FieldDescriptor, Object>> iter;
private final boolean messageSetWireFormat;
private Map.Entry<Descriptors.FieldDescriptor, Object> next;
public void writeUntil(int i, CodedOutputStream codedOutputStream) throws IOException {
while (true) {
Map.Entry<Descriptors.FieldDescriptor, Object> entry = this.next;
if (entry == null || entry.getKey().getNumber() >= i) {
return;
}
Descriptors.FieldDescriptor key = this.next.getKey();
if (!this.messageSetWireFormat || key.getLiteJavaType() != WireFormat.JavaType.MESSAGE || key.isRepeated()) {
FieldSet.writeField(key, this.next.getValue(), codedOutputStream);
} else if (this.next instanceof LazyField.LazyEntry) {
codedOutputStream.writeRawMessageSetExtension(key.getNumber(), ((LazyField.LazyEntry) this.next).getField().toByteString());
} else {
codedOutputStream.writeMessageSetExtension(key.getNumber(), (Message) this.next.getValue());
}
if (this.iter.hasNext()) {
this.next = this.iter.next();
} else {
this.next = null;
}
}
}
private ExtensionWriter(boolean z) {
Iterator<Map.Entry<Descriptors.FieldDescriptor, Object>> it = ExtendableMessage.this.extensions.iterator();
this.iter = it;
if (it.hasNext()) {
this.next = it.next();
}
this.messageSetWireFormat = z;
}
}
public ExtendableMessage() {
this.extensions = FieldSet.newFieldSet();
}
private void verifyContainingType(Descriptors.FieldDescriptor fieldDescriptor) {
if (fieldDescriptor.getContainingType() != getDescriptorForType()) {
throw new IllegalArgumentException("FieldDescriptor does not match message type.");
}
}
private void verifyExtensionContainingType(Extension<MessageType, ?> extension) {
if (extension.getDescriptor().getContainingType() == getDescriptorForType()) {
return;
}
throw new IllegalArgumentException("Extension is for type \"" + extension.getDescriptor().getContainingType().getFullName() + "\" which does not match message type \"" + getDescriptorForType().getFullName() + "\".");
}
public boolean extensionsAreInitialized() {
return this.extensions.isInitialized();
}
public int extensionsSerializedSize() {
return this.extensions.getSerializedSize();
}
public int extensionsSerializedSizeAsMessageSet() {
return this.extensions.getMessageSetSerializedSize();
}
@Override
public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
Map allFieldsMutable = getAllFieldsMutable(false);
allFieldsMutable.putAll(getExtensionFields());
return Collections.unmodifiableMap(allFieldsMutable);
}
@Override
public Map<Descriptors.FieldDescriptor, Object> getAllFieldsRaw() {
Map allFieldsMutable = getAllFieldsMutable(false);
allFieldsMutable.putAll(getExtensionFields());
return Collections.unmodifiableMap(allFieldsMutable);
}
@Override
public final <Type> Type getExtension(ExtensionLite<MessageType, Type> extensionLite) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
Descriptors.FieldDescriptor descriptor = checkNotLite.getDescriptor();
Object field = this.extensions.getField(descriptor);
return field == null ? descriptor.isRepeated() ? (Type) Collections.EMPTY_LIST : descriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE ? (Type) checkNotLite.getMessageDefaultInstance() : (Type) checkNotLite.fromReflectionType(descriptor.getDefaultValue()) : (Type) checkNotLite.fromReflectionType(field);
}
@Override
public final <Type> int getExtensionCount(ExtensionLite<MessageType, List<Type>> extensionLite) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
return this.extensions.getRepeatedFieldCount(checkNotLite.getDescriptor());
}
public Map<Descriptors.FieldDescriptor, Object> getExtensionFields() {
return this.extensions.getAllFields();
}
@Override
public Object getField(Descriptors.FieldDescriptor fieldDescriptor) {
if (!fieldDescriptor.isExtension()) {
return super.getField(fieldDescriptor);
}
verifyContainingType(fieldDescriptor);
Object field = this.extensions.getField(fieldDescriptor);
return field == null ? fieldDescriptor.isRepeated() ? Collections.EMPTY_LIST : fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE ? DynamicMessage.getDefaultInstance(fieldDescriptor.getMessageType()) : fieldDescriptor.getDefaultValue() : field;
}
@Override
public Object getRepeatedField(Descriptors.FieldDescriptor fieldDescriptor, int i) {
if (!fieldDescriptor.isExtension()) {
return super.getRepeatedField(fieldDescriptor, i);
}
verifyContainingType(fieldDescriptor);
return this.extensions.getRepeatedField(fieldDescriptor, i);
}
@Override
public int getRepeatedFieldCount(Descriptors.FieldDescriptor fieldDescriptor) {
if (!fieldDescriptor.isExtension()) {
return super.getRepeatedFieldCount(fieldDescriptor);
}
verifyContainingType(fieldDescriptor);
return this.extensions.getRepeatedFieldCount(fieldDescriptor);
}
@Override
public final <Type> boolean hasExtension(ExtensionLite<MessageType, Type> extensionLite) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
return this.extensions.hasField(checkNotLite.getDescriptor());
}
@Override
public boolean hasField(Descriptors.FieldDescriptor fieldDescriptor) {
if (!fieldDescriptor.isExtension()) {
return super.hasField(fieldDescriptor);
}
verifyContainingType(fieldDescriptor);
return this.extensions.hasField(fieldDescriptor);
}
@Override
public boolean isInitialized() {
return super.isInitialized() && extensionsAreInitialized();
}
@Override
public void makeExtensionsImmutable() {
this.extensions.makeImmutable();
}
public ExtendableMessage<MessageType>.ExtensionWriter newExtensionWriter() {
return new ExtensionWriter(false);
}
public ExtendableMessage<MessageType>.ExtensionWriter newMessageSetExtensionWriter() {
return new ExtensionWriter(true);
}
@Override
public boolean parseUnknownField(CodedInputStream codedInputStream, UnknownFieldSet.Builder builder, ExtensionRegistryLite extensionRegistryLite, int i) throws IOException {
if (codedInputStream.shouldDiscardUnknownFields()) {
builder = null;
}
return MessageReflection.mergeFieldFrom(codedInputStream, builder, extensionRegistryLite, getDescriptorForType(), new MessageReflection.ExtensionAdapter(this.extensions), i);
}
@Override
public boolean parseUnknownFieldProto3(CodedInputStream codedInputStream, UnknownFieldSet.Builder builder, ExtensionRegistryLite extensionRegistryLite, int i) throws IOException {
return parseUnknownField(codedInputStream, builder, extensionRegistryLite, i);
}
public ExtendableMessage(ExtendableBuilder<MessageType, ?> extendableBuilder) {
super(extendableBuilder);
this.extensions = extendableBuilder.buildExtensions();
}
@Override
public final <Type> boolean hasExtension(Extension<MessageType, Type> extension) {
return hasExtension((ExtensionLite) extension);
}
@Override
public final <Type> int getExtensionCount(Extension<MessageType, List<Type>> extension) {
return getExtensionCount((ExtensionLite) extension);
}
@Override
public final <Type> boolean hasExtension(GeneratedMessage.GeneratedExtension<MessageType, Type> generatedExtension) {
return hasExtension((ExtensionLite) generatedExtension);
}
@Override
public final <Type> int getExtensionCount(GeneratedMessage.GeneratedExtension<MessageType, List<Type>> generatedExtension) {
return getExtensionCount((ExtensionLite) generatedExtension);
}
@Override
public final <Type> Type getExtension(ExtensionLite<MessageType, List<Type>> extensionLite, int i) {
Extension<MessageType, ?> checkNotLite = GeneratedMessageV3.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
return (Type) checkNotLite.singularFromReflectionType(this.extensions.getRepeatedField(checkNotLite.getDescriptor(), i));
}
@Override
public final <Type> Type getExtension(Extension<MessageType, Type> extension) {
return (Type) getExtension((ExtensionLite) extension);
}
@Override
public final <Type> Type getExtension(GeneratedMessage.GeneratedExtension<MessageType, Type> generatedExtension) {
return (Type) getExtension((ExtensionLite) generatedExtension);
}
@Override
public final <Type> Type getExtension(Extension<MessageType, List<Type>> extension, int i) {
return (Type) getExtension((ExtensionLite) extension, i);
}
@Override
public final <Type> Type getExtension(GeneratedMessage.GeneratedExtension<MessageType, List<Type>> generatedExtension, int i) {
return (Type) getExtension((ExtensionLite) generatedExtension, i);
}
}
public static final class FieldAccessorTable {
private String[] camelCaseNames;
private final Descriptors.Descriptor descriptor;
private final FieldAccessor[] fields;
private volatile boolean initialized;
private final OneofAccessor[] oneofs;
public interface FieldAccessor {
void addRepeated(Builder builder, Object obj);
void clear(Builder builder);
Object get(Builder builder);
Object get(GeneratedMessageV3 generatedMessageV3);
Message.Builder getBuilder(Builder builder);
Object getRaw(Builder builder);
Object getRaw(GeneratedMessageV3 generatedMessageV3);
Object getRepeated(Builder builder, int i);
Object getRepeated(GeneratedMessageV3 generatedMessageV3, int i);
Message.Builder getRepeatedBuilder(Builder builder, int i);
int getRepeatedCount(Builder builder);
int getRepeatedCount(GeneratedMessageV3 generatedMessageV3);
Object getRepeatedRaw(Builder builder, int i);
Object getRepeatedRaw(GeneratedMessageV3 generatedMessageV3, int i);
boolean has(Builder builder);
boolean has(GeneratedMessageV3 generatedMessageV3);
Message.Builder newBuilder();
void set(Builder builder, Object obj);
void setRepeated(Builder builder, int i, Object obj);
}
public static class MapFieldAccessor implements FieldAccessor {
private final Descriptors.FieldDescriptor field;
private final Message mapEntryMessageDefaultInstance;
public MapFieldAccessor(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2) {
this.field = fieldDescriptor;
this.mapEntryMessageDefaultInstance = getMapField((GeneratedMessageV3) GeneratedMessageV3.invokeOrDie(GeneratedMessageV3.getMethodOrDie(cls, "getDefaultInstance", new Class[0]), null, new Object[0])).getMapEntryMessageDefaultInstance();
}
private Message coerceType(Message message) {
if (message == null) {
return null;
}
return this.mapEntryMessageDefaultInstance.getClass().isInstance(message) ? message : this.mapEntryMessageDefaultInstance.toBuilder().mergeFrom(message).build();
}
private MapField<?, ?> getMapField(GeneratedMessageV3 generatedMessageV3) {
return generatedMessageV3.internalGetMapField(this.field.getNumber());
}
private MapField<?, ?> getMutableMapField(Builder builder) {
return builder.internalGetMutableMapField(this.field.getNumber());
}
@Override
public void addRepeated(Builder builder, Object obj) {
getMutableMapField(builder).getMutableList().add(coerceType((Message) obj));
}
@Override
public void clear(Builder builder) {
getMutableMapField(builder).getMutableList().clear();
}
@Override
public Object get(GeneratedMessageV3 generatedMessageV3) {
ArrayList arrayList = new ArrayList();
for (int i = 0; i < getRepeatedCount(generatedMessageV3); i++) {
arrayList.add(getRepeated(generatedMessageV3, i));
}
return Collections.unmodifiableList(arrayList);
}
@Override
public Message.Builder getBuilder(Builder builder) {
throw new UnsupportedOperationException("Nested builder not supported for map fields.");
}
@Override
public Object getRaw(GeneratedMessageV3 generatedMessageV3) {
return get(generatedMessageV3);
}
@Override
public Object getRepeated(GeneratedMessageV3 generatedMessageV3, int i) {
return getMapField(generatedMessageV3).getList().get(i);
}
@Override
public Message.Builder getRepeatedBuilder(Builder builder, int i) {
throw new UnsupportedOperationException("Nested builder not supported for map fields.");
}
@Override
public int getRepeatedCount(GeneratedMessageV3 generatedMessageV3) {
return getMapField(generatedMessageV3).getList().size();
}
@Override
public Object getRepeatedRaw(GeneratedMessageV3 generatedMessageV3, int i) {
return getRepeated(generatedMessageV3, i);
}
@Override
public boolean has(GeneratedMessageV3 generatedMessageV3) {
throw new UnsupportedOperationException("hasField() is not supported for repeated fields.");
}
@Override
public Message.Builder newBuilder() {
return this.mapEntryMessageDefaultInstance.newBuilderForType();
}
@Override
public void set(Builder builder, Object obj) {
clear(builder);
Iterator it = ((List) obj).iterator();
while (it.hasNext()) {
addRepeated(builder, it.next());
}
}
@Override
public void setRepeated(Builder builder, int i, Object obj) {
getMutableMapField(builder).getMutableList().set(i, coerceType((Message) obj));
}
private MapField<?, ?> getMapField(Builder builder) {
return builder.internalGetMapField(this.field.getNumber());
}
@Override
public Object getRaw(Builder builder) {
return get(builder);
}
@Override
public Object getRepeated(Builder builder, int i) {
return getMapField(builder).getList().get(i);
}
@Override
public int getRepeatedCount(Builder builder) {
return getMapField(builder).getList().size();
}
@Override
public Object getRepeatedRaw(Builder builder, int i) {
return getRepeated(builder, i);
}
@Override
public boolean has(Builder builder) {
throw new UnsupportedOperationException("hasField() is not supported for repeated fields.");
}
@Override
public Object get(Builder builder) {
ArrayList arrayList = new ArrayList();
for (int i = 0; i < getRepeatedCount(builder); i++) {
arrayList.add(getRepeated(builder, i));
}
return Collections.unmodifiableList(arrayList);
}
}
public static class RepeatedFieldAccessor implements FieldAccessor {
protected final MethodInvoker invoker;
protected final Class type;
public interface MethodInvoker {
void addRepeated(Builder<?> builder, Object obj);
void clear(Builder<?> builder);
Object get(Builder<?> builder);
Object get(GeneratedMessageV3 generatedMessageV3);
Object getRepeated(Builder<?> builder, int i);
Object getRepeated(GeneratedMessageV3 generatedMessageV3, int i);
int getRepeatedCount(Builder<?> builder);
int getRepeatedCount(GeneratedMessageV3 generatedMessageV3);
void setRepeated(Builder<?> builder, int i, Object obj);
}
public static final class ReflectionInvoker implements MethodInvoker {
protected final java.lang.reflect.Method addRepeatedMethod;
protected final java.lang.reflect.Method clearMethod;
protected final java.lang.reflect.Method getCountMethod;
protected final java.lang.reflect.Method getCountMethodBuilder;
protected final java.lang.reflect.Method getMethod;
protected final java.lang.reflect.Method getMethodBuilder;
protected final java.lang.reflect.Method getRepeatedMethod;
protected final java.lang.reflect.Method getRepeatedMethodBuilder;
protected final java.lang.reflect.Method setRepeatedMethod;
public ReflectionInvoker(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2) {
this.getMethod = GeneratedMessageV3.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "List"), new Class[0]);
this.getMethodBuilder = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "List"), new Class[0]);
String C = d0.C("get", str);
Class cls3 = Integer.TYPE;
java.lang.reflect.Method methodOrDie = GeneratedMessageV3.getMethodOrDie(cls, C, cls3);
this.getRepeatedMethod = methodOrDie;
this.getRepeatedMethodBuilder = GeneratedMessageV3.getMethodOrDie(cls2, d0.C("get", str), cls3);
Class<?> returnType = methodOrDie.getReturnType();
this.setRepeatedMethod = GeneratedMessageV3.getMethodOrDie(cls2, d0.C("set", str), cls3, returnType);
this.addRepeatedMethod = GeneratedMessageV3.getMethodOrDie(cls2, d0.C("add", str), returnType);
this.getCountMethod = GeneratedMessageV3.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Count"), new Class[0]);
this.getCountMethodBuilder = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Count"), new Class[0]);
this.clearMethod = GeneratedMessageV3.getMethodOrDie(cls2, d0.C("clear", str), new Class[0]);
}
@Override
public void addRepeated(Builder<?> builder, Object obj) {
GeneratedMessageV3.invokeOrDie(this.addRepeatedMethod, builder, obj);
}
@Override
public void clear(Builder<?> builder) {
GeneratedMessageV3.invokeOrDie(this.clearMethod, builder, new Object[0]);
}
@Override
public Object get(GeneratedMessageV3 generatedMessageV3) {
return GeneratedMessageV3.invokeOrDie(this.getMethod, generatedMessageV3, new Object[0]);
}
@Override
public Object getRepeated(GeneratedMessageV3 generatedMessageV3, int i) {
return GeneratedMessageV3.invokeOrDie(this.getRepeatedMethod, generatedMessageV3, Integer.valueOf(i));
}
@Override
public int getRepeatedCount(GeneratedMessageV3 generatedMessageV3) {
return ((Integer) GeneratedMessageV3.invokeOrDie(this.getCountMethod, generatedMessageV3, new Object[0])).intValue();
}
@Override
public void setRepeated(Builder<?> builder, int i, Object obj) {
GeneratedMessageV3.invokeOrDie(this.setRepeatedMethod, builder, Integer.valueOf(i), obj);
}
@Override
public Object get(Builder<?> builder) {
return GeneratedMessageV3.invokeOrDie(this.getMethodBuilder, builder, new Object[0]);
}
@Override
public Object getRepeated(Builder<?> builder, int i) {
return GeneratedMessageV3.invokeOrDie(this.getRepeatedMethodBuilder, builder, Integer.valueOf(i));
}
@Override
public int getRepeatedCount(Builder<?> builder) {
return ((Integer) GeneratedMessageV3.invokeOrDie(this.getCountMethodBuilder, builder, new Object[0])).intValue();
}
}
public RepeatedFieldAccessor(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2) {
ReflectionInvoker reflectionInvoker = new ReflectionInvoker(fieldDescriptor, str, cls, cls2);
this.type = reflectionInvoker.getRepeatedMethod.getReturnType();
this.invoker = getMethodInvoker(reflectionInvoker);
}
public static MethodInvoker getMethodInvoker(ReflectionInvoker reflectionInvoker) {
return reflectionInvoker;
}
@Override
public void addRepeated(Builder builder, Object obj) {
this.invoker.addRepeated(builder, obj);
}
@Override
public void clear(Builder builder) {
this.invoker.clear(builder);
}
@Override
public Object get(GeneratedMessageV3 generatedMessageV3) {
return this.invoker.get(generatedMessageV3);
}
@Override
public Message.Builder getBuilder(Builder builder) {
throw new UnsupportedOperationException("getFieldBuilder() called on a non-Message type.");
}
@Override
public Object getRaw(GeneratedMessageV3 generatedMessageV3) {
return get(generatedMessageV3);
}
@Override
public Object getRepeated(GeneratedMessageV3 generatedMessageV3, int i) {
return this.invoker.getRepeated(generatedMessageV3, i);
}
@Override
public Message.Builder getRepeatedBuilder(Builder builder, int i) {
throw new UnsupportedOperationException("getRepeatedFieldBuilder() called on a non-Message type.");
}
@Override
public int getRepeatedCount(GeneratedMessageV3 generatedMessageV3) {
return this.invoker.getRepeatedCount(generatedMessageV3);
}
@Override
public Object getRepeatedRaw(GeneratedMessageV3 generatedMessageV3, int i) {
return getRepeated(generatedMessageV3, i);
}
@Override
public boolean has(GeneratedMessageV3 generatedMessageV3) {
throw new UnsupportedOperationException("hasField() called on a repeated field.");
}
@Override
public Message.Builder newBuilder() {
throw new UnsupportedOperationException("newBuilderForField() called on a non-Message type.");
}
@Override
public void set(Builder builder, Object obj) {
clear(builder);
Iterator it = ((List) obj).iterator();
while (it.hasNext()) {
addRepeated(builder, it.next());
}
}
@Override
public void setRepeated(Builder builder, int i, Object obj) {
this.invoker.setRepeated(builder, i, obj);
}
@Override
public Object get(Builder builder) {
return this.invoker.get((Builder<?>) builder);
}
@Override
public Object getRaw(Builder builder) {
return get(builder);
}
@Override
public Object getRepeated(Builder builder, int i) {
return this.invoker.getRepeated((Builder<?>) builder, i);
}
@Override
public int getRepeatedCount(Builder builder) {
return this.invoker.getRepeatedCount((Builder<?>) builder);
}
@Override
public Object getRepeatedRaw(Builder builder, int i) {
return getRepeated(builder, i);
}
@Override
public boolean has(Builder builder) {
throw new UnsupportedOperationException("hasField() called on a repeated field.");
}
}
public static final class RepeatedMessageFieldAccessor extends RepeatedFieldAccessor {
private final java.lang.reflect.Method getBuilderMethodBuilder;
private final java.lang.reflect.Method newBuilderMethod;
public RepeatedMessageFieldAccessor(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2) {
super(fieldDescriptor, str, cls, cls2);
this.newBuilderMethod = GeneratedMessageV3.getMethodOrDie(this.type, "newBuilder", new Class[0]);
this.getBuilderMethodBuilder = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Builder"), Integer.TYPE);
}
private Object coerceType(Object obj) {
return this.type.isInstance(obj) ? obj : ((Message.Builder) GeneratedMessageV3.invokeOrDie(this.newBuilderMethod, null, new Object[0])).mergeFrom((Message) obj).build();
}
@Override
public void addRepeated(Builder builder, Object obj) {
super.addRepeated(builder, coerceType(obj));
}
@Override
public Message.Builder getRepeatedBuilder(Builder builder, int i) {
return (Message.Builder) GeneratedMessageV3.invokeOrDie(this.getBuilderMethodBuilder, builder, Integer.valueOf(i));
}
@Override
public Message.Builder newBuilder() {
return (Message.Builder) GeneratedMessageV3.invokeOrDie(this.newBuilderMethod, null, new Object[0]);
}
@Override
public void setRepeated(Builder builder, int i, Object obj) {
super.setRepeated(builder, i, coerceType(obj));
}
}
public static class SingularFieldAccessor implements FieldAccessor {
protected final Descriptors.FieldDescriptor field;
protected final boolean hasHasMethod;
protected final MethodInvoker invoker;
protected final boolean isOneofField;
protected final Class<?> type;
public interface MethodInvoker {
void clear(Builder<?> builder);
Object get(Builder<?> builder);
Object get(GeneratedMessageV3 generatedMessageV3);
int getOneofFieldNumber(Builder<?> builder);
int getOneofFieldNumber(GeneratedMessageV3 generatedMessageV3);
boolean has(Builder<?> builder);
boolean has(GeneratedMessageV3 generatedMessageV3);
void set(Builder<?> builder, Object obj);
}
public static final class ReflectionInvoker implements MethodInvoker {
protected final java.lang.reflect.Method caseMethod;
protected final java.lang.reflect.Method caseMethodBuilder;
protected final java.lang.reflect.Method clearMethod;
protected final java.lang.reflect.Method getMethod;
protected final java.lang.reflect.Method getMethodBuilder;
protected final java.lang.reflect.Method hasMethod;
protected final java.lang.reflect.Method hasMethodBuilder;
protected final java.lang.reflect.Method setMethod;
public ReflectionInvoker(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2, String str2, boolean z, boolean z2) {
java.lang.reflect.Method methodOrDie = GeneratedMessageV3.getMethodOrDie(cls, d0.C("get", str), new Class[0]);
this.getMethod = methodOrDie;
this.getMethodBuilder = GeneratedMessageV3.getMethodOrDie(cls2, d0.C("get", str), new Class[0]);
this.setMethod = GeneratedMessageV3.getMethodOrDie(cls2, d0.C("set", str), methodOrDie.getReturnType());
this.hasMethod = z2 ? GeneratedMessageV3.getMethodOrDie(cls, d0.C("has", str), new Class[0]) : null;
this.hasMethodBuilder = z2 ? GeneratedMessageV3.getMethodOrDie(cls2, d0.C("has", str), new Class[0]) : null;
this.clearMethod = GeneratedMessageV3.getMethodOrDie(cls2, d0.C("clear", str), new Class[0]);
this.caseMethod = z ? GeneratedMessageV3.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str2, "Case"), new Class[0]) : null;
this.caseMethodBuilder = z ? GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str2, "Case"), new Class[0]) : null;
}
@Override
public void clear(Builder<?> builder) {
GeneratedMessageV3.invokeOrDie(this.clearMethod, builder, new Object[0]);
}
@Override
public Object get(GeneratedMessageV3 generatedMessageV3) {
return GeneratedMessageV3.invokeOrDie(this.getMethod, generatedMessageV3, new Object[0]);
}
@Override
public int getOneofFieldNumber(GeneratedMessageV3 generatedMessageV3) {
return ((Internal.EnumLite) GeneratedMessageV3.invokeOrDie(this.caseMethod, generatedMessageV3, new Object[0])).getNumber();
}
@Override
public boolean has(GeneratedMessageV3 generatedMessageV3) {
return ((Boolean) GeneratedMessageV3.invokeOrDie(this.hasMethod, generatedMessageV3, new Object[0])).booleanValue();
}
@Override
public void set(Builder<?> builder, Object obj) {
GeneratedMessageV3.invokeOrDie(this.setMethod, builder, obj);
}
@Override
public Object get(Builder<?> builder) {
return GeneratedMessageV3.invokeOrDie(this.getMethodBuilder, builder, new Object[0]);
}
@Override
public int getOneofFieldNumber(Builder<?> builder) {
return ((Internal.EnumLite) GeneratedMessageV3.invokeOrDie(this.caseMethodBuilder, builder, new Object[0])).getNumber();
}
@Override
public boolean has(Builder<?> builder) {
return ((Boolean) GeneratedMessageV3.invokeOrDie(this.hasMethodBuilder, builder, new Object[0])).booleanValue();
}
}
public SingularFieldAccessor(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2, String str2) {
boolean z = (fieldDescriptor.getContainingOneof() == null || fieldDescriptor.getContainingOneof().isSynthetic()) ? false : true;
this.isOneofField = z;
boolean z2 = fieldDescriptor.getFile().getSyntax() == Descriptors.FileDescriptor.Syntax.PROTO2 || fieldDescriptor.hasOptionalKeyword() || (!z && fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE);
this.hasHasMethod = z2;
ReflectionInvoker reflectionInvoker = new ReflectionInvoker(fieldDescriptor, str, cls, cls2, str2, z, z2);
this.field = fieldDescriptor;
this.type = reflectionInvoker.getMethod.getReturnType();
this.invoker = getMethodInvoker(reflectionInvoker);
}
public static MethodInvoker getMethodInvoker(ReflectionInvoker reflectionInvoker) {
return reflectionInvoker;
}
@Override
public void addRepeated(Builder builder, Object obj) {
throw new UnsupportedOperationException("addRepeatedField() called on a singular field.");
}
@Override
public void clear(Builder builder) {
this.invoker.clear(builder);
}
@Override
public Object get(GeneratedMessageV3 generatedMessageV3) {
return this.invoker.get(generatedMessageV3);
}
@Override
public Message.Builder getBuilder(Builder builder) {
throw new UnsupportedOperationException("getFieldBuilder() called on a non-Message type.");
}
@Override
public Object getRaw(GeneratedMessageV3 generatedMessageV3) {
return get(generatedMessageV3);
}
@Override
public Object getRepeated(GeneratedMessageV3 generatedMessageV3, int i) {
throw new UnsupportedOperationException("getRepeatedField() called on a singular field.");
}
@Override
public Message.Builder getRepeatedBuilder(Builder builder, int i) {
throw new UnsupportedOperationException("getRepeatedFieldBuilder() called on a non-Message type.");
}
@Override
public int getRepeatedCount(GeneratedMessageV3 generatedMessageV3) {
throw new UnsupportedOperationException("getRepeatedFieldSize() called on a singular field.");
}
@Override
public Object getRepeatedRaw(GeneratedMessageV3 generatedMessageV3, int i) {
throw new UnsupportedOperationException("getRepeatedFieldRaw() called on a singular field.");
}
@Override
public boolean has(GeneratedMessageV3 generatedMessageV3) {
return !this.hasHasMethod ? this.isOneofField ? this.invoker.getOneofFieldNumber(generatedMessageV3) == this.field.getNumber() : !get(generatedMessageV3).equals(this.field.getDefaultValue()) : this.invoker.has(generatedMessageV3);
}
@Override
public Message.Builder newBuilder() {
throw new UnsupportedOperationException("newBuilderForField() called on a non-Message type.");
}
@Override
public void set(Builder builder, Object obj) {
this.invoker.set(builder, obj);
}
@Override
public void setRepeated(Builder builder, int i, Object obj) {
throw new UnsupportedOperationException("setRepeatedField() called on a singular field.");
}
@Override
public Object get(Builder builder) {
return this.invoker.get((Builder<?>) builder);
}
@Override
public Object getRaw(Builder builder) {
return get(builder);
}
@Override
public Object getRepeated(Builder builder, int i) {
throw new UnsupportedOperationException("getRepeatedField() called on a singular field.");
}
@Override
public int getRepeatedCount(Builder builder) {
throw new UnsupportedOperationException("getRepeatedFieldSize() called on a singular field.");
}
@Override
public Object getRepeatedRaw(Builder builder, int i) {
throw new UnsupportedOperationException("getRepeatedFieldRaw() called on a singular field.");
}
@Override
public boolean has(Builder builder) {
if (!this.hasHasMethod) {
if (this.isOneofField) {
return this.invoker.getOneofFieldNumber((Builder<?>) builder) == this.field.getNumber();
}
return !get(builder).equals(this.field.getDefaultValue());
}
return this.invoker.has((Builder<?>) builder);
}
}
public static final class SingularMessageFieldAccessor extends SingularFieldAccessor {
private final java.lang.reflect.Method getBuilderMethodBuilder;
private final java.lang.reflect.Method newBuilderMethod;
public SingularMessageFieldAccessor(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2, String str2) {
super(fieldDescriptor, str, cls, cls2, str2);
this.newBuilderMethod = GeneratedMessageV3.getMethodOrDie(this.type, "newBuilder", new Class[0]);
this.getBuilderMethodBuilder = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Builder"), new Class[0]);
}
private Object coerceType(Object obj) {
return this.type.isInstance(obj) ? obj : ((Message.Builder) GeneratedMessageV3.invokeOrDie(this.newBuilderMethod, null, new Object[0])).mergeFrom((Message) obj).buildPartial();
}
@Override
public Message.Builder getBuilder(Builder builder) {
return (Message.Builder) GeneratedMessageV3.invokeOrDie(this.getBuilderMethodBuilder, builder, new Object[0]);
}
@Override
public Message.Builder newBuilder() {
return (Message.Builder) GeneratedMessageV3.invokeOrDie(this.newBuilderMethod, null, new Object[0]);
}
@Override
public void set(Builder builder, Object obj) {
super.set(builder, coerceType(obj));
}
}
public static final class SingularStringFieldAccessor extends SingularFieldAccessor {
private final java.lang.reflect.Method getBytesMethod;
private final java.lang.reflect.Method getBytesMethodBuilder;
private final java.lang.reflect.Method setBytesMethodBuilder;
public SingularStringFieldAccessor(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2, String str2) {
super(fieldDescriptor, str, cls, cls2, str2);
this.getBytesMethod = GeneratedMessageV3.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Bytes"), new Class[0]);
this.getBytesMethodBuilder = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Bytes"), new Class[0]);
this.setBytesMethodBuilder = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("set", str, "Bytes"), ByteString.class);
}
@Override
public Object getRaw(GeneratedMessageV3 generatedMessageV3) {
return GeneratedMessageV3.invokeOrDie(this.getBytesMethod, generatedMessageV3, new Object[0]);
}
@Override
public void set(Builder builder, Object obj) {
if (obj instanceof ByteString) {
GeneratedMessageV3.invokeOrDie(this.setBytesMethodBuilder, builder, obj);
} else {
super.set(builder, obj);
}
}
@Override
public Object getRaw(Builder builder) {
return GeneratedMessageV3.invokeOrDie(this.getBytesMethodBuilder, builder, new Object[0]);
}
}
public FieldAccessorTable(Descriptors.Descriptor descriptor, String[] strArr, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2) {
this(descriptor, strArr);
ensureFieldAccessorsInitialized(cls, cls2);
}
public FieldAccessor getField(Descriptors.FieldDescriptor fieldDescriptor) {
if (fieldDescriptor.getContainingType() != this.descriptor) {
throw new IllegalArgumentException("FieldDescriptor does not match message type.");
}
if (fieldDescriptor.isExtension()) {
throw new IllegalArgumentException("This type does not have extensions.");
}
return this.fields[fieldDescriptor.getIndex()];
}
public OneofAccessor getOneof(Descriptors.OneofDescriptor oneofDescriptor) {
if (oneofDescriptor.getContainingType() == this.descriptor) {
return this.oneofs[oneofDescriptor.getIndex()];
}
throw new IllegalArgumentException("OneofDescriptor does not match message type.");
}
public FieldAccessorTable ensureFieldAccessorsInitialized(Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2) {
if (this.initialized) {
return this;
}
synchronized (this) {
try {
if (this.initialized) {
return this;
}
int length = this.fields.length;
int i = 0;
while (true) {
if (i >= length) {
break;
}
Descriptors.FieldDescriptor fieldDescriptor = this.descriptor.getFields().get(i);
String str = fieldDescriptor.getContainingOneof() != null ? this.camelCaseNames[fieldDescriptor.getContainingOneof().getIndex() + length] : null;
if (fieldDescriptor.isRepeated()) {
if (fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE) {
if (fieldDescriptor.isMapField()) {
this.fields[i] = new MapFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls, cls2);
} else {
this.fields[i] = new RepeatedMessageFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls, cls2);
}
} else if (fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.ENUM) {
this.fields[i] = new RepeatedEnumFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls, cls2);
} else {
this.fields[i] = new RepeatedFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls, cls2);
}
} else if (fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE) {
this.fields[i] = new SingularMessageFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls, cls2, str);
} else if (fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.ENUM) {
this.fields[i] = new SingularEnumFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls, cls2, str);
} else if (fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.STRING) {
this.fields[i] = new SingularStringFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls, cls2, str);
} else {
this.fields[i] = new SingularFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls, cls2, str);
}
i++;
}
int length2 = this.oneofs.length;
for (int i2 = 0; i2 < length2; i2++) {
this.oneofs[i2] = new OneofAccessor(this.descriptor, i2, this.camelCaseNames[i2 + length], cls, cls2);
}
this.initialized = true;
this.camelCaseNames = null;
return this;
} catch (Throwable th) {
throw th;
}
}
}
public static class OneofAccessor {
private final java.lang.reflect.Method caseMethod;
private final java.lang.reflect.Method caseMethodBuilder;
private final java.lang.reflect.Method clearMethod;
private final Descriptors.Descriptor descriptor;
private final Descriptors.FieldDescriptor fieldDescriptor;
public OneofAccessor(Descriptors.Descriptor descriptor, int i, String str, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2) {
this.descriptor = descriptor;
Descriptors.OneofDescriptor oneofDescriptor = descriptor.getOneofs().get(i);
if (oneofDescriptor.isSynthetic()) {
this.caseMethod = null;
this.caseMethodBuilder = null;
this.fieldDescriptor = oneofDescriptor.getFields().get(0);
} else {
this.caseMethod = GeneratedMessageV3.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Case"), new Class[0]);
this.caseMethodBuilder = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Case"), new Class[0]);
this.fieldDescriptor = null;
}
this.clearMethod = GeneratedMessageV3.getMethodOrDie(cls2, d0.C("clear", str), new Class[0]);
}
public void clear(Builder builder) {
GeneratedMessageV3.invokeOrDie(this.clearMethod, builder, new Object[0]);
}
public Descriptors.FieldDescriptor get(GeneratedMessageV3 generatedMessageV3) {
Descriptors.FieldDescriptor fieldDescriptor = this.fieldDescriptor;
if (fieldDescriptor != null) {
if (generatedMessageV3.hasField(fieldDescriptor)) {
return this.fieldDescriptor;
}
return null;
}
int number = ((Internal.EnumLite) GeneratedMessageV3.invokeOrDie(this.caseMethod, generatedMessageV3, new Object[0])).getNumber();
if (number > 0) {
return this.descriptor.findFieldByNumber(number);
}
return null;
}
public boolean has(GeneratedMessageV3 generatedMessageV3) {
Descriptors.FieldDescriptor fieldDescriptor = this.fieldDescriptor;
return fieldDescriptor != null ? generatedMessageV3.hasField(fieldDescriptor) : ((Internal.EnumLite) GeneratedMessageV3.invokeOrDie(this.caseMethod, generatedMessageV3, new Object[0])).getNumber() != 0;
}
public boolean has(Builder builder) {
Descriptors.FieldDescriptor fieldDescriptor = this.fieldDescriptor;
if (fieldDescriptor != null) {
return builder.hasField(fieldDescriptor);
}
return ((Internal.EnumLite) GeneratedMessageV3.invokeOrDie(this.caseMethodBuilder, builder, new Object[0])).getNumber() != 0;
}
public Descriptors.FieldDescriptor get(Builder builder) {
Descriptors.FieldDescriptor fieldDescriptor = this.fieldDescriptor;
if (fieldDescriptor != null) {
if (builder.hasField(fieldDescriptor)) {
return this.fieldDescriptor;
}
return null;
}
int number = ((Internal.EnumLite) GeneratedMessageV3.invokeOrDie(this.caseMethodBuilder, builder, new Object[0])).getNumber();
if (number > 0) {
return this.descriptor.findFieldByNumber(number);
}
return null;
}
}
public FieldAccessorTable(Descriptors.Descriptor descriptor, String[] strArr) {
this.descriptor = descriptor;
this.camelCaseNames = strArr;
this.fields = new FieldAccessor[descriptor.getFields().size()];
this.oneofs = new OneofAccessor[descriptor.getOneofs().size()];
this.initialized = false;
}
public static final class RepeatedEnumFieldAccessor extends RepeatedFieldAccessor {
private java.lang.reflect.Method addRepeatedValueMethod;
private Descriptors.EnumDescriptor enumDescriptor;
private java.lang.reflect.Method getRepeatedValueMethod;
private java.lang.reflect.Method getRepeatedValueMethodBuilder;
private final java.lang.reflect.Method getValueDescriptorMethod;
private java.lang.reflect.Method setRepeatedValueMethod;
private boolean supportUnknownEnumValue;
private final java.lang.reflect.Method valueOfMethod;
public RepeatedEnumFieldAccessor(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2) {
super(fieldDescriptor, str, cls, cls2);
this.enumDescriptor = fieldDescriptor.getEnumType();
this.valueOfMethod = GeneratedMessageV3.getMethodOrDie(this.type, "valueOf", Descriptors.EnumValueDescriptor.class);
this.getValueDescriptorMethod = GeneratedMessageV3.getMethodOrDie(this.type, "getValueDescriptor", new Class[0]);
boolean supportsUnknownEnumValue = fieldDescriptor.getFile().supportsUnknownEnumValue();
this.supportUnknownEnumValue = supportsUnknownEnumValue;
if (supportsUnknownEnumValue) {
String m = com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Value");
Class cls3 = Integer.TYPE;
this.getRepeatedValueMethod = GeneratedMessageV3.getMethodOrDie(cls, m, cls3);
this.getRepeatedValueMethodBuilder = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Value"), cls3);
this.setRepeatedValueMethod = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("set", str, "Value"), cls3, cls3);
this.addRepeatedValueMethod = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("add", str, "Value"), cls3);
}
}
@Override
public void addRepeated(Builder builder, Object obj) {
if (this.supportUnknownEnumValue) {
GeneratedMessageV3.invokeOrDie(this.addRepeatedValueMethod, builder, Integer.valueOf(((Descriptors.EnumValueDescriptor) obj).getNumber()));
} else {
super.addRepeated(builder, GeneratedMessageV3.invokeOrDie(this.valueOfMethod, null, obj));
}
}
@Override
public Object get(GeneratedMessageV3 generatedMessageV3) {
ArrayList arrayList = new ArrayList();
int repeatedCount = getRepeatedCount(generatedMessageV3);
for (int i = 0; i < repeatedCount; i++) {
arrayList.add(getRepeated(generatedMessageV3, i));
}
return Collections.unmodifiableList(arrayList);
}
@Override
public Object getRepeated(GeneratedMessageV3 generatedMessageV3, int i) {
if (!this.supportUnknownEnumValue) {
return GeneratedMessageV3.invokeOrDie(this.getValueDescriptorMethod, super.getRepeated(generatedMessageV3, i), new Object[0]);
}
return this.enumDescriptor.findValueByNumberCreatingIfUnknown(((Integer) GeneratedMessageV3.invokeOrDie(this.getRepeatedValueMethod, generatedMessageV3, Integer.valueOf(i))).intValue());
}
@Override
public void setRepeated(Builder builder, int i, Object obj) {
if (this.supportUnknownEnumValue) {
GeneratedMessageV3.invokeOrDie(this.setRepeatedValueMethod, builder, Integer.valueOf(i), Integer.valueOf(((Descriptors.EnumValueDescriptor) obj).getNumber()));
} else {
super.setRepeated(builder, i, GeneratedMessageV3.invokeOrDie(this.valueOfMethod, null, obj));
}
}
@Override
public Object get(Builder builder) {
ArrayList arrayList = new ArrayList();
int repeatedCount = getRepeatedCount(builder);
for (int i = 0; i < repeatedCount; i++) {
arrayList.add(getRepeated(builder, i));
}
return Collections.unmodifiableList(arrayList);
}
@Override
public Object getRepeated(Builder builder, int i) {
if (this.supportUnknownEnumValue) {
return this.enumDescriptor.findValueByNumberCreatingIfUnknown(((Integer) GeneratedMessageV3.invokeOrDie(this.getRepeatedValueMethodBuilder, builder, Integer.valueOf(i))).intValue());
}
return GeneratedMessageV3.invokeOrDie(this.getValueDescriptorMethod, super.getRepeated(builder, i), new Object[0]);
}
}
public static final class SingularEnumFieldAccessor extends SingularFieldAccessor {
private Descriptors.EnumDescriptor enumDescriptor;
private java.lang.reflect.Method getValueDescriptorMethod;
private java.lang.reflect.Method getValueMethod;
private java.lang.reflect.Method getValueMethodBuilder;
private java.lang.reflect.Method setValueMethod;
private boolean supportUnknownEnumValue;
private java.lang.reflect.Method valueOfMethod;
public SingularEnumFieldAccessor(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessageV3> cls, Class<? extends Builder> cls2, String str2) {
super(fieldDescriptor, str, cls, cls2, str2);
this.enumDescriptor = fieldDescriptor.getEnumType();
this.valueOfMethod = GeneratedMessageV3.getMethodOrDie(this.type, "valueOf", Descriptors.EnumValueDescriptor.class);
this.getValueDescriptorMethod = GeneratedMessageV3.getMethodOrDie(this.type, "getValueDescriptor", new Class[0]);
boolean supportsUnknownEnumValue = fieldDescriptor.getFile().supportsUnknownEnumValue();
this.supportUnknownEnumValue = supportsUnknownEnumValue;
if (supportsUnknownEnumValue) {
this.getValueMethod = GeneratedMessageV3.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Value"), new Class[0]);
this.getValueMethodBuilder = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Value"), new Class[0]);
this.setValueMethod = GeneratedMessageV3.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("set", str, "Value"), Integer.TYPE);
}
}
@Override
public Object get(GeneratedMessageV3 generatedMessageV3) {
if (!this.supportUnknownEnumValue) {
return GeneratedMessageV3.invokeOrDie(this.getValueDescriptorMethod, super.get(generatedMessageV3), new Object[0]);
}
return this.enumDescriptor.findValueByNumberCreatingIfUnknown(((Integer) GeneratedMessageV3.invokeOrDie(this.getValueMethod, generatedMessageV3, new Object[0])).intValue());
}
@Override
public void set(Builder builder, Object obj) {
if (this.supportUnknownEnumValue) {
GeneratedMessageV3.invokeOrDie(this.setValueMethod, builder, Integer.valueOf(((Descriptors.EnumValueDescriptor) obj).getNumber()));
} else {
super.set(builder, GeneratedMessageV3.invokeOrDie(this.valueOfMethod, null, obj));
}
}
@Override
public Object get(Builder builder) {
if (this.supportUnknownEnumValue) {
return this.enumDescriptor.findValueByNumberCreatingIfUnknown(((Integer) GeneratedMessageV3.invokeOrDie(this.getValueMethodBuilder, builder, new Object[0])).intValue());
}
return GeneratedMessageV3.invokeOrDie(this.getValueDescriptorMethod, super.get(builder), new Object[0]);
}
}
}
public GeneratedMessageV3(Builder<?> builder) {
this.unknownFields = builder.getUnknownFields();
}
public static Internal.LongList mutableCopy(Internal.LongList longList) {
int size = longList.size();
return longList.mutableCopyWithCapacity2(size == 0 ? 10 : size * 2);
}
public static <M extends Message> M parseDelimitedWithIOException(Parser<M> parser, InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
try {
return parser.parseDelimitedFrom(inputStream, extensionRegistryLite);
} catch (InvalidProtocolBufferException e) {
throw e.unwrapIOException();
}
}
public static <M extends Message> M parseWithIOException(Parser<M> parser, InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
try {
return parser.parseFrom(inputStream, extensionRegistryLite);
} catch (InvalidProtocolBufferException e) {
throw e.unwrapIOException();
}
}
public static Internal.FloatList mutableCopy(Internal.FloatList floatList) {
int size = floatList.size();
return floatList.mutableCopyWithCapacity2(size == 0 ? 10 : size * 2);
}
public static <M extends Message> M parseWithIOException(Parser<M> parser, CodedInputStream codedInputStream) throws IOException {
try {
return parser.parseFrom(codedInputStream);
} catch (InvalidProtocolBufferException e) {
throw e.unwrapIOException();
}
}
public static Internal.DoubleList mutableCopy(Internal.DoubleList doubleList) {
int size = doubleList.size();
return doubleList.mutableCopyWithCapacity2(size == 0 ? 10 : size * 2);
}
public static <M extends Message> M parseWithIOException(Parser<M> parser, CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
try {
return parser.parseFrom(codedInputStream, extensionRegistryLite);
} catch (InvalidProtocolBufferException e) {
throw e.unwrapIOException();
}
}
public static Internal.BooleanList mutableCopy(Internal.BooleanList booleanList) {
int size = booleanList.size();
return booleanList.mutableCopyWithCapacity2(size == 0 ? 10 : size * 2);
}
}