正在查看： CallApp v2.226 应用的 GeneratedMessage.java JAVA 源代码文件
本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。
页面标题
页面副标题
CallApp v2.226 - GeneratedMessage.java 源代码
package com.explorestack.protobuf;
import a1.d0;
import com.explorestack.protobuf.AbstractMessage;
import com.explorestack.protobuf.Descriptors;
import com.explorestack.protobuf.Extension;
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.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public abstract class GeneratedMessage extends AbstractMessage implements Serializable {
protected static boolean alwaysUseFieldBuilders = false;
private static final long serialVersionUID = 1;
protected UnknownFieldSet unknownFields;
public static class AnonymousClass5 {
static final int[] $SwitchMap$com$google$protobuf$Descriptors$FieldDescriptor$JavaType;
static {
int[] iArr = new int[Descriptors.FieldDescriptor.JavaType.values().length];
$SwitchMap$com$google$protobuf$Descriptors$FieldDescriptor$JavaType = iArr;
try {
iArr[Descriptors.FieldDescriptor.JavaType.MESSAGE.ordinal()] = 1;
} catch (NoSuchFieldError unused) {
}
try {
$SwitchMap$com$google$protobuf$Descriptors$FieldDescriptor$JavaType[Descriptors.FieldDescriptor.JavaType.ENUM.ordinal()] = 2;
} catch (NoSuchFieldError unused2) {
}
}
}
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;
}
@Override
public void dispose() {
this.builderParent = null;
}
@Override
public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
return Collections.unmodifiableMap(getAllFieldsMutable());
}
@Override
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 boolean parseUnknownField(CodedInputStream codedInputStream, UnknownFieldSet.Builder builder, ExtensionRegistryLite extensionRegistryLite, int i) throws IOException {
return builder.mergeFieldFrom(i, codedInputStream);
}
public Builder(BuilderParent builderParent) {
this.unknownFields = UnknownFieldSet.getDefaultInstance();
this.builderParent = builderParent;
}
@Override
public BuilderType addRepeatedField(Descriptors.FieldDescriptor fieldDescriptor, Object obj) {
internalGetFieldAccessorTable().getField(fieldDescriptor).addRepeated(this, obj);
return this;
}
@Override
public BuilderType clearField(Descriptors.FieldDescriptor fieldDescriptor) {
internalGetFieldAccessorTable().getField(fieldDescriptor).clear(this);
return this;
}
@Override
public BuilderType setField(Descriptors.FieldDescriptor fieldDescriptor, Object obj) {
internalGetFieldAccessorTable().getField(fieldDescriptor).set(this, obj);
return this;
}
@Override
public BuilderType setRepeatedField(Descriptors.FieldDescriptor fieldDescriptor, int i, Object obj) {
internalGetFieldAccessorTable().getField(fieldDescriptor).setRepeated(this, i, obj);
return this;
}
@Override
public BuilderType setUnknownFields(UnknownFieldSet unknownFieldSet) {
this.unknownFields = unknownFieldSet;
onChanged();
return this;
}
@Override
public BuilderType clearOneof(Descriptors.OneofDescriptor oneofDescriptor) {
internalGetFieldAccessorTable().getOneof(oneofDescriptor).clear(this);
return this;
}
@Override
public BuilderType mergeUnknownFields(UnknownFieldSet unknownFieldSet) {
this.unknownFields = UnknownFieldSet.newBuilder(this.unknownFields).mergeFrom(unknownFieldSet).build();
onChanged();
return this;
}
@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 CachedDescriptorRetriever implements ExtensionDescriptorRetriever {
private volatile Descriptors.FieldDescriptor descriptor;
private CachedDescriptorRetriever() {
}
@Override
public Descriptors.FieldDescriptor getDescriptor() {
if (this.descriptor == null) {
synchronized (this) {
try {
if (this.descriptor == null) {
this.descriptor = loadDescriptor();
}
} finally {
}
}
}
return this.descriptor;
}
public abstract Descriptors.FieldDescriptor loadDescriptor();
}
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(GeneratedExtension<MessageType, Type> generatedExtension);
<Type> Type getExtension(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(GeneratedExtension<MessageType, List<Type>> generatedExtension);
<Type> boolean hasExtension(Extension<MessageType, Type> extension);
<Type> boolean hasExtension(ExtensionLite<MessageType, Type> extensionLite);
<Type> boolean hasExtension(GeneratedExtension<MessageType, Type> generatedExtension);
}
public interface ExtensionDescriptorRetriever {
Descriptors.FieldDescriptor getDescriptor();
}
public static class GeneratedExtension<ContainingType extends Message, Type> extends Extension<ContainingType, Type> {
private ExtensionDescriptorRetriever descriptorRetriever;
private final java.lang.reflect.Method enumGetValueDescriptor;
private final java.lang.reflect.Method enumValueOf;
private final Extension.ExtensionType extensionType;
private final Message messageDefaultInstance;
private final Class singularType;
public GeneratedExtension(ExtensionDescriptorRetriever extensionDescriptorRetriever, Class cls, Message message, Extension.ExtensionType extensionType) {
if (Message.class.isAssignableFrom(cls) && !cls.isInstance(message)) {
throw new IllegalArgumentException("Bad messageDefaultInstance for ".concat(cls.getName()));
}
this.descriptorRetriever = extensionDescriptorRetriever;
this.singularType = cls;
this.messageDefaultInstance = message;
if (ProtocolMessageEnum.class.isAssignableFrom(cls)) {
this.enumValueOf = GeneratedMessage.getMethodOrDie(cls, "valueOf", Descriptors.EnumValueDescriptor.class);
this.enumGetValueDescriptor = GeneratedMessage.getMethodOrDie(cls, "getValueDescriptor", new Class[0]);
} else {
this.enumValueOf = null;
this.enumGetValueDescriptor = null;
}
this.extensionType = extensionType;
}
@Override
public Object fromReflectionType(Object obj) {
Descriptors.FieldDescriptor descriptor = getDescriptor();
if (!descriptor.isRepeated()) {
return singularFromReflectionType(obj);
}
if (descriptor.getJavaType() != Descriptors.FieldDescriptor.JavaType.MESSAGE && descriptor.getJavaType() != Descriptors.FieldDescriptor.JavaType.ENUM) {
return obj;
}
ArrayList arrayList = new ArrayList();
Iterator it = ((List) obj).iterator();
while (it.hasNext()) {
arrayList.add(singularFromReflectionType(it.next()));
}
return arrayList;
}
@Override
public Type getDefaultValue() {
return isRepeated() ? (Type) Collections.EMPTY_LIST : getDescriptor().getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE ? (Type) this.messageDefaultInstance : (Type) singularFromReflectionType(getDescriptor().getDefaultValue());
}
@Override
public Descriptors.FieldDescriptor getDescriptor() {
ExtensionDescriptorRetriever extensionDescriptorRetriever = this.descriptorRetriever;
if (extensionDescriptorRetriever != null) {
return extensionDescriptorRetriever.getDescriptor();
}
throw new IllegalStateException("getDescriptor() called before internalInit()");
}
@Override
public Extension.ExtensionType getExtensionType() {
return this.extensionType;
}
@Override
public WireFormat.FieldType getLiteType() {
return getDescriptor().getLiteType();
}
@Override
public int getNumber() {
return getDescriptor().getNumber();
}
public void internalInit(final Descriptors.FieldDescriptor fieldDescriptor) {
if (this.descriptorRetriever != null) {
throw new IllegalStateException("Already initialized.");
}
this.descriptorRetriever = new ExtensionDescriptorRetriever() {
@Override
public Descriptors.FieldDescriptor getDescriptor() {
return fieldDescriptor;
}
};
}
@Override
public boolean isRepeated() {
return getDescriptor().isRepeated();
}
@Override
public Object singularFromReflectionType(Object obj) {
int i = AnonymousClass5.$SwitchMap$com$google$protobuf$Descriptors$FieldDescriptor$JavaType[getDescriptor().getJavaType().ordinal()];
if (i != 1) {
if (i == 2) {
return GeneratedMessage.invokeOrDie(this.enumValueOf, null, (Descriptors.EnumValueDescriptor) obj);
}
} else if (!this.singularType.isInstance(obj)) {
return this.messageDefaultInstance.newBuilderForType().mergeFrom((Message) obj).build();
}
return obj;
}
@Override
public Object singularToReflectionType(Object obj) {
return AnonymousClass5.$SwitchMap$com$google$protobuf$Descriptors$FieldDescriptor$JavaType[getDescriptor().getJavaType().ordinal()] != 2 ? obj : GeneratedMessage.invokeOrDie(this.enumGetValueDescriptor, obj, new Object[0]);
}
@Override
public Object toReflectionType(Object obj) {
Descriptors.FieldDescriptor descriptor = getDescriptor();
if (!descriptor.isRepeated()) {
return singularToReflectionType(obj);
}
if (descriptor.getJavaType() != Descriptors.FieldDescriptor.JavaType.ENUM) {
return obj;
}
ArrayList arrayList = new ArrayList();
Iterator it = ((List) obj).iterator();
while (it.hasNext()) {
arrayList.add(singularToReflectionType(it.next()));
}
return arrayList;
}
@Override
public Message getMessageDefaultInstance() {
return this.messageDefaultInstance;
}
}
public GeneratedMessage() {
this.unknownFields = UnknownFieldSet.getDefaultInstance();
}
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 void enableAlwaysUseFieldBuildersForTesting() {
alwaysUseFieldBuilders = 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);
}
}
public static <ContainingType extends Message, Type> GeneratedExtension<ContainingType, Type> newFileScopedGeneratedExtension(Class cls, Message message) {
return new GeneratedExtension<>(null, cls, message, Extension.ExtensionType.IMMUTABLE);
}
public static <ContainingType extends Message, Type> GeneratedExtension<ContainingType, Type> newMessageScopedGeneratedExtension(final Message message, final int i, Class cls, Message message2) {
return new GeneratedExtension<>(new CachedDescriptorRetriever() {
{
super();
}
@Override
public Descriptors.FieldDescriptor loadDescriptor() {
return Message.this.getDescriptorForType().getExtensions().get(i);
}
}, cls, message2, Extension.ExtensionType.IMMUTABLE);
}
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 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 GeneratedMessage> 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;
}
@Override
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() {
}
@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 boolean parseUnknownField(CodedInputStream codedInputStream, UnknownFieldSet.Builder builder, ExtensionRegistryLite extensionRegistryLite, int i) throws IOException {
return builder.mergeFieldFrom(i, codedInputStream);
}
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 ExtendableBuilder<MessageType extends ExtendableMessage, BuilderType extends ExtendableBuilder<MessageType, BuilderType>> extends Builder<BuilderType> implements ExtendableMessageOrBuilder<MessageType> {
private FieldSet<Descriptors.FieldDescriptor> extensions;
public ExtendableBuilder() {
this.extensions = FieldSet.emptySet();
}
public FieldSet<Descriptors.FieldDescriptor> buildExtensions() {
this.extensions.makeImmutable();
return this.extensions;
}
private void ensureExtensionsIsMutable() {
if (this.extensions.isImmutable()) {
this.extensions = this.extensions.m63clone();
}
}
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 = GeneratedMessage.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
ensureExtensionsIsMutable();
this.extensions.addRepeatedField(checkNotLite.getDescriptor(), checkNotLite.singularToReflectionType(type));
onChanged();
return this;
}
public final <Type> BuilderType clearExtension(ExtensionLite<MessageType, ?> extensionLite) {
Extension<MessageType, ?> checkNotLite = GeneratedMessage.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
ensureExtensionsIsMutable();
this.extensions.clearField(checkNotLite.getDescriptor());
onChanged();
return this;
}
public boolean extensionsAreInitialized() {
return this.extensions.isInitialized();
}
@Override
public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
Map allFieldsMutable = getAllFieldsMutable();
allFieldsMutable.putAll(this.extensions.getAllFields());
return Collections.unmodifiableMap(allFieldsMutable);
}
@Override
public final <Type> Type getExtension(ExtensionLite<MessageType, Type> extensionLite) {
Extension<MessageType, ?> checkNotLite = GeneratedMessage.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 = GeneratedMessage.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
return this.extensions.getRepeatedFieldCount(checkNotLite.getDescriptor());
}
@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.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 = GeneratedMessage.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);
}
public void internalSetExtensionSet(FieldSet<Descriptors.FieldDescriptor> fieldSet) {
this.extensions = fieldSet;
}
@Override
public boolean isInitialized() {
return super.isInitialized() && extensionsAreInitialized();
}
public final void mergeExtensionFields(ExtendableMessage extendableMessage) {
ensureExtensionsIsMutable();
this.extensions.mergeFrom(extendableMessage.extensions);
onChanged();
}
@Override
public boolean parseUnknownField(CodedInputStream codedInputStream, UnknownFieldSet.Builder builder, ExtensionRegistryLite extensionRegistryLite, int i) throws IOException {
return MessageReflection.mergeFieldFrom(codedInputStream, builder, extensionRegistryLite, getDescriptorForType(), new MessageReflection.BuilderAdapter(this), i);
}
public final <Type> BuilderType setExtension(ExtensionLite<MessageType, Type> extensionLite, Type type) {
Extension<MessageType, ?> checkNotLite = GeneratedMessage.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
ensureExtensionsIsMutable();
this.extensions.setField(checkNotLite.getDescriptor(), checkNotLite.toReflectionType(type));
onChanged();
return this;
}
public ExtendableBuilder(BuilderParent builderParent) {
super(builderParent);
this.extensions = FieldSet.emptySet();
}
@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 = FieldSet.emptySet();
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(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(GeneratedExtension<MessageType, List<Type>> generatedExtension) {
return getExtensionCount((ExtensionLite) generatedExtension);
}
public <Type> BuilderType clearExtension(GeneratedExtension<MessageType, ?> generatedExtension) {
return clearExtension((ExtensionLite) generatedExtension);
}
@Override
public BuilderType mo62clone() {
return (BuilderType) super.mo62clone();
}
public final <Type> BuilderType setExtension(ExtensionLite<MessageType, List<Type>> extensionLite, int i, Type type) {
Extension<MessageType, ?> checkNotLite = GeneratedMessage.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(GeneratedExtension<MessageType, List<Type>> generatedExtension, Type type) {
return addExtension((ExtensionLite<MessageType, List<GeneratedExtension<MessageType, List<Type>>>>) generatedExtension, (GeneratedExtension<MessageType, List<Type>>) type);
}
@Override
public final <Type> Type getExtension(ExtensionLite<MessageType, List<Type>> extensionLite, int i) {
Extension<MessageType, ?> checkNotLite = GeneratedMessage.checkNotLite(extensionLite);
verifyExtensionContainingType(checkNotLite);
return (Type) checkNotLite.singularFromReflectionType(this.extensions.getRepeatedField(checkNotLite.getDescriptor(), i));
}
public final <Type> BuilderType setExtension(Extension<MessageType, Type> extension, Type type) {
return setExtension(extension, (Extension<MessageType, Type>) type);
}
public <Type> BuilderType setExtension(GeneratedExtension<MessageType, Type> generatedExtension, Type type) {
return setExtension((ExtensionLite<MessageType, GeneratedExtension<MessageType, Type>>) generatedExtension, (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(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(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(GeneratedExtension<MessageType, List<Type>> generatedExtension, int i) {
return (Type) getExtension((ExtensionLite) generatedExtension, i);
}
}
public static abstract class ExtendableMessage<MessageType extends ExtendableMessage> extends GeneratedMessage 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 = GeneratedMessage.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 = GeneratedMessage.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 = GeneratedMessage.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 {
return MessageReflection.mergeFieldFrom(codedInputStream, builder, extensionRegistryLite, getDescriptorForType(), new MessageReflection.ExtensionAdapter(this.extensions), 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(GeneratedExtension<MessageType, Type> generatedExtension) {
return hasExtension((ExtensionLite) generatedExtension);
}
@Override
public final <Type> int getExtensionCount(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 = GeneratedMessage.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(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(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(GeneratedMessage generatedMessage);
Message.Builder getBuilder(Builder builder);
Object getRaw(Builder builder);
Object getRaw(GeneratedMessage generatedMessage);
Object getRepeated(Builder builder, int i);
Object getRepeated(GeneratedMessage generatedMessage, int i);
Message.Builder getRepeatedBuilder(Builder builder, int i);
int getRepeatedCount(Builder builder);
int getRepeatedCount(GeneratedMessage generatedMessage);
Object getRepeatedRaw(Builder builder, int i);
Object getRepeatedRaw(GeneratedMessage generatedMessage, int i);
boolean has(Builder builder);
boolean has(GeneratedMessage generatedMessage);
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 GeneratedMessage> cls, Class<? extends Builder> cls2) {
this.field = fieldDescriptor;
this.mapEntryMessageDefaultInstance = getMapField((GeneratedMessage) GeneratedMessage.invokeOrDie(GeneratedMessage.getMethodOrDie(cls, "getDefaultInstance", new Class[0]), null, new Object[0])).getMapEntryMessageDefaultInstance();
}
private MapField<?, ?> getMapField(GeneratedMessage generatedMessage) {
return generatedMessage.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((Message) obj);
}
@Override
public void clear(Builder builder) {
getMutableMapField(builder).getMutableList().clear();
}
@Override
public Object get(GeneratedMessage generatedMessage) {
ArrayList arrayList = new ArrayList();
for (int i = 0; i < getRepeatedCount(generatedMessage); i++) {
arrayList.add(getRepeated(generatedMessage, 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(GeneratedMessage generatedMessage) {
return get(generatedMessage);
}
@Override
public Object getRepeated(GeneratedMessage generatedMessage, int i) {
return getMapField(generatedMessage).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(GeneratedMessage generatedMessage) {
return getMapField(generatedMessage).getList().size();
}
@Override
public Object getRepeatedRaw(GeneratedMessage generatedMessage, int i) {
return getRepeated(generatedMessage, i);
}
@Override
public boolean has(GeneratedMessage generatedMessage) {
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, (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 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;
public OneofAccessor(Descriptors.Descriptor descriptor, String str, Class<? extends GeneratedMessage> cls, Class<? extends Builder> cls2) {
this.descriptor = descriptor;
this.caseMethod = GeneratedMessage.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Case"), new Class[0]);
this.caseMethodBuilder = GeneratedMessage.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Case"), new Class[0]);
this.clearMethod = GeneratedMessage.getMethodOrDie(cls2, d0.C("clear", str), new Class[0]);
}
public void clear(Builder builder) {
GeneratedMessage.invokeOrDie(this.clearMethod, builder, new Object[0]);
}
public Descriptors.FieldDescriptor get(GeneratedMessage generatedMessage) {
int number = ((Internal.EnumLite) GeneratedMessage.invokeOrDie(this.caseMethod, generatedMessage, new Object[0])).getNumber();
if (number > 0) {
return this.descriptor.findFieldByNumber(number);
}
return null;
}
public boolean has(GeneratedMessage generatedMessage) {
return ((Internal.EnumLite) GeneratedMessage.invokeOrDie(this.caseMethod, generatedMessage, new Object[0])).getNumber() != 0;
}
public boolean has(Builder builder) {
return ((Internal.EnumLite) GeneratedMessage.invokeOrDie(this.caseMethodBuilder, builder, new Object[0])).getNumber() != 0;
}
public Descriptors.FieldDescriptor get(Builder builder) {
int number = ((Internal.EnumLite) GeneratedMessage.invokeOrDie(this.caseMethodBuilder, builder, new Object[0])).getNumber();
if (number > 0) {
return this.descriptor.findFieldByNumber(number);
}
return null;
}
}
public static class RepeatedFieldAccessor implements FieldAccessor {
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;
protected final Class type;
public RepeatedFieldAccessor(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessage> cls, Class<? extends Builder> cls2) {
this.getMethod = GeneratedMessage.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "List"), new Class[0]);
this.getMethodBuilder = GeneratedMessage.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 = GeneratedMessage.getMethodOrDie(cls, C, cls3);
this.getRepeatedMethod = methodOrDie;
this.getRepeatedMethodBuilder = GeneratedMessage.getMethodOrDie(cls2, d0.C("get", str), cls3);
Class<?> returnType = methodOrDie.getReturnType();
this.type = returnType;
this.setRepeatedMethod = GeneratedMessage.getMethodOrDie(cls2, d0.C("set", str), cls3, returnType);
this.addRepeatedMethod = GeneratedMessage.getMethodOrDie(cls2, d0.C("add", str), returnType);
this.getCountMethod = GeneratedMessage.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Count"), new Class[0]);
this.getCountMethodBuilder = GeneratedMessage.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Count"), new Class[0]);
this.clearMethod = GeneratedMessage.getMethodOrDie(cls2, d0.C("clear", str), new Class[0]);
}
@Override
public void addRepeated(Builder builder, Object obj) {
GeneratedMessage.invokeOrDie(this.addRepeatedMethod, builder, obj);
}
@Override
public void clear(Builder builder) {
GeneratedMessage.invokeOrDie(this.clearMethod, builder, new Object[0]);
}
@Override
public Object get(GeneratedMessage generatedMessage) {
return GeneratedMessage.invokeOrDie(this.getMethod, generatedMessage, new Object[0]);
}
@Override
public Message.Builder getBuilder(Builder builder) {
throw new UnsupportedOperationException("getFieldBuilder() called on a non-Message type.");
}
@Override
public Object getRaw(GeneratedMessage generatedMessage) {
return get(generatedMessage);
}
@Override
public Object getRepeated(GeneratedMessage generatedMessage, int i) {
return GeneratedMessage.invokeOrDie(this.getRepeatedMethod, generatedMessage, Integer.valueOf(i));
}
@Override
public Message.Builder getRepeatedBuilder(Builder builder, int i) {
throw new UnsupportedOperationException("getRepeatedFieldBuilder() called on a non-Message type.");
}
@Override
public int getRepeatedCount(GeneratedMessage generatedMessage) {
return ((Integer) GeneratedMessage.invokeOrDie(this.getCountMethod, generatedMessage, new Object[0])).intValue();
}
@Override
public Object getRepeatedRaw(GeneratedMessage generatedMessage, int i) {
return getRepeated(generatedMessage, i);
}
@Override
public boolean has(GeneratedMessage generatedMessage) {
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) {
GeneratedMessage.invokeOrDie(this.setRepeatedMethod, builder, Integer.valueOf(i), obj);
}
@Override
public Object get(Builder builder) {
return GeneratedMessage.invokeOrDie(this.getMethodBuilder, builder, new Object[0]);
}
@Override
public Object getRaw(Builder builder) {
return get(builder);
}
@Override
public Object getRepeated(Builder builder, int i) {
return GeneratedMessage.invokeOrDie(this.getRepeatedMethodBuilder, builder, Integer.valueOf(i));
}
@Override
public int getRepeatedCount(Builder builder) {
return ((Integer) GeneratedMessage.invokeOrDie(this.getCountMethodBuilder, builder, new Object[0])).intValue();
}
@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 GeneratedMessage> cls, Class<? extends Builder> cls2) {
super(fieldDescriptor, str, cls, cls2);
this.newBuilderMethod = GeneratedMessage.getMethodOrDie(this.type, "newBuilder", new Class[0]);
this.getBuilderMethodBuilder = GeneratedMessage.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) GeneratedMessage.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) GeneratedMessage.invokeOrDie(this.getBuilderMethodBuilder, builder, Integer.valueOf(i));
}
@Override
public Message.Builder newBuilder() {
return (Message.Builder) GeneratedMessage.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 java.lang.reflect.Method caseMethod;
protected final java.lang.reflect.Method caseMethodBuilder;
protected final java.lang.reflect.Method clearMethod;
protected final Descriptors.FieldDescriptor field;
protected final java.lang.reflect.Method getMethod;
protected final java.lang.reflect.Method getMethodBuilder;
protected final boolean hasHasMethod;
protected final java.lang.reflect.Method hasMethod;
protected final java.lang.reflect.Method hasMethodBuilder;
protected final boolean isOneofField;
protected final java.lang.reflect.Method setMethod;
protected final Class<?> type;
public SingularFieldAccessor(Descriptors.FieldDescriptor fieldDescriptor, String str, Class<? extends GeneratedMessage> cls, Class<? extends Builder> cls2, String str2) {
this.field = fieldDescriptor;
boolean z = true;
boolean z2 = fieldDescriptor.getContainingOneof() != null;
this.isOneofField = z2;
if (!FieldAccessorTable.supportFieldPresence(fieldDescriptor.getFile()) && (z2 || fieldDescriptor.getJavaType() != Descriptors.FieldDescriptor.JavaType.MESSAGE)) {
z = false;
}
this.hasHasMethod = z;
java.lang.reflect.Method methodOrDie = GeneratedMessage.getMethodOrDie(cls, d0.C("get", str), new Class[0]);
this.getMethod = methodOrDie;
this.getMethodBuilder = GeneratedMessage.getMethodOrDie(cls2, d0.C("get", str), new Class[0]);
Class<?> returnType = methodOrDie.getReturnType();
this.type = returnType;
this.setMethod = GeneratedMessage.getMethodOrDie(cls2, d0.C("set", str), returnType);
this.hasMethod = z ? GeneratedMessage.getMethodOrDie(cls, d0.C("has", str), new Class[0]) : null;
this.hasMethodBuilder = z ? GeneratedMessage.getMethodOrDie(cls2, d0.C("has", str), new Class[0]) : null;
this.clearMethod = GeneratedMessage.getMethodOrDie(cls2, d0.C("clear", str), new Class[0]);
this.caseMethod = z2 ? GeneratedMessage.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str2, "Case"), new Class[0]) : null;
this.caseMethodBuilder = z2 ? GeneratedMessage.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str2, "Case"), new Class[0]) : null;
}
private int getOneofFieldNumber(GeneratedMessage generatedMessage) {
return ((Internal.EnumLite) GeneratedMessage.invokeOrDie(this.caseMethod, generatedMessage, new Object[0])).getNumber();
}
@Override
public void addRepeated(Builder builder, Object obj) {
throw new UnsupportedOperationException("addRepeatedField() called on a singular field.");
}
@Override
public void clear(Builder builder) {
GeneratedMessage.invokeOrDie(this.clearMethod, builder, new Object[0]);
}
@Override
public Object get(GeneratedMessage generatedMessage) {
return GeneratedMessage.invokeOrDie(this.getMethod, generatedMessage, new Object[0]);
}
@Override
public Message.Builder getBuilder(Builder builder) {
throw new UnsupportedOperationException("getFieldBuilder() called on a non-Message type.");
}
@Override
public Object getRaw(GeneratedMessage generatedMessage) {
return get(generatedMessage);
}
@Override
public Object getRepeated(GeneratedMessage generatedMessage, 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(GeneratedMessage generatedMessage) {
throw new UnsupportedOperationException("getRepeatedFieldSize() called on a singular field.");
}
@Override
public Object getRepeatedRaw(GeneratedMessage generatedMessage, int i) {
throw new UnsupportedOperationException("getRepeatedFieldRaw() called on a singular field.");
}
@Override
public boolean has(GeneratedMessage generatedMessage) {
return !this.hasHasMethod ? this.isOneofField ? getOneofFieldNumber(generatedMessage) == this.field.getNumber() : !get(generatedMessage).equals(this.field.getDefaultValue()) : ((Boolean) GeneratedMessage.invokeOrDie(this.hasMethod, generatedMessage, new Object[0])).booleanValue();
}
@Override
public Message.Builder newBuilder() {
throw new UnsupportedOperationException("newBuilderForField() called on a non-Message type.");
}
@Override
public void set(Builder builder, Object obj) {
GeneratedMessage.invokeOrDie(this.setMethod, builder, obj);
}
@Override
public void setRepeated(Builder builder, int i, Object obj) {
throw new UnsupportedOperationException("setRepeatedField() called on a singular field.");
}
private int getOneofFieldNumber(Builder builder) {
return ((Internal.EnumLite) GeneratedMessage.invokeOrDie(this.caseMethodBuilder, builder, new Object[0])).getNumber();
}
@Override
public Object get(Builder builder) {
return GeneratedMessage.invokeOrDie(this.getMethodBuilder, builder, new Object[0]);
}
@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 getOneofFieldNumber(builder) == this.field.getNumber();
}
return !get(builder).equals(this.field.getDefaultValue());
}
return ((Boolean) GeneratedMessage.invokeOrDie(this.hasMethodBuilder, builder, new Object[0])).booleanValue();
}
}
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 GeneratedMessage> cls, Class<? extends Builder> cls2, String str2) {
super(fieldDescriptor, str, cls, cls2, str2);
this.newBuilderMethod = GeneratedMessage.getMethodOrDie(this.type, "newBuilder", new Class[0]);
this.getBuilderMethodBuilder = GeneratedMessage.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) GeneratedMessage.invokeOrDie(this.newBuilderMethod, null, new Object[0])).mergeFrom((Message) obj).buildPartial();
}
@Override
public Message.Builder getBuilder(Builder builder) {
return (Message.Builder) GeneratedMessage.invokeOrDie(this.getBuilderMethodBuilder, builder, new Object[0]);
}
@Override
public Message.Builder newBuilder() {
return (Message.Builder) GeneratedMessage.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 GeneratedMessage> cls, Class<? extends Builder> cls2, String str2) {
super(fieldDescriptor, str, cls, cls2, str2);
this.getBytesMethod = GeneratedMessage.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Bytes"), new Class[0]);
this.getBytesMethodBuilder = GeneratedMessage.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Bytes"), new Class[0]);
this.setBytesMethodBuilder = GeneratedMessage.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("set", str, "Bytes"), ByteString.class);
}
@Override
public Object getRaw(GeneratedMessage generatedMessage) {
return GeneratedMessage.invokeOrDie(this.getBytesMethod, generatedMessage, new Object[0]);
}
@Override
public void set(Builder builder, Object obj) {
if (obj instanceof ByteString) {
GeneratedMessage.invokeOrDie(this.setBytesMethodBuilder, builder, obj);
} else {
super.set(builder, obj);
}
}
@Override
public Object getRaw(Builder builder) {
return GeneratedMessage.invokeOrDie(this.getBytesMethodBuilder, builder, new Object[0]);
}
}
public FieldAccessorTable(Descriptors.Descriptor descriptor, String[] strArr, Class<? extends GeneratedMessage> 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.");
}
private boolean isMapFieldEnabled(Descriptors.FieldDescriptor fieldDescriptor) {
return true;
}
public static boolean supportFieldPresence(Descriptors.FileDescriptor fileDescriptor) {
return fileDescriptor.getSyntax() == Descriptors.FileDescriptor.Syntax.PROTO2;
}
public FieldAccessorTable ensureFieldAccessorsInitialized(Class<? extends GeneratedMessage> cls, Class<? extends Builder> cls2) {
Class<? extends GeneratedMessage> cls3;
Class<? extends Builder> cls4;
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() && isMapFieldEnabled(fieldDescriptor)) {
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);
}
cls3 = cls;
cls4 = cls2;
} else if (fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE) {
cls3 = cls;
cls4 = cls2;
this.fields[i] = new SingularMessageFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls3, cls4, str);
} else {
cls3 = cls;
cls4 = cls2;
if (fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.ENUM) {
this.fields[i] = new SingularEnumFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls3, cls4, str);
} else if (fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.STRING) {
this.fields[i] = new SingularStringFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls3, cls4, str);
} else {
this.fields[i] = new SingularFieldAccessor(fieldDescriptor, this.camelCaseNames[i], cls3, cls4, str);
}
}
i++;
cls = cls3;
cls2 = cls4;
}
Class<? extends GeneratedMessage> cls5 = cls;
Class<? extends Builder> cls6 = cls2;
int length2 = this.oneofs.length;
for (int i2 = 0; i2 < length2; i2++) {
this.oneofs[i2] = new OneofAccessor(this.descriptor, this.camelCaseNames[i2 + length], cls5, cls6);
}
this.initialized = true;
this.camelCaseNames = null;
return this;
} catch (Throwable th) {
throw th;
}
}
}
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 GeneratedMessage> cls, Class<? extends Builder> cls2) {
super(fieldDescriptor, str, cls, cls2);
this.enumDescriptor = fieldDescriptor.getEnumType();
this.valueOfMethod = GeneratedMessage.getMethodOrDie(this.type, "valueOf", Descriptors.EnumValueDescriptor.class);
this.getValueDescriptorMethod = GeneratedMessage.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 = GeneratedMessage.getMethodOrDie(cls, m, cls3);
this.getRepeatedValueMethodBuilder = GeneratedMessage.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Value"), cls3);
this.setRepeatedValueMethod = GeneratedMessage.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("set", str, "Value"), cls3, cls3);
this.addRepeatedValueMethod = GeneratedMessage.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("add", str, "Value"), cls3);
}
}
@Override
public void addRepeated(Builder builder, Object obj) {
if (this.supportUnknownEnumValue) {
GeneratedMessage.invokeOrDie(this.addRepeatedValueMethod, builder, Integer.valueOf(((Descriptors.EnumValueDescriptor) obj).getNumber()));
} else {
super.addRepeated(builder, GeneratedMessage.invokeOrDie(this.valueOfMethod, null, obj));
}
}
@Override
public Object get(GeneratedMessage generatedMessage) {
ArrayList arrayList = new ArrayList();
int repeatedCount = getRepeatedCount(generatedMessage);
for (int i = 0; i < repeatedCount; i++) {
arrayList.add(getRepeated(generatedMessage, i));
}
return Collections.unmodifiableList(arrayList);
}
@Override
public Object getRepeated(GeneratedMessage generatedMessage, int i) {
if (!this.supportUnknownEnumValue) {
return GeneratedMessage.invokeOrDie(this.getValueDescriptorMethod, super.getRepeated(generatedMessage, i), new Object[0]);
}
return this.enumDescriptor.findValueByNumberCreatingIfUnknown(((Integer) GeneratedMessage.invokeOrDie(this.getRepeatedValueMethod, generatedMessage, Integer.valueOf(i))).intValue());
}
@Override
public void setRepeated(Builder builder, int i, Object obj) {
if (this.supportUnknownEnumValue) {
GeneratedMessage.invokeOrDie(this.setRepeatedValueMethod, builder, Integer.valueOf(i), Integer.valueOf(((Descriptors.EnumValueDescriptor) obj).getNumber()));
} else {
super.setRepeated(builder, i, GeneratedMessage.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) GeneratedMessage.invokeOrDie(this.getRepeatedValueMethodBuilder, builder, Integer.valueOf(i))).intValue());
}
return GeneratedMessage.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 GeneratedMessage> cls, Class<? extends Builder> cls2, String str2) {
super(fieldDescriptor, str, cls, cls2, str2);
this.enumDescriptor = fieldDescriptor.getEnumType();
this.valueOfMethod = GeneratedMessage.getMethodOrDie(this.type, "valueOf", Descriptors.EnumValueDescriptor.class);
this.getValueDescriptorMethod = GeneratedMessage.getMethodOrDie(this.type, "getValueDescriptor", new Class[0]);
boolean supportsUnknownEnumValue = fieldDescriptor.getFile().supportsUnknownEnumValue();
this.supportUnknownEnumValue = supportsUnknownEnumValue;
if (supportsUnknownEnumValue) {
this.getValueMethod = GeneratedMessage.getMethodOrDie(cls, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Value"), new Class[0]);
this.getValueMethodBuilder = GeneratedMessage.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("get", str, "Value"), new Class[0]);
this.setValueMethod = GeneratedMessage.getMethodOrDie(cls2, com.mobilefuse.sdk.assetsmanager.a.m("set", str, "Value"), Integer.TYPE);
}
}
@Override
public Object get(GeneratedMessage generatedMessage) {
if (!this.supportUnknownEnumValue) {
return GeneratedMessage.invokeOrDie(this.getValueDescriptorMethod, super.get(generatedMessage), new Object[0]);
}
return this.enumDescriptor.findValueByNumberCreatingIfUnknown(((Integer) GeneratedMessage.invokeOrDie(this.getValueMethod, generatedMessage, new Object[0])).intValue());
}
@Override
public void set(Builder builder, Object obj) {
if (this.supportUnknownEnumValue) {
GeneratedMessage.invokeOrDie(this.setValueMethod, builder, Integer.valueOf(((Descriptors.EnumValueDescriptor) obj).getNumber()));
} else {
super.set(builder, GeneratedMessage.invokeOrDie(this.valueOfMethod, null, obj));
}
}
@Override
public Object get(Builder builder) {
if (this.supportUnknownEnumValue) {
return this.enumDescriptor.findValueByNumberCreatingIfUnknown(((Integer) GeneratedMessage.invokeOrDie(this.getValueMethodBuilder, builder, new Object[0])).intValue());
}
return GeneratedMessage.invokeOrDie(this.getValueDescriptorMethod, super.get(builder), new Object[0]);
}
}
}
public static <ContainingType extends Message, Type> GeneratedExtension<ContainingType, Type> newFileScopedGeneratedExtension(final Class cls, Message message, final String str, final String str2) {
return new GeneratedExtension<>(new CachedDescriptorRetriever() {
{
super();
}
@Override
public Descriptors.FieldDescriptor loadDescriptor() {
try {
return ((Descriptors.FileDescriptor) cls.getClassLoader().loadClass(str).getField("descriptor").get(null)).findExtensionByName(str2);
} catch (Exception e) {
throw new RuntimeException(d0.s(new StringBuilder("Cannot load descriptors: "), str, " is not a valid descriptor class name"), e);
}
}
}, cls, message, Extension.ExtensionType.MUTABLE);
}
public static <ContainingType extends Message, Type> GeneratedExtension<ContainingType, Type> newMessageScopedGeneratedExtension(final Message message, final String str, Class cls, Message message2) {
return new GeneratedExtension<>(new CachedDescriptorRetriever() {
{
super();
}
@Override
public Descriptors.FieldDescriptor loadDescriptor() {
return Message.this.getDescriptorForType().findFieldByName(str);
}
}, cls, message2, Extension.ExtensionType.MUTABLE);
}
public GeneratedMessage(Builder<?> builder) {
this.unknownFields = builder.getUnknownFields();
}
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 <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 <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();
}
}
}