Daniel Elliott
f9d20bb3fc
- 28,932 files - Full Java source code - Smali files - Resources Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
1002 lines
36 KiB
Java
1002 lines
36 KiB
Java
package com.fyber.inneractive.sdk.protobuf;
|
|
|
|
import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
|
|
import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite.b;
|
|
import com.fyber.inneractive.sdk.protobuf.a;
|
|
import com.fyber.inneractive.sdk.protobuf.e;
|
|
import com.fyber.inneractive.sdk.protobuf.i;
|
|
import com.fyber.inneractive.sdk.protobuf.j;
|
|
import com.fyber.inneractive.sdk.protobuf.o0;
|
|
import com.fyber.inneractive.sdk.protobuf.q;
|
|
import com.fyber.inneractive.sdk.protobuf.r1;
|
|
import com.fyber.inneractive.sdk.protobuf.u;
|
|
import com.fyber.inneractive.sdk.protobuf.y;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.nio.ByteBuffer;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
|
/* loaded from: classes2.dex */
|
|
public abstract class GeneratedMessageLite<MessageType extends GeneratedMessageLite<MessageType, BuilderType>, BuilderType extends b<MessageType, BuilderType>> extends com.fyber.inneractive.sdk.protobuf.a<MessageType, BuilderType> {
|
|
private static Map<Object, GeneratedMessageLite<?, ?>> defaultInstanceMap = new ConcurrentHashMap();
|
|
protected l1 unknownFields = l1.f;
|
|
protected int memoizedSerializedSize = -1;
|
|
|
|
public static abstract class ExtendableMessage<MessageType extends ExtendableMessage<MessageType, BuilderType>, BuilderType> extends GeneratedMessageLite<MessageType, BuilderType> implements p0 {
|
|
protected u<d> extensions = u.b();
|
|
|
|
public class a {
|
|
public a(ExtendableMessage extendableMessage) {
|
|
Iterator<Map.Entry<d, Object>> e = extendableMessage.extensions.e();
|
|
if (e.hasNext()) {
|
|
e.next();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void eagerlyMergeMessageSetExtension(j jVar, e<?, ?> eVar, q qVar, int i) throws IOException {
|
|
parseExtension(jVar, qVar, eVar, r1.a(i, 2), i);
|
|
}
|
|
|
|
private void mergeMessageSetExtensionFromBytes(i iVar, q qVar, e<?, ?> eVar) throws IOException {
|
|
o0 o0Var = (o0) this.extensions.a((u<d>) eVar.d);
|
|
o0.a builder = o0Var != null ? o0Var.toBuilder() : null;
|
|
if (builder == null) {
|
|
builder = eVar.c.newBuilderForType();
|
|
}
|
|
a.AbstractC0103a abstractC0103a = (a.AbstractC0103a) builder;
|
|
abstractC0103a.getClass();
|
|
try {
|
|
j g = iVar.g();
|
|
((b) abstractC0103a).a(g, qVar);
|
|
g.a(0);
|
|
Object a2 = ((b) builder).a();
|
|
u<d> ensureExtensionsAreMutable = ensureExtensionsAreMutable();
|
|
d dVar = eVar.d;
|
|
if (dVar.c.e() == r1.c.ENUM) {
|
|
a2 = Integer.valueOf(((y.c) a2).a());
|
|
}
|
|
ensureExtensionsAreMutable.b(dVar, a2);
|
|
} catch (z e) {
|
|
throw e;
|
|
} catch (IOException e2) {
|
|
throw new RuntimeException("Reading " + abstractC0103a.getClass().getName() + " from a ByteString threw an IOException (should never happen).", e2);
|
|
}
|
|
}
|
|
|
|
private <MessageType extends o0> void mergeMessageSetExtensionFromCodedStream(MessageType messagetype, j jVar, q qVar) throws IOException {
|
|
int i = 0;
|
|
i.h hVar = null;
|
|
e<?, ?> eVar = null;
|
|
while (true) {
|
|
int t = jVar.t();
|
|
if (t == 0) {
|
|
break;
|
|
}
|
|
if (t == r1.c) {
|
|
i = jVar.u();
|
|
if (i != 0) {
|
|
eVar = qVar.a.get(new q.a(i, messagetype));
|
|
}
|
|
} else if (t == r1.d) {
|
|
if (i == 0 || eVar == null) {
|
|
hVar = jVar.e();
|
|
} else {
|
|
eagerlyMergeMessageSetExtension(jVar, eVar, qVar, i);
|
|
hVar = null;
|
|
}
|
|
} else if (!jVar.e(t)) {
|
|
break;
|
|
}
|
|
}
|
|
jVar.a(r1.b);
|
|
if (hVar == null || i == 0) {
|
|
return;
|
|
}
|
|
if (eVar != null) {
|
|
mergeMessageSetExtensionFromBytes(hVar, qVar, eVar);
|
|
} else {
|
|
mergeLengthDelimitedField(i, hVar);
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX WARN: Removed duplicated region for block: B:10:0x0037 */
|
|
/* JADX WARN: Removed duplicated region for block: B:7:0x0032 */
|
|
/* JADX WARN: Type inference failed for: r10v27, types: [com.fyber.inneractive.sdk.protobuf.y$c] */
|
|
/* JADX WARN: Type inference failed for: r10v30, types: [java.lang.Integer] */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
private boolean parseExtension(com.fyber.inneractive.sdk.protobuf.j r7, com.fyber.inneractive.sdk.protobuf.q r8, com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite.e<?, ?> r9, int r10, int r11) throws java.io.IOException {
|
|
/*
|
|
Method dump skipped, instructions count: 318
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite.ExtendableMessage.parseExtension(com.fyber.inneractive.sdk.protobuf.j, com.fyber.inneractive.sdk.protobuf.q, com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite$e, int, int):boolean");
|
|
}
|
|
|
|
private void verifyExtensionContainingType(e<MessageType, ?> eVar) {
|
|
if (eVar.a != getDefaultInstanceForType()) {
|
|
throw new IllegalArgumentException("This extension is for a different message type. Please make sure that you are not suppressing any generics type warnings.");
|
|
}
|
|
}
|
|
|
|
public boolean extensionsAreInitialized() {
|
|
return this.extensions.d();
|
|
}
|
|
|
|
public int extensionsSerializedSize() {
|
|
return this.extensions.c();
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite, com.fyber.inneractive.sdk.protobuf.p0
|
|
public /* bridge */ /* synthetic */ o0 getDefaultInstanceForType() {
|
|
return super.getDefaultInstanceForType();
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX WARN: Type inference failed for: r1v6, types: [Type, java.util.ArrayList] */
|
|
public final <Type> Type getExtension(o<MessageType, Type> oVar) {
|
|
e<MessageType, ?> checkIsLite = GeneratedMessageLite.checkIsLite(oVar);
|
|
verifyExtensionContainingType(checkIsLite);
|
|
Type type = (Type) this.extensions.a((u<d>) checkIsLite.d);
|
|
if (type == 0) {
|
|
return checkIsLite.b;
|
|
}
|
|
d dVar = checkIsLite.d;
|
|
if (!dVar.d) {
|
|
return dVar.c.e() == r1.c.ENUM ? (Type) checkIsLite.d.a.a(((Integer) type).intValue()) : type;
|
|
}
|
|
if (dVar.c.e() != r1.c.ENUM) {
|
|
return type;
|
|
}
|
|
?? r1 = (Type) new ArrayList();
|
|
for (Object obj : (List) type) {
|
|
if (checkIsLite.d.c.e() == r1.c.ENUM) {
|
|
obj = checkIsLite.d.a.a(((Integer) obj).intValue());
|
|
}
|
|
r1.add(obj);
|
|
}
|
|
return r1;
|
|
}
|
|
|
|
public final <Type> int getExtensionCount(o<MessageType, List<Type>> oVar) {
|
|
e<MessageType, ?> checkIsLite = GeneratedMessageLite.checkIsLite(oVar);
|
|
verifyExtensionContainingType(checkIsLite);
|
|
u<d> uVar = this.extensions;
|
|
d dVar = checkIsLite.d;
|
|
uVar.getClass();
|
|
if (!dVar.b()) {
|
|
throw new IllegalArgumentException("getRepeatedField() can only be called on repeated fields.");
|
|
}
|
|
Object a2 = uVar.a((u<d>) dVar);
|
|
if (a2 == null) {
|
|
return 0;
|
|
}
|
|
return ((List) a2).size();
|
|
}
|
|
|
|
public final <Type> boolean hasExtension(o<MessageType, Type> oVar) {
|
|
e<MessageType, ?> checkIsLite = GeneratedMessageLite.checkIsLite(oVar);
|
|
verifyExtensionContainingType(checkIsLite);
|
|
u<d> uVar = this.extensions;
|
|
d dVar = checkIsLite.d;
|
|
uVar.getClass();
|
|
if (dVar.b()) {
|
|
throw new IllegalArgumentException("hasField() can only be called on non-repeated fields.");
|
|
}
|
|
return uVar.a.get(dVar) != null;
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite, com.fyber.inneractive.sdk.protobuf.o0
|
|
public /* bridge */ /* synthetic */ o0.a newBuilderForType() {
|
|
return super.newBuilderForType();
|
|
}
|
|
|
|
public ExtendableMessage<MessageType, BuilderType>.a newExtensionWriter() {
|
|
return new a(this);
|
|
}
|
|
|
|
public ExtendableMessage<MessageType, BuilderType>.a newMessageSetExtensionWriter() {
|
|
return new a(this);
|
|
}
|
|
|
|
public <MessageType extends o0> boolean parseUnknownField(MessageType messagetype, j jVar, q qVar, int i) throws IOException {
|
|
int i2 = r1.a;
|
|
int i3 = i >>> 3;
|
|
return parseExtension(jVar, qVar, qVar.a.get(new q.a(i3, messagetype)), i, i3);
|
|
}
|
|
|
|
public <MessageType extends o0> boolean parseUnknownFieldAsMessageSet(MessageType messagetype, j jVar, q qVar, int i) throws IOException {
|
|
if (i != r1.a) {
|
|
return (i & 7) == 2 ? parseUnknownField(messagetype, jVar, qVar, i) : jVar.e(i);
|
|
}
|
|
mergeMessageSetExtensionFromCodedStream(messagetype, jVar, qVar);
|
|
return true;
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite, com.fyber.inneractive.sdk.protobuf.o0
|
|
public /* bridge */ /* synthetic */ o0.a toBuilder() {
|
|
return super.toBuilder();
|
|
}
|
|
|
|
public u<d> ensureExtensionsAreMutable() {
|
|
u<d> uVar = this.extensions;
|
|
if (uVar.b) {
|
|
this.extensions = uVar.clone();
|
|
}
|
|
return this.extensions;
|
|
}
|
|
|
|
public int extensionsSerializedSizeAsMessageSet() {
|
|
u<d> uVar = this.extensions;
|
|
int i = 0;
|
|
for (int i2 = 0; i2 < uVar.a.b.size(); i2++) {
|
|
i += u.a(uVar.a.a(i2));
|
|
}
|
|
Iterator<Map.Entry<d, Object>> it = uVar.a.b().iterator();
|
|
while (it.hasNext()) {
|
|
i += u.a(it.next());
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public final void mergeExtensionFields(MessageType messagetype) {
|
|
u<d> uVar = this.extensions;
|
|
if (uVar.b) {
|
|
this.extensions = uVar.clone();
|
|
}
|
|
u<d> uVar2 = this.extensions;
|
|
u<d> uVar3 = messagetype.extensions;
|
|
uVar2.getClass();
|
|
for (int i = 0; i < uVar3.a.b.size(); i++) {
|
|
uVar2.c(uVar3.a.a(i));
|
|
}
|
|
Iterator<Map.Entry<d, Object>> it = uVar3.a.b().iterator();
|
|
while (it.hasNext()) {
|
|
uVar2.c(it.next());
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public final <Type> Type getExtension(o<MessageType, List<Type>> oVar, int i) {
|
|
e<MessageType, ?> checkIsLite = GeneratedMessageLite.checkIsLite(oVar);
|
|
verifyExtensionContainingType(checkIsLite);
|
|
u<d> uVar = this.extensions;
|
|
d dVar = checkIsLite.d;
|
|
uVar.getClass();
|
|
if (dVar.d) {
|
|
Object a2 = uVar.a((u<d>) dVar);
|
|
if (a2 != null) {
|
|
Type type = (Type) ((List) a2).get(i);
|
|
return checkIsLite.d.c.e() == r1.c.ENUM ? (Type) checkIsLite.d.a.a(((Integer) type).intValue()) : type;
|
|
}
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
throw new IllegalArgumentException("getRepeatedField() can only be called on repeated fields.");
|
|
}
|
|
}
|
|
|
|
public static /* synthetic */ class a {
|
|
public static final /* synthetic */ int[] a;
|
|
|
|
static {
|
|
int[] iArr = new int[r1.c.values().length];
|
|
a = iArr;
|
|
try {
|
|
iArr[r1.c.MESSAGE.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
a[r1.c.ENUM.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
}
|
|
}
|
|
|
|
public static abstract class b<MessageType extends GeneratedMessageLite<MessageType, BuilderType>, BuilderType extends b<MessageType, BuilderType>> extends a.AbstractC0103a<MessageType, BuilderType> {
|
|
public final MessageType a;
|
|
public MessageType b;
|
|
public boolean c = false;
|
|
|
|
public b(MessageType messagetype) {
|
|
this.a = messagetype;
|
|
this.b = (MessageType) messagetype.dynamicMethod(f.NEW_MUTABLE_INSTANCE);
|
|
}
|
|
|
|
public static void a(GeneratedMessageLite generatedMessageLite, GeneratedMessageLite generatedMessageLite2) {
|
|
z0 z0Var = z0.c;
|
|
z0Var.getClass();
|
|
z0Var.a(generatedMessageLite.getClass()).a(generatedMessageLite, generatedMessageLite2);
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.p0
|
|
public final o0 getDefaultInstanceForType() {
|
|
return this.a;
|
|
}
|
|
|
|
public final void c() {
|
|
if (this.c) {
|
|
MessageType messagetype = (MessageType) this.b.dynamicMethod(f.NEW_MUTABLE_INSTANCE);
|
|
a(messagetype, this.b);
|
|
this.b = messagetype;
|
|
this.c = false;
|
|
}
|
|
}
|
|
|
|
public final Object clone() throws CloneNotSupportedException {
|
|
b newBuilderForType = this.a.newBuilderForType();
|
|
newBuilderForType.a(b());
|
|
return newBuilderForType;
|
|
}
|
|
|
|
public final MessageType a() {
|
|
MessageType b = b();
|
|
if (b.isInitialized()) {
|
|
return b;
|
|
}
|
|
throw new j1();
|
|
}
|
|
|
|
public final MessageType b() {
|
|
if (this.c) {
|
|
return this.b;
|
|
}
|
|
this.b.makeImmutable();
|
|
this.c = true;
|
|
return this.b;
|
|
}
|
|
|
|
public final BuilderType a(MessageType messagetype) {
|
|
c();
|
|
a(this.b, messagetype);
|
|
return this;
|
|
}
|
|
|
|
public final BuilderType a(j jVar, q qVar) throws IOException {
|
|
c();
|
|
try {
|
|
z0 z0Var = z0.c;
|
|
MessageType messagetype = this.b;
|
|
z0Var.getClass();
|
|
d1 a = z0Var.a(messagetype.getClass());
|
|
MessageType messagetype2 = this.b;
|
|
k kVar = jVar.d;
|
|
if (kVar == null) {
|
|
kVar = new k(jVar);
|
|
}
|
|
a.a(messagetype2, kVar, qVar);
|
|
return this;
|
|
} catch (RuntimeException e) {
|
|
if (e.getCause() instanceof IOException) {
|
|
throw ((IOException) e.getCause());
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class c<T extends GeneratedMessageLite<T, ?>> extends com.fyber.inneractive.sdk.protobuf.b<T> {
|
|
public c(T t) {
|
|
}
|
|
}
|
|
|
|
public static final class d implements u.b<d> {
|
|
public final y.d<?> a;
|
|
public final int b;
|
|
public final r1.b c;
|
|
public final boolean d;
|
|
public final boolean e;
|
|
|
|
public d(y.d<?> dVar, int i, r1.b bVar, boolean z, boolean z2) {
|
|
this.a = dVar;
|
|
this.b = i;
|
|
this.c = bVar;
|
|
this.d = z;
|
|
this.e = z2;
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.u.b
|
|
public final int a() {
|
|
return this.b;
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.u.b
|
|
public final boolean b() {
|
|
return this.d;
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.u.b
|
|
public final r1.b c() {
|
|
return this.c;
|
|
}
|
|
|
|
@Override // java.lang.Comparable
|
|
public final int compareTo(Object obj) {
|
|
return this.b - ((d) obj).b;
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.u.b
|
|
public final r1.c d() {
|
|
return this.c.e();
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.u.b
|
|
public final boolean isPacked() {
|
|
return this.e;
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
@Override // com.fyber.inneractive.sdk.protobuf.u.b
|
|
public final b a(o0.a aVar, o0 o0Var) {
|
|
return ((b) aVar).a((GeneratedMessageLite) o0Var);
|
|
}
|
|
}
|
|
|
|
public static class e<ContainingType extends o0, Type> extends o<ContainingType, Type> {
|
|
public final ContainingType a;
|
|
public final Type b;
|
|
public final o0 c;
|
|
public final d d;
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public e(o0 o0Var, Object obj, o0 o0Var2, d dVar) {
|
|
if (o0Var == 0) {
|
|
throw new IllegalArgumentException("Null containingTypeDefaultInstance");
|
|
}
|
|
if (dVar.c() == r1.b.MESSAGE && o0Var2 == null) {
|
|
throw new IllegalArgumentException("Null messageDefaultInstance");
|
|
}
|
|
this.a = o0Var;
|
|
this.b = obj;
|
|
this.c = o0Var2;
|
|
this.d = dVar;
|
|
}
|
|
}
|
|
|
|
public enum f {
|
|
GET_MEMOIZED_IS_INITIALIZED,
|
|
SET_MEMOIZED_IS_INITIALIZED,
|
|
BUILD_MESSAGE_INFO,
|
|
NEW_MUTABLE_INSTANCE,
|
|
NEW_BUILDER,
|
|
GET_DEFAULT_INSTANCE,
|
|
GET_PARSER
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public static <MessageType extends ExtendableMessage<MessageType, BuilderType>, BuilderType, T> e<MessageType, T> checkIsLite(o<MessageType, T> oVar) {
|
|
oVar.getClass();
|
|
return (e) oVar;
|
|
}
|
|
|
|
private static <T extends GeneratedMessageLite<T, ?>> T checkMessageInitialized(T t) throws z {
|
|
if (t == null || t.isInitialized()) {
|
|
return t;
|
|
}
|
|
j1 newUninitializedMessageException = t.newUninitializedMessageException();
|
|
newUninitializedMessageException.getClass();
|
|
throw new z(newUninitializedMessageException.getMessage());
|
|
}
|
|
|
|
public static y.a emptyBooleanList() {
|
|
return g.d;
|
|
}
|
|
|
|
public static y.b emptyDoubleList() {
|
|
return n.d;
|
|
}
|
|
|
|
public static y.f emptyFloatList() {
|
|
return v.d;
|
|
}
|
|
|
|
public static y.g emptyIntList() {
|
|
return x.d;
|
|
}
|
|
|
|
public static y.i emptyLongList() {
|
|
return f0.d;
|
|
}
|
|
|
|
public static <E> y.j<E> emptyProtobufList() {
|
|
return a1.d;
|
|
}
|
|
|
|
private final void ensureUnknownFieldsInitialized() {
|
|
if (this.unknownFields == l1.f) {
|
|
this.unknownFields = new l1();
|
|
}
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<?, ?>> T getDefaultInstance(Class<T> cls) {
|
|
GeneratedMessageLite<?, ?> generatedMessageLite = defaultInstanceMap.get(cls);
|
|
if (generatedMessageLite == null) {
|
|
try {
|
|
Class.forName(cls.getName(), true, cls.getClassLoader());
|
|
generatedMessageLite = defaultInstanceMap.get(cls);
|
|
} catch (ClassNotFoundException e2) {
|
|
throw new IllegalStateException("Class initialization cannot fail.", e2);
|
|
}
|
|
}
|
|
if (generatedMessageLite == null) {
|
|
try {
|
|
generatedMessageLite = (T) ((GeneratedMessageLite) p1.a.allocateInstance(cls)).getDefaultInstanceForType();
|
|
if (generatedMessageLite == null) {
|
|
throw new IllegalStateException();
|
|
}
|
|
defaultInstanceMap.put(cls, generatedMessageLite);
|
|
} catch (Throwable th) {
|
|
throw new IllegalStateException(th);
|
|
}
|
|
}
|
|
return (T) generatedMessageLite;
|
|
}
|
|
|
|
public static Method getMethodOrDie(Class cls, String str, Class... clsArr) {
|
|
try {
|
|
return cls.getMethod(str, clsArr);
|
|
} catch (NoSuchMethodException e2) {
|
|
throw new RuntimeException("Generated message class \"" + cls.getName() + "\" missing method \"" + str + "\".", e2);
|
|
}
|
|
}
|
|
|
|
public static Object invokeOrDie(Method method, Object obj, Object... objArr) {
|
|
try {
|
|
return method.invoke(obj, objArr);
|
|
} catch (IllegalAccessException e2) {
|
|
throw new RuntimeException("Couldn't use Java reflection to implement protocol message reflection.", e2);
|
|
} catch (InvocationTargetException e3) {
|
|
Throwable cause = e3.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 y.g mutableCopy(y.g gVar) {
|
|
x xVar = (x) gVar;
|
|
int i = xVar.c;
|
|
return xVar.a(i == 0 ? 10 : i * 2);
|
|
}
|
|
|
|
public static Object newMessageInfo(o0 o0Var, String str, Object[] objArr) {
|
|
return new b1(o0Var, str, objArr);
|
|
}
|
|
|
|
public static <ContainingType extends o0, Type> e<ContainingType, Type> newRepeatedGeneratedExtension(ContainingType containingtype, o0 o0Var, y.d<?> dVar, int i, r1.b bVar, boolean z, Class cls) {
|
|
return new e<>(containingtype, Collections.emptyList(), o0Var, new d(dVar, i, bVar, true, z));
|
|
}
|
|
|
|
public static <ContainingType extends o0, Type> e<ContainingType, Type> newSingularGeneratedExtension(ContainingType containingtype, Type type, o0 o0Var, y.d<?> dVar, int i, r1.b bVar, Class cls) {
|
|
return new e<>(containingtype, type, o0Var, new d(dVar, i, bVar, false, false));
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseDelimitedFrom(T t, InputStream inputStream) throws z {
|
|
return (T) checkMessageInitialized(parsePartialDelimitedFrom(t, inputStream, q.a()));
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseFrom(T t, InputStream inputStream) throws z {
|
|
j bVar;
|
|
if (inputStream == null) {
|
|
byte[] bArr = y.b;
|
|
int length = bArr.length;
|
|
bVar = new j.a(bArr, 0, length, false);
|
|
try {
|
|
bVar.d(length);
|
|
} catch (z e2) {
|
|
throw new IllegalArgumentException(e2);
|
|
}
|
|
} else {
|
|
bVar = new j.b(inputStream);
|
|
}
|
|
return (T) checkMessageInitialized(parsePartialFrom(t, bVar, q.a()));
|
|
}
|
|
|
|
private static <T extends GeneratedMessageLite<T, ?>> T parsePartialDelimitedFrom(T t, InputStream inputStream, q qVar) throws z {
|
|
try {
|
|
int read = inputStream.read();
|
|
if (read == -1) {
|
|
return null;
|
|
}
|
|
if ((read & 128) != 0) {
|
|
read &= 127;
|
|
int i = 7;
|
|
while (true) {
|
|
if (i >= 32) {
|
|
while (i < 64) {
|
|
int read2 = inputStream.read();
|
|
if (read2 == -1) {
|
|
throw z.i();
|
|
}
|
|
if ((read2 & 128) != 0) {
|
|
i += 7;
|
|
}
|
|
}
|
|
throw z.e();
|
|
}
|
|
int read3 = inputStream.read();
|
|
if (read3 == -1) {
|
|
throw z.i();
|
|
}
|
|
read |= (read3 & 127) << i;
|
|
if ((read3 & 128) == 0) {
|
|
break;
|
|
}
|
|
i += 7;
|
|
}
|
|
}
|
|
j.b bVar = new j.b(new a.AbstractC0103a.C0104a(read, inputStream));
|
|
T t2 = (T) parsePartialFrom(t, bVar, qVar);
|
|
bVar.a(0);
|
|
return t2;
|
|
} catch (IOException e2) {
|
|
throw new z(e2.getMessage());
|
|
}
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parsePartialFrom(T t, j jVar, q qVar) throws z {
|
|
T t2 = (T) t.dynamicMethod(f.NEW_MUTABLE_INSTANCE);
|
|
try {
|
|
z0 z0Var = z0.c;
|
|
z0Var.getClass();
|
|
d1 a2 = z0Var.a(t2.getClass());
|
|
k kVar = jVar.d;
|
|
if (kVar == null) {
|
|
kVar = new k(jVar);
|
|
}
|
|
a2.a(t2, kVar, qVar);
|
|
a2.a(t2);
|
|
return t2;
|
|
} catch (IOException e2) {
|
|
if (e2.getCause() instanceof z) {
|
|
throw ((z) e2.getCause());
|
|
}
|
|
throw new z(e2.getMessage());
|
|
} catch (RuntimeException e3) {
|
|
if (e3.getCause() instanceof z) {
|
|
throw ((z) e3.getCause());
|
|
}
|
|
throw e3;
|
|
}
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<?, ?>> void registerDefaultInstance(Class<T> cls, T t) {
|
|
defaultInstanceMap.put(cls, t);
|
|
}
|
|
|
|
public Object buildMessageInfo() throws Exception {
|
|
return dynamicMethod(f.BUILD_MESSAGE_INFO);
|
|
}
|
|
|
|
public final <MessageType extends GeneratedMessageLite<MessageType, BuilderType>, BuilderType extends b<MessageType, BuilderType>> BuilderType createBuilder() {
|
|
return (BuilderType) dynamicMethod(f.NEW_BUILDER);
|
|
}
|
|
|
|
public Object dynamicMethod(f fVar, Object obj) {
|
|
return dynamicMethod(fVar, obj, null);
|
|
}
|
|
|
|
public abstract Object dynamicMethod(f fVar, Object obj, Object obj2);
|
|
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (obj == null || getClass() != obj.getClass()) {
|
|
return false;
|
|
}
|
|
z0 z0Var = z0.c;
|
|
z0Var.getClass();
|
|
return z0Var.a(getClass()).b(this, (GeneratedMessageLite) obj);
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.a
|
|
public int getMemoizedSerializedSize() {
|
|
return this.memoizedSerializedSize;
|
|
}
|
|
|
|
public final w0<MessageType> getParserForType() {
|
|
return (w0) dynamicMethod(f.GET_PARSER);
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.p0
|
|
public final boolean isInitialized() {
|
|
return isInitialized(this, true);
|
|
}
|
|
|
|
public void makeImmutable() {
|
|
z0 z0Var = z0.c;
|
|
z0Var.getClass();
|
|
z0Var.a(getClass()).a(this);
|
|
}
|
|
|
|
public void mergeLengthDelimitedField(int i, i iVar) {
|
|
ensureUnknownFieldsInitialized();
|
|
l1 l1Var = this.unknownFields;
|
|
if (!l1Var.e) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
if (i == 0) {
|
|
throw new IllegalArgumentException("Zero is not a valid field number.");
|
|
}
|
|
l1Var.a(r1.a(i, 2), iVar);
|
|
}
|
|
|
|
public final void mergeUnknownFields(l1 l1Var) {
|
|
this.unknownFields = l1.a(this.unknownFields, l1Var);
|
|
}
|
|
|
|
public void mergeVarintField(int i, int i2) {
|
|
ensureUnknownFieldsInitialized();
|
|
l1 l1Var = this.unknownFields;
|
|
if (!l1Var.e) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
if (i == 0) {
|
|
throw new IllegalArgumentException("Zero is not a valid field number.");
|
|
}
|
|
l1Var.a(r1.a(i, 0), Long.valueOf(i2));
|
|
}
|
|
|
|
public boolean parseUnknownField(int i, j jVar) throws IOException {
|
|
int i2 = r1.a;
|
|
if ((i & 7) == 4) {
|
|
return false;
|
|
}
|
|
ensureUnknownFieldsInitialized();
|
|
return this.unknownFields.a(i, jVar);
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.a
|
|
public void setMemoizedSerializedSize(int i) {
|
|
this.memoizedSerializedSize = i;
|
|
}
|
|
|
|
public String toString() {
|
|
String obj = super.toString();
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("# ");
|
|
sb.append(obj);
|
|
q0.a(this, sb, 0);
|
|
return sb.toString();
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.o0
|
|
public void writeTo(l lVar) throws IOException {
|
|
z0 z0Var = z0.c;
|
|
z0Var.getClass();
|
|
d1 a2 = z0Var.a(getClass());
|
|
m mVar = lVar.a;
|
|
if (mVar == null) {
|
|
mVar = new m(lVar);
|
|
}
|
|
a2.a((Object) this, mVar);
|
|
}
|
|
|
|
public static final <T extends GeneratedMessageLite<T, ?>> boolean isInitialized(T t, boolean z) {
|
|
byte byteValue = ((Byte) t.dynamicMethod(f.GET_MEMOIZED_IS_INITIALIZED)).byteValue();
|
|
if (byteValue == 1) {
|
|
return true;
|
|
}
|
|
if (byteValue == 0) {
|
|
return false;
|
|
}
|
|
z0 z0Var = z0.c;
|
|
z0Var.getClass();
|
|
boolean b2 = z0Var.a(t.getClass()).b(t);
|
|
if (z) {
|
|
t.dynamicMethod(f.SET_MEMOIZED_IS_INITIALIZED, b2 ? t : null);
|
|
}
|
|
return b2;
|
|
}
|
|
|
|
public final <MessageType extends GeneratedMessageLite<MessageType, BuilderType>, BuilderType extends b<MessageType, BuilderType>> BuilderType createBuilder(MessageType messagetype) {
|
|
return (BuilderType) createBuilder().a(messagetype);
|
|
}
|
|
|
|
public Object dynamicMethod(f fVar) {
|
|
return dynamicMethod(fVar, null, null);
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.p0
|
|
public final MessageType getDefaultInstanceForType() {
|
|
return (MessageType) dynamicMethod(f.GET_DEFAULT_INSTANCE);
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.o0
|
|
public int getSerializedSize() {
|
|
if (this.memoizedSerializedSize == -1) {
|
|
z0 z0Var = z0.c;
|
|
z0Var.getClass();
|
|
this.memoizedSerializedSize = z0Var.a(getClass()).c(this);
|
|
}
|
|
return this.memoizedSerializedSize;
|
|
}
|
|
|
|
public int hashCode() {
|
|
int i = this.memoizedHashCode;
|
|
if (i != 0) {
|
|
return i;
|
|
}
|
|
z0 z0Var = z0.c;
|
|
z0Var.getClass();
|
|
int d2 = z0Var.a(getClass()).d(this);
|
|
this.memoizedHashCode = d2;
|
|
return d2;
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.o0
|
|
public final BuilderType newBuilderForType() {
|
|
return (BuilderType) dynamicMethod(f.NEW_BUILDER);
|
|
}
|
|
|
|
@Override // com.fyber.inneractive.sdk.protobuf.o0
|
|
public final BuilderType toBuilder() {
|
|
BuilderType buildertype = (BuilderType) dynamicMethod(f.NEW_BUILDER);
|
|
buildertype.a(this);
|
|
return buildertype;
|
|
}
|
|
|
|
public static y.i mutableCopy(y.i iVar) {
|
|
f0 f0Var = (f0) iVar;
|
|
int i = f0Var.c;
|
|
return f0Var.a(i == 0 ? 10 : i * 2);
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseDelimitedFrom(T t, InputStream inputStream, q qVar) throws z {
|
|
return (T) checkMessageInitialized(parsePartialDelimitedFrom(t, inputStream, qVar));
|
|
}
|
|
|
|
public static y.f mutableCopy(y.f fVar) {
|
|
v vVar = (v) fVar;
|
|
int i = vVar.c;
|
|
return vVar.a(i == 0 ? 10 : i * 2);
|
|
}
|
|
|
|
public static y.b mutableCopy(y.b bVar) {
|
|
n nVar = (n) bVar;
|
|
int i = nVar.c;
|
|
return nVar.a(i == 0 ? 10 : i * 2);
|
|
}
|
|
|
|
public static y.a mutableCopy(y.a aVar) {
|
|
g gVar = (g) aVar;
|
|
int i = gVar.c;
|
|
return gVar.a(i == 0 ? 10 : i * 2);
|
|
}
|
|
|
|
public static <E> y.j<E> mutableCopy(y.j<E> jVar) {
|
|
int size = jVar.size();
|
|
return jVar.a(size == 0 ? 10 : size * 2);
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseFrom(T t, InputStream inputStream, q qVar) throws z {
|
|
j bVar;
|
|
if (inputStream == null) {
|
|
byte[] bArr = y.b;
|
|
int length = bArr.length;
|
|
bVar = new j.a(bArr, 0, length, false);
|
|
try {
|
|
bVar.d(length);
|
|
} catch (z e2) {
|
|
throw new IllegalArgumentException(e2);
|
|
}
|
|
} else {
|
|
bVar = new j.b(inputStream);
|
|
}
|
|
return (T) checkMessageInitialized(parsePartialFrom(t, bVar, qVar));
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parsePartialFrom(T t, byte[] bArr, int i, int i2, q qVar) throws z {
|
|
T t2 = (T) t.dynamicMethod(f.NEW_MUTABLE_INSTANCE);
|
|
try {
|
|
z0 z0Var = z0.c;
|
|
z0Var.getClass();
|
|
d1 a2 = z0Var.a(t2.getClass());
|
|
a2.a(t2, bArr, i, i + i2, new e.b(qVar));
|
|
a2.a(t2);
|
|
if (t2.memoizedHashCode == 0) {
|
|
return t2;
|
|
}
|
|
throw new RuntimeException();
|
|
} catch (IOException e2) {
|
|
if (e2.getCause() instanceof z) {
|
|
throw ((z) e2.getCause());
|
|
}
|
|
throw new z(e2.getMessage());
|
|
} catch (IndexOutOfBoundsException unused) {
|
|
throw z.i();
|
|
}
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseFrom(T t, ByteBuffer byteBuffer, q qVar) throws z {
|
|
j.a aVar;
|
|
j cVar;
|
|
if (byteBuffer.hasArray()) {
|
|
byte[] array = byteBuffer.array();
|
|
int position = byteBuffer.position() + byteBuffer.arrayOffset();
|
|
int remaining = byteBuffer.remaining();
|
|
aVar = new j.a(array, position, remaining, false);
|
|
try {
|
|
aVar.d(remaining);
|
|
} catch (z e2) {
|
|
throw new IllegalArgumentException(e2);
|
|
}
|
|
} else {
|
|
if (byteBuffer.isDirect() && p1.d) {
|
|
cVar = new j.c(byteBuffer, false);
|
|
return (T) checkMessageInitialized(parseFrom(t, cVar, qVar));
|
|
}
|
|
int remaining2 = byteBuffer.remaining();
|
|
byte[] bArr = new byte[remaining2];
|
|
byteBuffer.duplicate().get(bArr);
|
|
j.a aVar2 = new j.a(bArr, 0, remaining2, true);
|
|
try {
|
|
aVar2.d(remaining2);
|
|
aVar = aVar2;
|
|
} catch (z e3) {
|
|
throw new IllegalArgumentException(e3);
|
|
}
|
|
}
|
|
cVar = aVar;
|
|
return (T) checkMessageInitialized(parseFrom(t, cVar, qVar));
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parsePartialFrom(T t, j jVar) throws z {
|
|
return (T) parsePartialFrom(t, jVar, q.a());
|
|
}
|
|
|
|
private static <T extends GeneratedMessageLite<T, ?>> T parsePartialFrom(T t, i iVar, q qVar) throws z {
|
|
j g = iVar.g();
|
|
T t2 = (T) parsePartialFrom(t, g, qVar);
|
|
g.a(0);
|
|
return t2;
|
|
}
|
|
|
|
private static <T extends GeneratedMessageLite<T, ?>> T parsePartialFrom(T t, byte[] bArr, q qVar) throws z {
|
|
return (T) checkMessageInitialized(parsePartialFrom(t, bArr, 0, bArr.length, qVar));
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseFrom(T t, ByteBuffer byteBuffer) throws z {
|
|
return (T) parseFrom(t, byteBuffer, q.a());
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseFrom(T t, i iVar) throws z {
|
|
return (T) checkMessageInitialized(parseFrom(t, iVar, q.a()));
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseFrom(T t, i iVar, q qVar) throws z {
|
|
return (T) checkMessageInitialized(parsePartialFrom(t, iVar, qVar));
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseFrom(T t, byte[] bArr) throws z {
|
|
return (T) checkMessageInitialized(parsePartialFrom(t, bArr, 0, bArr.length, q.a()));
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseFrom(T t, byte[] bArr, q qVar) throws z {
|
|
return (T) checkMessageInitialized(parsePartialFrom(t, bArr, 0, bArr.length, qVar));
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseFrom(T t, j jVar) throws z {
|
|
return (T) parseFrom(t, jVar, q.a());
|
|
}
|
|
|
|
public static <T extends GeneratedMessageLite<T, ?>> T parseFrom(T t, j jVar, q qVar) throws z {
|
|
return (T) checkMessageInitialized(parsePartialFrom(t, jVar, qVar));
|
|
}
|
|
}
|