Daniel Elliott
c080f0d97f
- Added realracing3-community.apk (71.57 MB) - Removed 32-bit support (armeabi-v7a) - Only includes arm64-v8a libraries - Decompiled source code included - Added README-community.md with analysis
1064 lines
42 KiB
Java
1064 lines
42 KiB
Java
package androidx.datastore.preferences.protobuf;
|
|
|
|
import androidx.datastore.preferences.protobuf.FieldSet.FieldDescriptorLite;
|
|
import androidx.datastore.preferences.protobuf.Internal;
|
|
import androidx.datastore.preferences.protobuf.LazyField;
|
|
import androidx.datastore.preferences.protobuf.MessageLite;
|
|
import androidx.datastore.preferences.protobuf.WireFormat;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
/* loaded from: classes.dex */
|
|
final class FieldSet<T extends FieldDescriptorLite<T>> {
|
|
private static final int DEFAULT_FIELD_MAP_ARRAY_SIZE = 16;
|
|
private static final FieldSet DEFAULT_INSTANCE = new FieldSet(true);
|
|
private final SmallSortedMap<T, Object> fields;
|
|
private boolean hasLazyField;
|
|
private boolean isImmutable;
|
|
|
|
public interface FieldDescriptorLite<T extends FieldDescriptorLite<T>> extends Comparable<T> {
|
|
Internal.EnumLiteMap<?> getEnumType();
|
|
|
|
WireFormat.JavaType getLiteJavaType();
|
|
|
|
WireFormat.FieldType getLiteType();
|
|
|
|
int getNumber();
|
|
|
|
MessageLite.Builder internalMergeFrom(MessageLite.Builder builder, MessageLite messageLite);
|
|
|
|
boolean isPacked();
|
|
|
|
boolean isRepeated();
|
|
}
|
|
|
|
public static <T extends FieldDescriptorLite<T>> FieldSet<T> emptySet() {
|
|
return DEFAULT_INSTANCE;
|
|
}
|
|
|
|
public boolean isImmutable() {
|
|
return this.isImmutable;
|
|
}
|
|
|
|
public /* synthetic */ FieldSet(SmallSortedMap smallSortedMap, AnonymousClass1 anonymousClass1) {
|
|
this(smallSortedMap);
|
|
}
|
|
|
|
private FieldSet() {
|
|
this.fields = SmallSortedMap.newFieldMap(16);
|
|
}
|
|
|
|
private FieldSet(boolean z) {
|
|
this(SmallSortedMap.newFieldMap(0));
|
|
makeImmutable();
|
|
}
|
|
|
|
private FieldSet(SmallSortedMap<T, Object> smallSortedMap) {
|
|
this.fields = smallSortedMap;
|
|
makeImmutable();
|
|
}
|
|
|
|
public static <T extends FieldDescriptorLite<T>> FieldSet<T> newFieldSet() {
|
|
return new FieldSet<>();
|
|
}
|
|
|
|
public static <T extends FieldDescriptorLite<T>> Builder<T> newBuilder() {
|
|
return new Builder<>((AnonymousClass1) null);
|
|
}
|
|
|
|
public boolean isEmpty() {
|
|
return this.fields.isEmpty();
|
|
}
|
|
|
|
public void makeImmutable() {
|
|
if (this.isImmutable) {
|
|
return;
|
|
}
|
|
this.fields.makeImmutable();
|
|
this.isImmutable = true;
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (obj instanceof FieldSet) {
|
|
return this.fields.equals(((FieldSet) obj).fields);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public int hashCode() {
|
|
return this.fields.hashCode();
|
|
}
|
|
|
|
/* renamed from: clone, reason: merged with bridge method [inline-methods] */
|
|
public FieldSet<T> m147clone() {
|
|
FieldSet<T> newFieldSet = newFieldSet();
|
|
for (int i = 0; i < this.fields.getNumArrayEntries(); i++) {
|
|
Map.Entry<T, Object> arrayEntryAt = this.fields.getArrayEntryAt(i);
|
|
newFieldSet.setField(arrayEntryAt.getKey(), arrayEntryAt.getValue());
|
|
}
|
|
for (Map.Entry<T, Object> entry : this.fields.getOverflowEntries()) {
|
|
newFieldSet.setField(entry.getKey(), entry.getValue());
|
|
}
|
|
newFieldSet.hasLazyField = this.hasLazyField;
|
|
return newFieldSet;
|
|
}
|
|
|
|
public void clear() {
|
|
this.fields.clear();
|
|
this.hasLazyField = false;
|
|
}
|
|
|
|
public Map<T, Object> getAllFields() {
|
|
if (!this.hasLazyField) {
|
|
return this.fields.isImmutable() ? this.fields : Collections.unmodifiableMap(this.fields);
|
|
}
|
|
SmallSortedMap cloneAllFieldsMap = cloneAllFieldsMap(this.fields, false);
|
|
if (this.fields.isImmutable()) {
|
|
cloneAllFieldsMap.makeImmutable();
|
|
}
|
|
return cloneAllFieldsMap;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public static <T extends FieldDescriptorLite<T>> SmallSortedMap<T, Object> cloneAllFieldsMap(SmallSortedMap<T, Object> smallSortedMap, boolean z) {
|
|
SmallSortedMap<T, Object> newFieldMap = SmallSortedMap.newFieldMap(16);
|
|
for (int i = 0; i < smallSortedMap.getNumArrayEntries(); i++) {
|
|
cloneFieldEntry(newFieldMap, smallSortedMap.getArrayEntryAt(i), z);
|
|
}
|
|
Iterator<Map.Entry<T, Object>> it = smallSortedMap.getOverflowEntries().iterator();
|
|
while (it.hasNext()) {
|
|
cloneFieldEntry(newFieldMap, it.next(), z);
|
|
}
|
|
return newFieldMap;
|
|
}
|
|
|
|
private static <T extends FieldDescriptorLite<T>> void cloneFieldEntry(Map<T, Object> map, Map.Entry<T, Object> entry, boolean z) {
|
|
T key = entry.getKey();
|
|
Object value = entry.getValue();
|
|
if (value instanceof LazyField) {
|
|
map.put(key, ((LazyField) value).getValue());
|
|
} else if (z && (value instanceof List)) {
|
|
map.put(key, new ArrayList((List) value));
|
|
} else {
|
|
map.put(key, value);
|
|
}
|
|
}
|
|
|
|
public Iterator<Map.Entry<T, Object>> iterator() {
|
|
if (this.hasLazyField) {
|
|
return new LazyField.LazyIterator(this.fields.entrySet().iterator());
|
|
}
|
|
return this.fields.entrySet().iterator();
|
|
}
|
|
|
|
public Iterator<Map.Entry<T, Object>> descendingIterator() {
|
|
if (this.hasLazyField) {
|
|
return new LazyField.LazyIterator(this.fields.descendingEntrySet().iterator());
|
|
}
|
|
return this.fields.descendingEntrySet().iterator();
|
|
}
|
|
|
|
public boolean hasField(T t) {
|
|
if (t.isRepeated()) {
|
|
throw new IllegalArgumentException("hasField() can only be called on non-repeated fields.");
|
|
}
|
|
return this.fields.get(t) != null;
|
|
}
|
|
|
|
public Object getField(T t) {
|
|
Object obj = this.fields.get(t);
|
|
return obj instanceof LazyField ? ((LazyField) obj).getValue() : obj;
|
|
}
|
|
|
|
public void setField(T t, Object obj) {
|
|
if (t.isRepeated()) {
|
|
if (!(obj instanceof List)) {
|
|
throw new IllegalArgumentException("Wrong object type used with protocol message reflection.");
|
|
}
|
|
ArrayList arrayList = new ArrayList();
|
|
arrayList.addAll((List) obj);
|
|
Iterator it = arrayList.iterator();
|
|
while (it.hasNext()) {
|
|
verifyType(t.getLiteType(), it.next());
|
|
}
|
|
obj = arrayList;
|
|
} else {
|
|
verifyType(t.getLiteType(), obj);
|
|
}
|
|
if (obj instanceof LazyField) {
|
|
this.hasLazyField = true;
|
|
}
|
|
this.fields.put((SmallSortedMap<T, Object>) t, (T) obj);
|
|
}
|
|
|
|
public void clearField(T t) {
|
|
this.fields.remove(t);
|
|
if (this.fields.isEmpty()) {
|
|
this.hasLazyField = false;
|
|
}
|
|
}
|
|
|
|
public int getRepeatedFieldCount(T t) {
|
|
if (!t.isRepeated()) {
|
|
throw new IllegalArgumentException("getRepeatedField() can only be called on repeated fields.");
|
|
}
|
|
Object field = getField(t);
|
|
if (field == null) {
|
|
return 0;
|
|
}
|
|
return ((List) field).size();
|
|
}
|
|
|
|
public Object getRepeatedField(T t, int i) {
|
|
if (!t.isRepeated()) {
|
|
throw new IllegalArgumentException("getRepeatedField() can only be called on repeated fields.");
|
|
}
|
|
Object field = getField(t);
|
|
if (field == null) {
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
return ((List) field).get(i);
|
|
}
|
|
|
|
public void setRepeatedField(T t, int i, Object obj) {
|
|
if (!t.isRepeated()) {
|
|
throw new IllegalArgumentException("getRepeatedField() can only be called on repeated fields.");
|
|
}
|
|
Object field = getField(t);
|
|
if (field == null) {
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
verifyType(t.getLiteType(), obj);
|
|
((List) field).set(i, obj);
|
|
}
|
|
|
|
public void addRepeatedField(T t, Object obj) {
|
|
List list;
|
|
if (!t.isRepeated()) {
|
|
throw new IllegalArgumentException("addRepeatedField() can only be called on repeated fields.");
|
|
}
|
|
verifyType(t.getLiteType(), obj);
|
|
Object field = getField(t);
|
|
if (field == null) {
|
|
list = new ArrayList();
|
|
this.fields.put((SmallSortedMap<T, Object>) t, (T) list);
|
|
} else {
|
|
list = (List) field;
|
|
}
|
|
list.add(obj);
|
|
}
|
|
|
|
private void verifyType(WireFormat.FieldType fieldType, Object obj) {
|
|
if (!isValidType(fieldType, obj)) {
|
|
throw new IllegalArgumentException("Wrong object type used with protocol message reflection.");
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public static boolean isValidType(WireFormat.FieldType fieldType, Object obj) {
|
|
Internal.checkNotNull(obj);
|
|
switch (AnonymousClass1.$SwitchMap$com$google$protobuf$WireFormat$JavaType[fieldType.getJavaType().ordinal()]) {
|
|
case 7:
|
|
if (!(obj instanceof ByteString) && !(obj instanceof byte[])) {
|
|
break;
|
|
}
|
|
break;
|
|
case 8:
|
|
if (!(obj instanceof Integer) && !(obj instanceof Internal.EnumLite)) {
|
|
break;
|
|
}
|
|
break;
|
|
case 9:
|
|
if (!(obj instanceof MessageLite) && !(obj instanceof LazyField)) {
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
for (int i = 0; i < this.fields.getNumArrayEntries(); i++) {
|
|
if (!isInitialized(this.fields.getArrayEntryAt(i))) {
|
|
return false;
|
|
}
|
|
}
|
|
Iterator<Map.Entry<T, Object>> it = this.fields.getOverflowEntries().iterator();
|
|
while (it.hasNext()) {
|
|
if (!isInitialized(it.next())) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public static <T extends FieldDescriptorLite<T>> boolean isInitialized(Map.Entry<T, Object> entry) {
|
|
T key = entry.getKey();
|
|
if (key.getLiteJavaType() == WireFormat.JavaType.MESSAGE) {
|
|
if (key.isRepeated()) {
|
|
Iterator it = ((List) entry.getValue()).iterator();
|
|
while (it.hasNext()) {
|
|
if (!((MessageLite) it.next()).isInitialized()) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
Object value = entry.getValue();
|
|
if (value instanceof MessageLite) {
|
|
if (!((MessageLite) value).isInitialized()) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if (value instanceof LazyField) {
|
|
return true;
|
|
}
|
|
throw new IllegalArgumentException("Wrong object type used with protocol message reflection.");
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static int getWireFormatForFieldType(WireFormat.FieldType fieldType, boolean z) {
|
|
if (z) {
|
|
return 2;
|
|
}
|
|
return fieldType.getWireType();
|
|
}
|
|
|
|
public void mergeFrom(FieldSet<T> fieldSet) {
|
|
for (int i = 0; i < fieldSet.fields.getNumArrayEntries(); i++) {
|
|
mergeFromField(fieldSet.fields.getArrayEntryAt(i));
|
|
}
|
|
Iterator<Map.Entry<T, Object>> it = fieldSet.fields.getOverflowEntries().iterator();
|
|
while (it.hasNext()) {
|
|
mergeFromField(it.next());
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public static Object cloneIfMutable(Object obj) {
|
|
if (!(obj instanceof byte[])) {
|
|
return obj;
|
|
}
|
|
byte[] bArr = (byte[]) obj;
|
|
byte[] bArr2 = new byte[bArr.length];
|
|
System.arraycopy(bArr, 0, bArr2, 0, bArr.length);
|
|
return bArr2;
|
|
}
|
|
|
|
private void mergeFromField(Map.Entry<T, Object> entry) {
|
|
T key = entry.getKey();
|
|
Object value = entry.getValue();
|
|
if (value instanceof LazyField) {
|
|
value = ((LazyField) value).getValue();
|
|
}
|
|
if (key.isRepeated()) {
|
|
Object field = getField(key);
|
|
if (field == null) {
|
|
field = new ArrayList();
|
|
}
|
|
Iterator it = ((List) value).iterator();
|
|
while (it.hasNext()) {
|
|
((List) field).add(cloneIfMutable(it.next()));
|
|
}
|
|
this.fields.put((SmallSortedMap<T, Object>) key, (T) field);
|
|
return;
|
|
}
|
|
if (key.getLiteJavaType() == WireFormat.JavaType.MESSAGE) {
|
|
Object field2 = getField(key);
|
|
if (field2 == null) {
|
|
this.fields.put((SmallSortedMap<T, Object>) key, (T) cloneIfMutable(value));
|
|
return;
|
|
} else {
|
|
this.fields.put((SmallSortedMap<T, Object>) key, (T) key.internalMergeFrom(((MessageLite) field2).toBuilder(), (MessageLite) value).build());
|
|
return;
|
|
}
|
|
}
|
|
this.fields.put((SmallSortedMap<T, Object>) key, (T) cloneIfMutable(value));
|
|
}
|
|
|
|
public static Object readPrimitiveField(CodedInputStream codedInputStream, WireFormat.FieldType fieldType, boolean z) throws IOException {
|
|
if (z) {
|
|
return WireFormat.readPrimitiveField(codedInputStream, fieldType, WireFormat.Utf8Validation.STRICT);
|
|
}
|
|
return WireFormat.readPrimitiveField(codedInputStream, fieldType, WireFormat.Utf8Validation.LOOSE);
|
|
}
|
|
|
|
public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
|
|
for (int i = 0; i < this.fields.getNumArrayEntries(); i++) {
|
|
Map.Entry<T, Object> arrayEntryAt = this.fields.getArrayEntryAt(i);
|
|
writeField(arrayEntryAt.getKey(), arrayEntryAt.getValue(), codedOutputStream);
|
|
}
|
|
for (Map.Entry<T, Object> entry : this.fields.getOverflowEntries()) {
|
|
writeField(entry.getKey(), entry.getValue(), codedOutputStream);
|
|
}
|
|
}
|
|
|
|
public void writeMessageSetTo(CodedOutputStream codedOutputStream) throws IOException {
|
|
for (int i = 0; i < this.fields.getNumArrayEntries(); i++) {
|
|
writeMessageSetTo(this.fields.getArrayEntryAt(i), codedOutputStream);
|
|
}
|
|
Iterator<Map.Entry<T, Object>> it = this.fields.getOverflowEntries().iterator();
|
|
while (it.hasNext()) {
|
|
writeMessageSetTo(it.next(), codedOutputStream);
|
|
}
|
|
}
|
|
|
|
private void writeMessageSetTo(Map.Entry<T, Object> entry, CodedOutputStream codedOutputStream) throws IOException {
|
|
T key = entry.getKey();
|
|
if (key.getLiteJavaType() == WireFormat.JavaType.MESSAGE && !key.isRepeated() && !key.isPacked()) {
|
|
Object value = entry.getValue();
|
|
if (value instanceof LazyField) {
|
|
value = ((LazyField) value).getValue();
|
|
}
|
|
codedOutputStream.writeMessageSetExtension(entry.getKey().getNumber(), (MessageLite) value);
|
|
return;
|
|
}
|
|
writeField(key, entry.getValue(), codedOutputStream);
|
|
}
|
|
|
|
public static void writeElement(CodedOutputStream codedOutputStream, WireFormat.FieldType fieldType, int i, Object obj) throws IOException {
|
|
if (fieldType == WireFormat.FieldType.GROUP) {
|
|
codedOutputStream.writeGroup(i, (MessageLite) obj);
|
|
} else {
|
|
codedOutputStream.writeTag(i, getWireFormatForFieldType(fieldType, false));
|
|
writeElementNoTag(codedOutputStream, fieldType, obj);
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.datastore.preferences.protobuf.FieldSet$1, reason: invalid class name */
|
|
public static /* synthetic */ class AnonymousClass1 {
|
|
static final /* synthetic */ int[] $SwitchMap$com$google$protobuf$WireFormat$FieldType;
|
|
static final /* synthetic */ int[] $SwitchMap$com$google$protobuf$WireFormat$JavaType;
|
|
|
|
static {
|
|
int[] iArr = new int[WireFormat.FieldType.values().length];
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType = iArr;
|
|
try {
|
|
iArr[WireFormat.FieldType.DOUBLE.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.FLOAT.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.INT64.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused3) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.UINT64.ordinal()] = 4;
|
|
} catch (NoSuchFieldError unused4) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.INT32.ordinal()] = 5;
|
|
} catch (NoSuchFieldError unused5) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.FIXED64.ordinal()] = 6;
|
|
} catch (NoSuchFieldError unused6) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.FIXED32.ordinal()] = 7;
|
|
} catch (NoSuchFieldError unused7) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.BOOL.ordinal()] = 8;
|
|
} catch (NoSuchFieldError unused8) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.GROUP.ordinal()] = 9;
|
|
} catch (NoSuchFieldError unused9) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.MESSAGE.ordinal()] = 10;
|
|
} catch (NoSuchFieldError unused10) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.STRING.ordinal()] = 11;
|
|
} catch (NoSuchFieldError unused11) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.BYTES.ordinal()] = 12;
|
|
} catch (NoSuchFieldError unused12) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.UINT32.ordinal()] = 13;
|
|
} catch (NoSuchFieldError unused13) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.SFIXED32.ordinal()] = 14;
|
|
} catch (NoSuchFieldError unused14) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.SFIXED64.ordinal()] = 15;
|
|
} catch (NoSuchFieldError unused15) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.SINT32.ordinal()] = 16;
|
|
} catch (NoSuchFieldError unused16) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.SINT64.ordinal()] = 17;
|
|
} catch (NoSuchFieldError unused17) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$FieldType[WireFormat.FieldType.ENUM.ordinal()] = 18;
|
|
} catch (NoSuchFieldError unused18) {
|
|
}
|
|
int[] iArr2 = new int[WireFormat.JavaType.values().length];
|
|
$SwitchMap$com$google$protobuf$WireFormat$JavaType = iArr2;
|
|
try {
|
|
iArr2[WireFormat.JavaType.INT.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused19) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$JavaType[WireFormat.JavaType.LONG.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused20) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$JavaType[WireFormat.JavaType.FLOAT.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused21) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$JavaType[WireFormat.JavaType.DOUBLE.ordinal()] = 4;
|
|
} catch (NoSuchFieldError unused22) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$JavaType[WireFormat.JavaType.BOOLEAN.ordinal()] = 5;
|
|
} catch (NoSuchFieldError unused23) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$JavaType[WireFormat.JavaType.STRING.ordinal()] = 6;
|
|
} catch (NoSuchFieldError unused24) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$JavaType[WireFormat.JavaType.BYTE_STRING.ordinal()] = 7;
|
|
} catch (NoSuchFieldError unused25) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$JavaType[WireFormat.JavaType.ENUM.ordinal()] = 8;
|
|
} catch (NoSuchFieldError unused26) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$google$protobuf$WireFormat$JavaType[WireFormat.JavaType.MESSAGE.ordinal()] = 9;
|
|
} catch (NoSuchFieldError unused27) {
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void writeElementNoTag(CodedOutputStream codedOutputStream, WireFormat.FieldType fieldType, Object obj) throws IOException {
|
|
switch (AnonymousClass1.$SwitchMap$com$google$protobuf$WireFormat$FieldType[fieldType.ordinal()]) {
|
|
case 1:
|
|
codedOutputStream.writeDoubleNoTag(((Double) obj).doubleValue());
|
|
break;
|
|
case 2:
|
|
codedOutputStream.writeFloatNoTag(((Float) obj).floatValue());
|
|
break;
|
|
case 3:
|
|
codedOutputStream.writeInt64NoTag(((Long) obj).longValue());
|
|
break;
|
|
case 4:
|
|
codedOutputStream.writeUInt64NoTag(((Long) obj).longValue());
|
|
break;
|
|
case 5:
|
|
codedOutputStream.writeInt32NoTag(((Integer) obj).intValue());
|
|
break;
|
|
case 6:
|
|
codedOutputStream.writeFixed64NoTag(((Long) obj).longValue());
|
|
break;
|
|
case 7:
|
|
codedOutputStream.writeFixed32NoTag(((Integer) obj).intValue());
|
|
break;
|
|
case 8:
|
|
codedOutputStream.writeBoolNoTag(((Boolean) obj).booleanValue());
|
|
break;
|
|
case 9:
|
|
codedOutputStream.writeGroupNoTag((MessageLite) obj);
|
|
break;
|
|
case 10:
|
|
codedOutputStream.writeMessageNoTag((MessageLite) obj);
|
|
break;
|
|
case 11:
|
|
if (obj instanceof ByteString) {
|
|
codedOutputStream.writeBytesNoTag((ByteString) obj);
|
|
break;
|
|
} else {
|
|
codedOutputStream.writeStringNoTag((String) obj);
|
|
break;
|
|
}
|
|
case 12:
|
|
if (obj instanceof ByteString) {
|
|
codedOutputStream.writeBytesNoTag((ByteString) obj);
|
|
break;
|
|
} else {
|
|
codedOutputStream.writeByteArrayNoTag((byte[]) obj);
|
|
break;
|
|
}
|
|
case 13:
|
|
codedOutputStream.writeUInt32NoTag(((Integer) obj).intValue());
|
|
break;
|
|
case 14:
|
|
codedOutputStream.writeSFixed32NoTag(((Integer) obj).intValue());
|
|
break;
|
|
case 15:
|
|
codedOutputStream.writeSFixed64NoTag(((Long) obj).longValue());
|
|
break;
|
|
case 16:
|
|
codedOutputStream.writeSInt32NoTag(((Integer) obj).intValue());
|
|
break;
|
|
case 17:
|
|
codedOutputStream.writeSInt64NoTag(((Long) obj).longValue());
|
|
break;
|
|
case 18:
|
|
if (obj instanceof Internal.EnumLite) {
|
|
codedOutputStream.writeEnumNoTag(((Internal.EnumLite) obj).getNumber());
|
|
break;
|
|
} else {
|
|
codedOutputStream.writeEnumNoTag(((Integer) obj).intValue());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void writeField(FieldDescriptorLite<?> fieldDescriptorLite, Object obj, CodedOutputStream codedOutputStream) throws IOException {
|
|
WireFormat.FieldType liteType = fieldDescriptorLite.getLiteType();
|
|
int number = fieldDescriptorLite.getNumber();
|
|
if (fieldDescriptorLite.isRepeated()) {
|
|
List list = (List) obj;
|
|
if (fieldDescriptorLite.isPacked()) {
|
|
codedOutputStream.writeTag(number, 2);
|
|
Iterator it = list.iterator();
|
|
int i = 0;
|
|
while (it.hasNext()) {
|
|
i += computeElementSizeNoTag(liteType, it.next());
|
|
}
|
|
codedOutputStream.writeRawVarint32(i);
|
|
Iterator it2 = list.iterator();
|
|
while (it2.hasNext()) {
|
|
writeElementNoTag(codedOutputStream, liteType, it2.next());
|
|
}
|
|
return;
|
|
}
|
|
Iterator it3 = list.iterator();
|
|
while (it3.hasNext()) {
|
|
writeElement(codedOutputStream, liteType, number, it3.next());
|
|
}
|
|
return;
|
|
}
|
|
if (obj instanceof LazyField) {
|
|
writeElement(codedOutputStream, liteType, number, ((LazyField) obj).getValue());
|
|
} else {
|
|
writeElement(codedOutputStream, liteType, number, obj);
|
|
}
|
|
}
|
|
|
|
public int getSerializedSize() {
|
|
int i = 0;
|
|
for (int i2 = 0; i2 < this.fields.getNumArrayEntries(); i2++) {
|
|
Map.Entry<T, Object> arrayEntryAt = this.fields.getArrayEntryAt(i2);
|
|
i += computeFieldSize(arrayEntryAt.getKey(), arrayEntryAt.getValue());
|
|
}
|
|
for (Map.Entry<T, Object> entry : this.fields.getOverflowEntries()) {
|
|
i += computeFieldSize(entry.getKey(), entry.getValue());
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public int getMessageSetSerializedSize() {
|
|
int i = 0;
|
|
for (int i2 = 0; i2 < this.fields.getNumArrayEntries(); i2++) {
|
|
i += getMessageSetSerializedSize(this.fields.getArrayEntryAt(i2));
|
|
}
|
|
Iterator<Map.Entry<T, Object>> it = this.fields.getOverflowEntries().iterator();
|
|
while (it.hasNext()) {
|
|
i += getMessageSetSerializedSize(it.next());
|
|
}
|
|
return i;
|
|
}
|
|
|
|
private int getMessageSetSerializedSize(Map.Entry<T, Object> entry) {
|
|
T key = entry.getKey();
|
|
Object value = entry.getValue();
|
|
if (key.getLiteJavaType() == WireFormat.JavaType.MESSAGE && !key.isRepeated() && !key.isPacked()) {
|
|
if (value instanceof LazyField) {
|
|
return CodedOutputStream.computeLazyFieldMessageSetExtensionSize(entry.getKey().getNumber(), (LazyField) value);
|
|
}
|
|
return CodedOutputStream.computeMessageSetExtensionSize(entry.getKey().getNumber(), (MessageLite) value);
|
|
}
|
|
return computeFieldSize(key, value);
|
|
}
|
|
|
|
public static int computeElementSize(WireFormat.FieldType fieldType, int i, Object obj) {
|
|
int computeTagSize = CodedOutputStream.computeTagSize(i);
|
|
if (fieldType == WireFormat.FieldType.GROUP) {
|
|
computeTagSize *= 2;
|
|
}
|
|
return computeTagSize + computeElementSizeNoTag(fieldType, obj);
|
|
}
|
|
|
|
public static int computeElementSizeNoTag(WireFormat.FieldType fieldType, Object obj) {
|
|
switch (AnonymousClass1.$SwitchMap$com$google$protobuf$WireFormat$FieldType[fieldType.ordinal()]) {
|
|
case 1:
|
|
return CodedOutputStream.computeDoubleSizeNoTag(((Double) obj).doubleValue());
|
|
case 2:
|
|
return CodedOutputStream.computeFloatSizeNoTag(((Float) obj).floatValue());
|
|
case 3:
|
|
return CodedOutputStream.computeInt64SizeNoTag(((Long) obj).longValue());
|
|
case 4:
|
|
return CodedOutputStream.computeUInt64SizeNoTag(((Long) obj).longValue());
|
|
case 5:
|
|
return CodedOutputStream.computeInt32SizeNoTag(((Integer) obj).intValue());
|
|
case 6:
|
|
return CodedOutputStream.computeFixed64SizeNoTag(((Long) obj).longValue());
|
|
case 7:
|
|
return CodedOutputStream.computeFixed32SizeNoTag(((Integer) obj).intValue());
|
|
case 8:
|
|
return CodedOutputStream.computeBoolSizeNoTag(((Boolean) obj).booleanValue());
|
|
case 9:
|
|
return CodedOutputStream.computeGroupSizeNoTag((MessageLite) obj);
|
|
case 10:
|
|
if (obj instanceof LazyField) {
|
|
return CodedOutputStream.computeLazyFieldSizeNoTag((LazyField) obj);
|
|
}
|
|
return CodedOutputStream.computeMessageSizeNoTag((MessageLite) obj);
|
|
case 11:
|
|
if (obj instanceof ByteString) {
|
|
return CodedOutputStream.computeBytesSizeNoTag((ByteString) obj);
|
|
}
|
|
return CodedOutputStream.computeStringSizeNoTag((String) obj);
|
|
case 12:
|
|
if (obj instanceof ByteString) {
|
|
return CodedOutputStream.computeBytesSizeNoTag((ByteString) obj);
|
|
}
|
|
return CodedOutputStream.computeByteArraySizeNoTag((byte[]) obj);
|
|
case 13:
|
|
return CodedOutputStream.computeUInt32SizeNoTag(((Integer) obj).intValue());
|
|
case 14:
|
|
return CodedOutputStream.computeSFixed32SizeNoTag(((Integer) obj).intValue());
|
|
case 15:
|
|
return CodedOutputStream.computeSFixed64SizeNoTag(((Long) obj).longValue());
|
|
case 16:
|
|
return CodedOutputStream.computeSInt32SizeNoTag(((Integer) obj).intValue());
|
|
case 17:
|
|
return CodedOutputStream.computeSInt64SizeNoTag(((Long) obj).longValue());
|
|
case 18:
|
|
if (obj instanceof Internal.EnumLite) {
|
|
return CodedOutputStream.computeEnumSizeNoTag(((Internal.EnumLite) obj).getNumber());
|
|
}
|
|
return CodedOutputStream.computeEnumSizeNoTag(((Integer) obj).intValue());
|
|
default:
|
|
throw new RuntimeException("There is no way to get here, but the compiler thinks otherwise.");
|
|
}
|
|
}
|
|
|
|
public static int computeFieldSize(FieldDescriptorLite<?> fieldDescriptorLite, Object obj) {
|
|
WireFormat.FieldType liteType = fieldDescriptorLite.getLiteType();
|
|
int number = fieldDescriptorLite.getNumber();
|
|
if (fieldDescriptorLite.isRepeated()) {
|
|
int i = 0;
|
|
if (fieldDescriptorLite.isPacked()) {
|
|
Iterator it = ((List) obj).iterator();
|
|
while (it.hasNext()) {
|
|
i += computeElementSizeNoTag(liteType, it.next());
|
|
}
|
|
return CodedOutputStream.computeTagSize(number) + i + CodedOutputStream.computeRawVarint32Size(i);
|
|
}
|
|
Iterator it2 = ((List) obj).iterator();
|
|
while (it2.hasNext()) {
|
|
i += computeElementSize(liteType, number, it2.next());
|
|
}
|
|
return i;
|
|
}
|
|
return computeElementSize(liteType, number, obj);
|
|
}
|
|
|
|
public static final class Builder<T extends FieldDescriptorLite<T>> {
|
|
private SmallSortedMap<T, Object> fields;
|
|
private boolean hasLazyField;
|
|
private boolean hasNestedBuilders;
|
|
private boolean isMutable;
|
|
|
|
public /* synthetic */ Builder(AnonymousClass1 anonymousClass1) {
|
|
this();
|
|
}
|
|
|
|
private Builder() {
|
|
this(SmallSortedMap.newFieldMap(16));
|
|
}
|
|
|
|
private Builder(SmallSortedMap<T, Object> smallSortedMap) {
|
|
this.fields = smallSortedMap;
|
|
this.isMutable = true;
|
|
}
|
|
|
|
public FieldSet<T> build() {
|
|
if (this.fields.isEmpty()) {
|
|
return FieldSet.emptySet();
|
|
}
|
|
this.isMutable = false;
|
|
SmallSortedMap<T, Object> smallSortedMap = this.fields;
|
|
if (this.hasNestedBuilders) {
|
|
smallSortedMap = FieldSet.cloneAllFieldsMap(smallSortedMap, false);
|
|
replaceBuilders(smallSortedMap);
|
|
}
|
|
FieldSet<T> fieldSet = new FieldSet<>(smallSortedMap, null);
|
|
((FieldSet) fieldSet).hasLazyField = this.hasLazyField;
|
|
return fieldSet;
|
|
}
|
|
|
|
private static <T extends FieldDescriptorLite<T>> void replaceBuilders(SmallSortedMap<T, Object> smallSortedMap) {
|
|
for (int i = 0; i < smallSortedMap.getNumArrayEntries(); i++) {
|
|
replaceBuilders(smallSortedMap.getArrayEntryAt(i));
|
|
}
|
|
Iterator<Map.Entry<T, Object>> it = smallSortedMap.getOverflowEntries().iterator();
|
|
while (it.hasNext()) {
|
|
replaceBuilders(it.next());
|
|
}
|
|
}
|
|
|
|
private static <T extends FieldDescriptorLite<T>> void replaceBuilders(Map.Entry<T, Object> entry) {
|
|
entry.setValue(replaceBuilders(entry.getKey(), entry.getValue()));
|
|
}
|
|
|
|
private static <T extends FieldDescriptorLite<T>> Object replaceBuilders(T t, Object obj) {
|
|
if (obj == null || t.getLiteJavaType() != WireFormat.JavaType.MESSAGE) {
|
|
return obj;
|
|
}
|
|
if (t.isRepeated()) {
|
|
if (!(obj instanceof List)) {
|
|
throw new IllegalStateException("Repeated field should contains a List but actually contains type: " + obj.getClass());
|
|
}
|
|
List list = (List) obj;
|
|
for (int i = 0; i < list.size(); i++) {
|
|
Object obj2 = list.get(i);
|
|
Object replaceBuilder = replaceBuilder(obj2);
|
|
if (replaceBuilder != obj2) {
|
|
if (list == obj) {
|
|
list = new ArrayList(list);
|
|
}
|
|
list.set(i, replaceBuilder);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
return replaceBuilder(obj);
|
|
}
|
|
|
|
private static Object replaceBuilder(Object obj) {
|
|
return obj instanceof MessageLite.Builder ? ((MessageLite.Builder) obj).build() : obj;
|
|
}
|
|
|
|
public static <T extends FieldDescriptorLite<T>> Builder<T> fromFieldSet(FieldSet<T> fieldSet) {
|
|
Builder<T> builder = new Builder<>(FieldSet.cloneAllFieldsMap(((FieldSet) fieldSet).fields, true));
|
|
((Builder) builder).hasLazyField = ((FieldSet) fieldSet).hasLazyField;
|
|
return builder;
|
|
}
|
|
|
|
public Map<T, Object> getAllFields() {
|
|
if (!this.hasLazyField) {
|
|
return this.fields.isImmutable() ? this.fields : Collections.unmodifiableMap(this.fields);
|
|
}
|
|
SmallSortedMap cloneAllFieldsMap = FieldSet.cloneAllFieldsMap(this.fields, false);
|
|
if (this.fields.isImmutable()) {
|
|
cloneAllFieldsMap.makeImmutable();
|
|
} else {
|
|
replaceBuilders(cloneAllFieldsMap);
|
|
}
|
|
return cloneAllFieldsMap;
|
|
}
|
|
|
|
public boolean hasField(T t) {
|
|
if (t.isRepeated()) {
|
|
throw new IllegalArgumentException("hasField() can only be called on non-repeated fields.");
|
|
}
|
|
return this.fields.get(t) != null;
|
|
}
|
|
|
|
public Object getField(T t) {
|
|
return replaceBuilders(t, getFieldAllowBuilders(t));
|
|
}
|
|
|
|
public Object getFieldAllowBuilders(T t) {
|
|
Object obj = this.fields.get(t);
|
|
return obj instanceof LazyField ? ((LazyField) obj).getValue() : obj;
|
|
}
|
|
|
|
private void ensureIsMutable() {
|
|
if (this.isMutable) {
|
|
return;
|
|
}
|
|
this.fields = FieldSet.cloneAllFieldsMap(this.fields, true);
|
|
this.isMutable = true;
|
|
}
|
|
|
|
public void setField(T t, Object obj) {
|
|
ensureIsMutable();
|
|
if (t.isRepeated()) {
|
|
if (!(obj instanceof List)) {
|
|
throw new IllegalArgumentException("Wrong object type used with protocol message reflection.");
|
|
}
|
|
ArrayList arrayList = new ArrayList();
|
|
arrayList.addAll((List) obj);
|
|
for (Object obj2 : arrayList) {
|
|
verifyType(t.getLiteType(), obj2);
|
|
this.hasNestedBuilders = this.hasNestedBuilders || (obj2 instanceof MessageLite.Builder);
|
|
}
|
|
obj = arrayList;
|
|
} else {
|
|
verifyType(t.getLiteType(), obj);
|
|
}
|
|
if (obj instanceof LazyField) {
|
|
this.hasLazyField = true;
|
|
}
|
|
this.hasNestedBuilders = this.hasNestedBuilders || (obj instanceof MessageLite.Builder);
|
|
this.fields.put((SmallSortedMap<T, Object>) t, (T) obj);
|
|
}
|
|
|
|
public void clearField(T t) {
|
|
ensureIsMutable();
|
|
this.fields.remove(t);
|
|
if (this.fields.isEmpty()) {
|
|
this.hasLazyField = false;
|
|
}
|
|
}
|
|
|
|
public int getRepeatedFieldCount(T t) {
|
|
if (!t.isRepeated()) {
|
|
throw new IllegalArgumentException("getRepeatedField() can only be called on repeated fields.");
|
|
}
|
|
Object field = getField(t);
|
|
if (field == null) {
|
|
return 0;
|
|
}
|
|
return ((List) field).size();
|
|
}
|
|
|
|
public Object getRepeatedField(T t, int i) {
|
|
if (this.hasNestedBuilders) {
|
|
ensureIsMutable();
|
|
}
|
|
return replaceBuilder(getRepeatedFieldAllowBuilders(t, i));
|
|
}
|
|
|
|
public Object getRepeatedFieldAllowBuilders(T t, int i) {
|
|
if (!t.isRepeated()) {
|
|
throw new IllegalArgumentException("getRepeatedField() can only be called on repeated fields.");
|
|
}
|
|
Object fieldAllowBuilders = getFieldAllowBuilders(t);
|
|
if (fieldAllowBuilders == null) {
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
return ((List) fieldAllowBuilders).get(i);
|
|
}
|
|
|
|
public void setRepeatedField(T t, int i, Object obj) {
|
|
ensureIsMutable();
|
|
if (!t.isRepeated()) {
|
|
throw new IllegalArgumentException("getRepeatedField() can only be called on repeated fields.");
|
|
}
|
|
this.hasNestedBuilders = this.hasNestedBuilders || (obj instanceof MessageLite.Builder);
|
|
Object field = getField(t);
|
|
if (field == null) {
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
verifyType(t.getLiteType(), obj);
|
|
((List) field).set(i, obj);
|
|
}
|
|
|
|
public void addRepeatedField(T t, Object obj) {
|
|
List list;
|
|
ensureIsMutable();
|
|
if (!t.isRepeated()) {
|
|
throw new IllegalArgumentException("addRepeatedField() can only be called on repeated fields.");
|
|
}
|
|
this.hasNestedBuilders = this.hasNestedBuilders || (obj instanceof MessageLite.Builder);
|
|
verifyType(t.getLiteType(), obj);
|
|
Object field = getField(t);
|
|
if (field == null) {
|
|
list = new ArrayList();
|
|
this.fields.put((SmallSortedMap<T, Object>) t, (T) list);
|
|
} else {
|
|
list = (List) field;
|
|
}
|
|
list.add(obj);
|
|
}
|
|
|
|
private static void verifyType(WireFormat.FieldType fieldType, Object obj) {
|
|
if (FieldSet.isValidType(fieldType, obj)) {
|
|
return;
|
|
}
|
|
if (fieldType.getJavaType() != WireFormat.JavaType.MESSAGE || !(obj instanceof MessageLite.Builder)) {
|
|
throw new IllegalArgumentException("Wrong object type used with protocol message reflection.");
|
|
}
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
for (int i = 0; i < this.fields.getNumArrayEntries(); i++) {
|
|
if (!FieldSet.isInitialized(this.fields.getArrayEntryAt(i))) {
|
|
return false;
|
|
}
|
|
}
|
|
Iterator<Map.Entry<T, Object>> it = this.fields.getOverflowEntries().iterator();
|
|
while (it.hasNext()) {
|
|
if (!FieldSet.isInitialized(it.next())) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void mergeFrom(FieldSet<T> fieldSet) {
|
|
ensureIsMutable();
|
|
for (int i = 0; i < ((FieldSet) fieldSet).fields.getNumArrayEntries(); i++) {
|
|
mergeFromField(((FieldSet) fieldSet).fields.getArrayEntryAt(i));
|
|
}
|
|
Iterator it = ((FieldSet) fieldSet).fields.getOverflowEntries().iterator();
|
|
while (it.hasNext()) {
|
|
mergeFromField((Map.Entry) it.next());
|
|
}
|
|
}
|
|
|
|
private void mergeFromField(Map.Entry<T, Object> entry) {
|
|
T key = entry.getKey();
|
|
Object value = entry.getValue();
|
|
if (value instanceof LazyField) {
|
|
value = ((LazyField) value).getValue();
|
|
}
|
|
if (key.isRepeated()) {
|
|
Object field = getField(key);
|
|
if (field == null) {
|
|
field = new ArrayList();
|
|
}
|
|
Iterator it = ((List) value).iterator();
|
|
while (it.hasNext()) {
|
|
((List) field).add(FieldSet.cloneIfMutable(it.next()));
|
|
}
|
|
this.fields.put((SmallSortedMap<T, Object>) key, (T) field);
|
|
return;
|
|
}
|
|
if (key.getLiteJavaType() != WireFormat.JavaType.MESSAGE) {
|
|
this.fields.put((SmallSortedMap<T, Object>) key, (T) FieldSet.cloneIfMutable(value));
|
|
return;
|
|
}
|
|
Object field2 = getField(key);
|
|
if (field2 == null) {
|
|
this.fields.put((SmallSortedMap<T, Object>) key, (T) FieldSet.cloneIfMutable(value));
|
|
} else if (field2 instanceof MessageLite.Builder) {
|
|
key.internalMergeFrom((MessageLite.Builder) field2, (MessageLite) value);
|
|
} else {
|
|
this.fields.put((SmallSortedMap<T, Object>) key, (T) key.internalMergeFrom(((MessageLite) field2).toBuilder(), (MessageLite) value).build());
|
|
}
|
|
}
|
|
}
|
|
}
|