988 lines
46 KiB
Java
988 lines
46 KiB
Java
|
package com.google.firebase.firestore.util;
|
||
|
|
|
||
|
|
import android.net.Uri;
|
||
|
|
import com.google.firebase.Timestamp;
|
||
|
|
import com.google.firebase.firestore.Blob;
|
||
|
|
import com.google.firebase.firestore.DocumentId;
|
||
|
|
import com.google.firebase.firestore.DocumentReference;
|
||
|
|
import com.google.firebase.firestore.Exclude;
|
||
|
|
import com.google.firebase.firestore.FieldValue;
|
||
|
|
import com.google.firebase.firestore.GeoPoint;
|
||
|
|
import com.google.firebase.firestore.IgnoreExtraProperties;
|
||
|
|
import com.google.firebase.firestore.PropertyName;
|
||
|
|
import com.google.firebase.firestore.ServerTimestamp;
|
||
|
|
import com.google.firebase.firestore.ThrowOnExtraProperties;
|
||
|
|
import java.lang.reflect.AccessibleObject;
|
||
|
|
import java.lang.reflect.Constructor;
|
||
|
|
import java.lang.reflect.Field;
|
||
|
|
import java.lang.reflect.GenericArrayType;
|
||
|
|
import java.lang.reflect.Method;
|
||
|
|
import java.lang.reflect.Modifier;
|
||
|
|
import java.lang.reflect.ParameterizedType;
|
||
|
|
import java.lang.reflect.Type;
|
||
|
|
import java.lang.reflect.TypeVariable;
|
||
|
|
import java.lang.reflect.WildcardType;
|
||
|
|
import java.net.URI;
|
||
|
|
import java.net.URL;
|
||
|
|
import java.util.ArrayList;
|
||
|
|
import java.util.Collection;
|
||
|
|
import java.util.Collections;
|
||
|
|
import java.util.Date;
|
||
|
|
import java.util.HashMap;
|
||
|
|
import java.util.HashSet;
|
||
|
|
import java.util.Iterator;
|
||
|
|
import java.util.List;
|
||
|
|
import java.util.Locale;
|
||
|
|
import java.util.Map;
|
||
|
|
import java.util.concurrent.ConcurrentHashMap;
|
||
|
|
import java.util.concurrent.ConcurrentMap;
|
||
|
|
|
||
|
|
/* loaded from: classes2.dex */
|
||
|
|
public class CustomClassMapper {
|
||
|
|
private static final ConcurrentMap<Class<?>, BeanMapper<?>> mappers = new ConcurrentHashMap();
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: private */
|
||
|
|
public static void hardAssert(boolean z, String str) {
|
||
|
|
if (!z) {
|
||
|
|
throw new RuntimeException("Hard assert failed: ".concat(String.valueOf(str)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Object convertToPlainJavaTypes(Object obj) {
|
||
|
|
return serialize(obj);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static <T> T convertToCustomClass(Object obj, Class<T> cls, DocumentReference documentReference) {
|
||
|
|
return (T) deserializeToClass(obj, cls, new DeserializeContext(ErrorPath.EMPTY, documentReference));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static <T> Object serialize(T t) {
|
||
|
|
return serialize(t, ErrorPath.EMPTY);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: private */
|
||
|
|
/* JADX WARN: Multi-variable type inference failed */
|
||
|
|
public static <T> Object serialize(T t, ErrorPath errorPath) {
|
||
|
|
if (errorPath.getLength() > 500) {
|
||
|
|
throw serializeError(errorPath, "Exceeded maximum depth of 500, which likely indicates there's an object cycle");
|
||
|
|
}
|
||
|
|
if (t == 0) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if (t instanceof Number) {
|
||
|
|
if ((t instanceof Long) || (t instanceof Integer) || (t instanceof Double) || (t instanceof Float)) {
|
||
|
|
return t;
|
||
|
|
}
|
||
|
|
throw serializeError(errorPath, String.format("Numbers of type %s are not supported, please use an int, long, float or double", t.getClass().getSimpleName()));
|
||
|
|
}
|
||
|
|
if ((t instanceof String) || (t instanceof Boolean)) {
|
||
|
|
return t;
|
||
|
|
}
|
||
|
|
if (t instanceof Character) {
|
||
|
|
throw serializeError(errorPath, "Characters are not supported, please use Strings");
|
||
|
|
}
|
||
|
|
if (t instanceof Map) {
|
||
|
|
HashMap hashMap = new HashMap();
|
||
|
|
for (Map.Entry entry : ((Map) t).entrySet()) {
|
||
|
|
Object key = entry.getKey();
|
||
|
|
if (key instanceof String) {
|
||
|
|
String str = (String) key;
|
||
|
|
hashMap.put(str, serialize(entry.getValue(), errorPath.child(str)));
|
||
|
|
} else {
|
||
|
|
throw serializeError(errorPath, "Maps with non-string keys are not supported");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return hashMap;
|
||
|
|
}
|
||
|
|
if (t instanceof Collection) {
|
||
|
|
if (t instanceof List) {
|
||
|
|
List list = (List) t;
|
||
|
|
ArrayList arrayList = new ArrayList(list.size());
|
||
|
|
for (int i = 0; i < list.size(); i++) {
|
||
|
|
Object obj = list.get(i);
|
||
|
|
StringBuilder sb = new StringBuilder("[");
|
||
|
|
sb.append(i);
|
||
|
|
sb.append("]");
|
||
|
|
arrayList.add(serialize(obj, errorPath.child(sb.toString())));
|
||
|
|
}
|
||
|
|
return arrayList;
|
||
|
|
}
|
||
|
|
throw serializeError(errorPath, "Serializing Collections is not supported, please use Lists instead");
|
||
|
|
}
|
||
|
|
if (t.getClass().isArray()) {
|
||
|
|
throw serializeError(errorPath, "Serializing Arrays is not supported, please use Lists instead");
|
||
|
|
}
|
||
|
|
if (t instanceof Enum) {
|
||
|
|
String name = ((Enum) t).name();
|
||
|
|
try {
|
||
|
|
return BeanMapper.propertyName(t.getClass().getField(name));
|
||
|
|
} catch (NoSuchFieldException unused) {
|
||
|
|
return name;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ((t instanceof Date) || (t instanceof Timestamp) || (t instanceof GeoPoint) || (t instanceof Blob) || (t instanceof DocumentReference) || (t instanceof FieldValue)) {
|
||
|
|
return t;
|
||
|
|
}
|
||
|
|
if ((t instanceof Uri) || (t instanceof URI) || (t instanceof URL)) {
|
||
|
|
return t.toString();
|
||
|
|
}
|
||
|
|
return loadOrCreateBeanMapperForClass(t.getClass()).serialize(t, errorPath);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: private */
|
||
|
|
public static <T> T deserializeToType(Object obj, Type type, DeserializeContext deserializeContext) {
|
||
|
|
while (obj != null) {
|
||
|
|
if (type instanceof ParameterizedType) {
|
||
|
|
return (T) deserializeToParameterizedType(obj, (ParameterizedType) type, deserializeContext);
|
||
|
|
}
|
||
|
|
if (type instanceof Class) {
|
||
|
|
return (T) deserializeToClass(obj, (Class) type, deserializeContext);
|
||
|
|
}
|
||
|
|
if (type instanceof WildcardType) {
|
||
|
|
WildcardType wildcardType = (WildcardType) type;
|
||
|
|
if (wildcardType.getLowerBounds().length > 0) {
|
||
|
|
throw deserializeError(deserializeContext.errorPath, "Generic lower-bounded wildcard types are not supported");
|
||
|
|
}
|
||
|
|
Type[] upperBounds = wildcardType.getUpperBounds();
|
||
|
|
hardAssert(upperBounds.length > 0, "Unexpected type bounds on wildcard ".concat(String.valueOf(type)));
|
||
|
|
type = upperBounds[0];
|
||
|
|
} else if (type instanceof TypeVariable) {
|
||
|
|
Type[] bounds = ((TypeVariable) type).getBounds();
|
||
|
|
hardAssert(bounds.length > 0, "Unexpected type bounds on type variable ".concat(String.valueOf(type)));
|
||
|
|
type = bounds[0];
|
||
|
|
} else {
|
||
|
|
if (type instanceof GenericArrayType) {
|
||
|
|
throw deserializeError(deserializeContext.errorPath, "Generic Arrays are not supported, please use Lists instead");
|
||
|
|
}
|
||
|
|
throw deserializeError(deserializeContext.errorPath, "Unknown type encountered: ".concat(String.valueOf(type)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX WARN: Multi-variable type inference failed */
|
||
|
|
private static <T> T deserializeToClass(Object obj, Class<T> cls, DeserializeContext deserializeContext) {
|
||
|
|
if (obj == 0) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if (cls.isPrimitive() || Number.class.isAssignableFrom(cls) || Boolean.class.isAssignableFrom(cls) || Character.class.isAssignableFrom(cls)) {
|
||
|
|
return (T) deserializeToPrimitive(obj, cls, deserializeContext);
|
||
|
|
}
|
||
|
|
if (String.class.isAssignableFrom(cls)) {
|
||
|
|
return (T) convertString(obj, deserializeContext);
|
||
|
|
}
|
||
|
|
if (Date.class.isAssignableFrom(cls)) {
|
||
|
|
return (T) convertDate(obj, deserializeContext);
|
||
|
|
}
|
||
|
|
if (Timestamp.class.isAssignableFrom(cls)) {
|
||
|
|
return (T) convertTimestamp(obj, deserializeContext);
|
||
|
|
}
|
||
|
|
if (Blob.class.isAssignableFrom(cls)) {
|
||
|
|
return (T) convertBlob(obj, deserializeContext);
|
||
|
|
}
|
||
|
|
if (GeoPoint.class.isAssignableFrom(cls)) {
|
||
|
|
return (T) convertGeoPoint(obj, deserializeContext);
|
||
|
|
}
|
||
|
|
if (DocumentReference.class.isAssignableFrom(cls)) {
|
||
|
|
return (T) convertDocumentReference(obj, deserializeContext);
|
||
|
|
}
|
||
|
|
if (cls.isArray()) {
|
||
|
|
throw deserializeError(deserializeContext.errorPath, "Converting to Arrays is not supported, please use Lists instead");
|
||
|
|
}
|
||
|
|
if (cls.getTypeParameters().length > 0) {
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Class ");
|
||
|
|
sb.append(cls.getName());
|
||
|
|
sb.append(" has generic type parameters, please use GenericTypeIndicator instead");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
if (cls.equals(Object.class)) {
|
||
|
|
return obj;
|
||
|
|
}
|
||
|
|
if (cls.isEnum()) {
|
||
|
|
return (T) deserializeToEnum(obj, cls, deserializeContext);
|
||
|
|
}
|
||
|
|
return (T) convertBean(obj, cls, deserializeContext);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX WARN: Type inference failed for: r0v5, types: [java.util.AbstractMap, T, java.util.HashMap] */
|
||
|
|
/* JADX WARN: Type inference failed for: r0v8, types: [java.util.List, T, java.util.ArrayList] */
|
||
|
|
private static <T> T deserializeToParameterizedType(Object obj, ParameterizedType parameterizedType, DeserializeContext deserializeContext) {
|
||
|
|
Class cls = (Class) parameterizedType.getRawType();
|
||
|
|
int i = 0;
|
||
|
|
if (List.class.isAssignableFrom(cls)) {
|
||
|
|
Type type = parameterizedType.getActualTypeArguments()[0];
|
||
|
|
if (obj instanceof List) {
|
||
|
|
List list = (List) obj;
|
||
|
|
?? r0 = (T) new ArrayList(list.size());
|
||
|
|
while (i < list.size()) {
|
||
|
|
Object obj2 = list.get(i);
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("[");
|
||
|
|
sb.append(i);
|
||
|
|
sb.append("]");
|
||
|
|
r0.add(deserializeToType(obj2, type, deserializeContext.newInstanceWithErrorPath(errorPath.child(sb.toString()))));
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
return r0;
|
||
|
|
}
|
||
|
|
ErrorPath errorPath2 = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb2 = new StringBuilder("Expected a List, but got a ");
|
||
|
|
sb2.append(obj.getClass());
|
||
|
|
throw deserializeError(errorPath2, sb2.toString());
|
||
|
|
}
|
||
|
|
if (Map.class.isAssignableFrom(cls)) {
|
||
|
|
Type type2 = parameterizedType.getActualTypeArguments()[0];
|
||
|
|
Type type3 = parameterizedType.getActualTypeArguments()[1];
|
||
|
|
if (!type2.equals(String.class)) {
|
||
|
|
throw deserializeError(deserializeContext.errorPath, "Only Maps with string keys are supported, but found Map with key type ".concat(String.valueOf(type2)));
|
||
|
|
}
|
||
|
|
Map<String, Object> expectMap = expectMap(obj, deserializeContext);
|
||
|
|
?? r02 = (T) new HashMap();
|
||
|
|
for (Map.Entry<String, Object> entry : expectMap.entrySet()) {
|
||
|
|
r02.put(entry.getKey(), deserializeToType(entry.getValue(), type3, deserializeContext.newInstanceWithErrorPath(deserializeContext.errorPath.child(entry.getKey()))));
|
||
|
|
}
|
||
|
|
return r02;
|
||
|
|
}
|
||
|
|
if (Collection.class.isAssignableFrom(cls)) {
|
||
|
|
throw deserializeError(deserializeContext.errorPath, "Collections are not supported, please use Lists instead");
|
||
|
|
}
|
||
|
|
Map<String, Object> expectMap2 = expectMap(obj, deserializeContext);
|
||
|
|
BeanMapper loadOrCreateBeanMapperForClass = loadOrCreateBeanMapperForClass(cls);
|
||
|
|
HashMap hashMap = new HashMap();
|
||
|
|
TypeVariable<Class<T>>[] typeParameters = loadOrCreateBeanMapperForClass.clazz.getTypeParameters();
|
||
|
|
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
|
||
|
|
if (actualTypeArguments.length != typeParameters.length) {
|
||
|
|
throw new IllegalStateException("Mismatched lengths for type variables and actual types");
|
||
|
|
}
|
||
|
|
while (i < typeParameters.length) {
|
||
|
|
hashMap.put(typeParameters[i], actualTypeArguments[i]);
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
return (T) loadOrCreateBeanMapperForClass.deserialize(expectMap2, hashMap, deserializeContext);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static <T> T deserializeToPrimitive(Object obj, Class<T> cls, DeserializeContext deserializeContext) {
|
||
|
|
if (Integer.class.isAssignableFrom(cls) || Integer.TYPE.isAssignableFrom(cls)) {
|
||
|
|
return (T) convertInteger(obj, deserializeContext);
|
||
|
|
}
|
||
|
|
if (Boolean.class.isAssignableFrom(cls) || Boolean.TYPE.isAssignableFrom(cls)) {
|
||
|
|
return (T) convertBoolean(obj, deserializeContext);
|
||
|
|
}
|
||
|
|
if (Double.class.isAssignableFrom(cls) || Double.TYPE.isAssignableFrom(cls)) {
|
||
|
|
return (T) convertDouble(obj, deserializeContext);
|
||
|
|
}
|
||
|
|
if (Long.class.isAssignableFrom(cls) || Long.TYPE.isAssignableFrom(cls)) {
|
||
|
|
return (T) convertLong(obj, deserializeContext);
|
||
|
|
}
|
||
|
|
if (Float.class.isAssignableFrom(cls) || Float.TYPE.isAssignableFrom(cls)) {
|
||
|
|
return (T) Float.valueOf(convertDouble(obj, deserializeContext).floatValue());
|
||
|
|
}
|
||
|
|
throw deserializeError(deserializeContext.errorPath, String.format("Deserializing values to %s is not supported", cls.getSimpleName()));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static <T> T deserializeToEnum(Object obj, Class<T> cls, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof String) {
|
||
|
|
String str = (String) obj;
|
||
|
|
for (Field field : cls.getFields()) {
|
||
|
|
if (field.isEnumConstant() && str.equals(BeanMapper.propertyName(field))) {
|
||
|
|
str = field.getName();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
return (T) Enum.valueOf(cls, str);
|
||
|
|
} catch (IllegalArgumentException unused) {
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Could not find enum value of ");
|
||
|
|
sb.append(cls.getName());
|
||
|
|
sb.append(" for value \"");
|
||
|
|
sb.append(str);
|
||
|
|
sb.append("\"");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ErrorPath errorPath2 = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb2 = new StringBuilder("Expected a String while deserializing to enum ");
|
||
|
|
sb2.append(cls);
|
||
|
|
sb2.append(" but got a ");
|
||
|
|
sb2.append(obj.getClass());
|
||
|
|
throw deserializeError(errorPath2, sb2.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static <T> BeanMapper<T> loadOrCreateBeanMapperForClass(Class<T> cls) {
|
||
|
|
ConcurrentMap<Class<?>, BeanMapper<?>> concurrentMap = mappers;
|
||
|
|
BeanMapper<T> beanMapper = (BeanMapper) concurrentMap.get(cls);
|
||
|
|
if (beanMapper != null) {
|
||
|
|
return beanMapper;
|
||
|
|
}
|
||
|
|
BeanMapper<T> beanMapper2 = new BeanMapper<>(cls);
|
||
|
|
concurrentMap.put(cls, beanMapper2);
|
||
|
|
return beanMapper2;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Map<String, Object> expectMap(Object obj, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof Map) {
|
||
|
|
return (Map) obj;
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Expected a Map while deserializing, but got a ");
|
||
|
|
sb.append(obj.getClass());
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Integer convertInteger(Object obj, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof Integer) {
|
||
|
|
return (Integer) obj;
|
||
|
|
}
|
||
|
|
if ((obj instanceof Long) || (obj instanceof Double)) {
|
||
|
|
Number number = (Number) obj;
|
||
|
|
double doubleValue = number.doubleValue();
|
||
|
|
if (doubleValue >= -2.147483648E9d && doubleValue <= 2.147483647E9d) {
|
||
|
|
return Integer.valueOf(number.intValue());
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Numeric value out of 32-bit integer range: ");
|
||
|
|
sb.append(doubleValue);
|
||
|
|
sb.append(". Did you mean to use a long or double instead of an int?");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
ErrorPath errorPath2 = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb2 = new StringBuilder("Failed to convert a value of type ");
|
||
|
|
sb2.append(obj.getClass().getName());
|
||
|
|
sb2.append(" to int");
|
||
|
|
throw deserializeError(errorPath2, sb2.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Long convertLong(Object obj, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof Integer) {
|
||
|
|
return Long.valueOf(((Integer) obj).longValue());
|
||
|
|
}
|
||
|
|
if (obj instanceof Long) {
|
||
|
|
return (Long) obj;
|
||
|
|
}
|
||
|
|
if (obj instanceof Double) {
|
||
|
|
Double d = (Double) obj;
|
||
|
|
if (d.doubleValue() >= -9.223372036854776E18d && d.doubleValue() <= 9.223372036854776E18d) {
|
||
|
|
return Long.valueOf(d.longValue());
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Numeric value out of 64-bit long range: ");
|
||
|
|
sb.append(d);
|
||
|
|
sb.append(". Did you mean to use a double instead of a long?");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
ErrorPath errorPath2 = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb2 = new StringBuilder("Failed to convert a value of type ");
|
||
|
|
sb2.append(obj.getClass().getName());
|
||
|
|
sb2.append(" to long");
|
||
|
|
throw deserializeError(errorPath2, sb2.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Double convertDouble(Object obj, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof Integer) {
|
||
|
|
return Double.valueOf(((Integer) obj).doubleValue());
|
||
|
|
}
|
||
|
|
if (obj instanceof Long) {
|
||
|
|
Long l = (Long) obj;
|
||
|
|
Double valueOf = Double.valueOf(l.doubleValue());
|
||
|
|
if (valueOf.longValue() == l.longValue()) {
|
||
|
|
return valueOf;
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Loss of precision while converting number to double: ");
|
||
|
|
sb.append(obj);
|
||
|
|
sb.append(". Did you mean to use a 64-bit long instead?");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
if (obj instanceof Double) {
|
||
|
|
return (Double) obj;
|
||
|
|
}
|
||
|
|
ErrorPath errorPath2 = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb2 = new StringBuilder("Failed to convert a value of type ");
|
||
|
|
sb2.append(obj.getClass().getName());
|
||
|
|
sb2.append(" to double");
|
||
|
|
throw deserializeError(errorPath2, sb2.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Boolean convertBoolean(Object obj, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof Boolean) {
|
||
|
|
return (Boolean) obj;
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Failed to convert value of type ");
|
||
|
|
sb.append(obj.getClass().getName());
|
||
|
|
sb.append(" to boolean");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static String convertString(Object obj, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof String) {
|
||
|
|
return (String) obj;
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Failed to convert value of type ");
|
||
|
|
sb.append(obj.getClass().getName());
|
||
|
|
sb.append(" to String");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Date convertDate(Object obj, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof Date) {
|
||
|
|
return (Date) obj;
|
||
|
|
}
|
||
|
|
if (obj instanceof Timestamp) {
|
||
|
|
return ((Timestamp) obj).toDate();
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Failed to convert value of type ");
|
||
|
|
sb.append(obj.getClass().getName());
|
||
|
|
sb.append(" to Date");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Timestamp convertTimestamp(Object obj, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof Timestamp) {
|
||
|
|
return (Timestamp) obj;
|
||
|
|
}
|
||
|
|
if (obj instanceof Date) {
|
||
|
|
return new Timestamp((Date) obj);
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Failed to convert value of type ");
|
||
|
|
sb.append(obj.getClass().getName());
|
||
|
|
sb.append(" to Timestamp");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Blob convertBlob(Object obj, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof Blob) {
|
||
|
|
return (Blob) obj;
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Failed to convert value of type ");
|
||
|
|
sb.append(obj.getClass().getName());
|
||
|
|
sb.append(" to Blob");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static GeoPoint convertGeoPoint(Object obj, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof GeoPoint) {
|
||
|
|
return (GeoPoint) obj;
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Failed to convert value of type ");
|
||
|
|
sb.append(obj.getClass().getName());
|
||
|
|
sb.append(" to GeoPoint");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static DocumentReference convertDocumentReference(Object obj, DeserializeContext deserializeContext) {
|
||
|
|
if (obj instanceof DocumentReference) {
|
||
|
|
return (DocumentReference) obj;
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Failed to convert value of type ");
|
||
|
|
sb.append(obj.getClass().getName());
|
||
|
|
sb.append(" to DocumentReference");
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static <T> T convertBean(Object obj, Class<T> cls, DeserializeContext deserializeContext) {
|
||
|
|
BeanMapper loadOrCreateBeanMapperForClass = loadOrCreateBeanMapperForClass(cls);
|
||
|
|
if (obj instanceof Map) {
|
||
|
|
return (T) loadOrCreateBeanMapperForClass.deserialize(expectMap(obj, deserializeContext), deserializeContext);
|
||
|
|
}
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Can't convert object of type ");
|
||
|
|
sb.append(obj.getClass().getName());
|
||
|
|
sb.append(" to type ");
|
||
|
|
sb.append(cls.getName());
|
||
|
|
throw deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static IllegalArgumentException serializeError(ErrorPath errorPath, String str) {
|
||
|
|
String concat = "Could not serialize object. ".concat(String.valueOf(str));
|
||
|
|
if (errorPath.getLength() > 0) {
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
sb.append(concat);
|
||
|
|
sb.append(" (found in field '");
|
||
|
|
sb.append(errorPath.toString());
|
||
|
|
sb.append("')");
|
||
|
|
concat = sb.toString();
|
||
|
|
}
|
||
|
|
return new IllegalArgumentException(concat);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: private */
|
||
|
|
public static RuntimeException deserializeError(ErrorPath errorPath, String str) {
|
||
|
|
String concat = "Could not deserialize object. ".concat(String.valueOf(str));
|
||
|
|
if (errorPath.getLength() > 0) {
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
sb.append(concat);
|
||
|
|
sb.append(" (found in field '");
|
||
|
|
sb.append(errorPath.toString());
|
||
|
|
sb.append("')");
|
||
|
|
concat = sb.toString();
|
||
|
|
}
|
||
|
|
return new RuntimeException(concat);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
||
|
|
/* loaded from: classes2.dex */
|
||
|
|
public static class BeanMapper<T> {
|
||
|
|
private final Class<T> clazz;
|
||
|
|
private final Constructor<T> constructor;
|
||
|
|
private final boolean throwOnUnknownProperties;
|
||
|
|
private final boolean warnOnUnknownProperties;
|
||
|
|
private final Map<String, String> properties = new HashMap();
|
||
|
|
private final Map<String, Method> setters = new HashMap();
|
||
|
|
private final Map<String, Method> getters = new HashMap();
|
||
|
|
private final Map<String, Field> fields = new HashMap();
|
||
|
|
private final HashSet<String> serverTimestamps = new HashSet<>();
|
||
|
|
private final HashSet<String> documentIdPropertyNames = new HashSet<>();
|
||
|
|
|
||
|
|
BeanMapper(Class<T> cls) {
|
||
|
|
Constructor<T> constructor;
|
||
|
|
this.clazz = cls;
|
||
|
|
this.throwOnUnknownProperties = cls.isAnnotationPresent(ThrowOnExtraProperties.class);
|
||
|
|
this.warnOnUnknownProperties = !cls.isAnnotationPresent(IgnoreExtraProperties.class);
|
||
|
|
try {
|
||
|
|
constructor = cls.getDeclaredConstructor(new Class[0]);
|
||
|
|
constructor.setAccessible(true);
|
||
|
|
} catch (NoSuchMethodException unused) {
|
||
|
|
constructor = null;
|
||
|
|
}
|
||
|
|
this.constructor = constructor;
|
||
|
|
for (Method method : cls.getMethods()) {
|
||
|
|
if (shouldIncludeGetter(method)) {
|
||
|
|
String propertyName = propertyName(method);
|
||
|
|
addProperty(propertyName);
|
||
|
|
method.setAccessible(true);
|
||
|
|
if (this.getters.containsKey(propertyName)) {
|
||
|
|
StringBuilder sb = new StringBuilder("Found conflicting getters for name ");
|
||
|
|
sb.append(method.getName());
|
||
|
|
sb.append(" on class ");
|
||
|
|
sb.append(cls.getName());
|
||
|
|
throw new RuntimeException(sb.toString());
|
||
|
|
}
|
||
|
|
this.getters.put(propertyName, method);
|
||
|
|
applyGetterAnnotations(method);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (Field field : cls.getFields()) {
|
||
|
|
if (shouldIncludeField(field)) {
|
||
|
|
addProperty(propertyName(field));
|
||
|
|
applyFieldAnnotations(field);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Class<T> cls2 = cls;
|
||
|
|
do {
|
||
|
|
for (Method method2 : cls2.getDeclaredMethods()) {
|
||
|
|
if (shouldIncludeSetter(method2)) {
|
||
|
|
String propertyName2 = propertyName(method2);
|
||
|
|
String str = this.properties.get(propertyName2.toLowerCase(Locale.US));
|
||
|
|
if (str == null) {
|
||
|
|
continue;
|
||
|
|
} else {
|
||
|
|
if (!str.equals(propertyName2)) {
|
||
|
|
StringBuilder sb2 = new StringBuilder("Found setter on ");
|
||
|
|
sb2.append(cls2.getName());
|
||
|
|
sb2.append(" with invalid case-sensitive name: ");
|
||
|
|
sb2.append(method2.getName());
|
||
|
|
throw new RuntimeException(sb2.toString());
|
||
|
|
}
|
||
|
|
Method method3 = this.setters.get(propertyName2);
|
||
|
|
if (method3 == null) {
|
||
|
|
method2.setAccessible(true);
|
||
|
|
this.setters.put(propertyName2, method2);
|
||
|
|
applySetterAnnotations(method2);
|
||
|
|
} else if (!isSetterOverride(method2, method3)) {
|
||
|
|
if (cls2 == cls) {
|
||
|
|
StringBuilder sb3 = new StringBuilder("Class ");
|
||
|
|
sb3.append(cls.getName());
|
||
|
|
sb3.append(" has multiple setter overloads with name ");
|
||
|
|
sb3.append(method2.getName());
|
||
|
|
throw new RuntimeException(sb3.toString());
|
||
|
|
}
|
||
|
|
StringBuilder sb4 = new StringBuilder("Found conflicting setters with name: ");
|
||
|
|
sb4.append(method2.getName());
|
||
|
|
sb4.append(" (conflicts with ");
|
||
|
|
sb4.append(method3.getName());
|
||
|
|
sb4.append(" defined on ");
|
||
|
|
sb4.append(method3.getDeclaringClass().getName());
|
||
|
|
sb4.append(")");
|
||
|
|
throw new RuntimeException(sb4.toString());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (Field field2 : cls2.getDeclaredFields()) {
|
||
|
|
String propertyName3 = propertyName(field2);
|
||
|
|
if (this.properties.containsKey(propertyName3.toLowerCase(Locale.US)) && !this.fields.containsKey(propertyName3)) {
|
||
|
|
field2.setAccessible(true);
|
||
|
|
this.fields.put(propertyName3, field2);
|
||
|
|
applyFieldAnnotations(field2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
cls2 = cls2.getSuperclass();
|
||
|
|
if (cls2 == null) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} while (!cls2.equals(Object.class));
|
||
|
|
if (this.properties.isEmpty()) {
|
||
|
|
StringBuilder sb5 = new StringBuilder("No properties to serialize found on class ");
|
||
|
|
sb5.append(cls.getName());
|
||
|
|
throw new RuntimeException(sb5.toString());
|
||
|
|
}
|
||
|
|
Iterator<String> it = this.documentIdPropertyNames.iterator();
|
||
|
|
while (it.hasNext()) {
|
||
|
|
String next = it.next();
|
||
|
|
if (!this.setters.containsKey(next) && !this.fields.containsKey(next)) {
|
||
|
|
StringBuilder sb6 = new StringBuilder("@DocumentId is annotated on property ");
|
||
|
|
sb6.append(next);
|
||
|
|
sb6.append(" of class ");
|
||
|
|
sb6.append(cls.getName());
|
||
|
|
sb6.append(" but no field or public setter was found");
|
||
|
|
throw new RuntimeException(sb6.toString());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void addProperty(String str) {
|
||
|
|
String put = this.properties.put(str.toLowerCase(Locale.US), str);
|
||
|
|
if (put == null || str.equals(put)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
StringBuilder sb = new StringBuilder("Found two getters or fields with conflicting case sensitivity for property: ");
|
||
|
|
sb.append(str.toLowerCase(Locale.US));
|
||
|
|
throw new RuntimeException(sb.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
T deserialize(Map<String, Object> map, DeserializeContext deserializeContext) {
|
||
|
|
return deserialize(map, Collections.emptyMap(), deserializeContext);
|
||
|
|
}
|
||
|
|
|
||
|
|
T deserialize(Map<String, Object> map, Map<TypeVariable<Class<T>>, Type> map2, DeserializeContext deserializeContext) {
|
||
|
|
Constructor<T> constructor = this.constructor;
|
||
|
|
if (constructor == null) {
|
||
|
|
ErrorPath errorPath = deserializeContext.errorPath;
|
||
|
|
StringBuilder sb = new StringBuilder("Class ");
|
||
|
|
sb.append(this.clazz.getName());
|
||
|
|
sb.append(" does not define a no-argument constructor. If you are using ProGuard, make sure these constructors are not stripped");
|
||
|
|
throw CustomClassMapper.deserializeError(errorPath, sb.toString());
|
||
|
|
}
|
||
|
|
T t = (T) ApiUtil.newInstance(constructor);
|
||
|
|
HashSet<String> hashSet = new HashSet<>();
|
||
|
|
for (Map.Entry<String, Object> entry : map.entrySet()) {
|
||
|
|
String key = entry.getKey();
|
||
|
|
ErrorPath child = deserializeContext.errorPath.child(key);
|
||
|
|
if (this.setters.containsKey(key)) {
|
||
|
|
Method method = this.setters.get(key);
|
||
|
|
Type[] genericParameterTypes = method.getGenericParameterTypes();
|
||
|
|
if (genericParameterTypes.length != 1) {
|
||
|
|
throw CustomClassMapper.deserializeError(child, "Setter does not have exactly one parameter");
|
||
|
|
}
|
||
|
|
ApiUtil.invoke(method, t, CustomClassMapper.deserializeToType(entry.getValue(), resolveType(genericParameterTypes[0], map2), deserializeContext.newInstanceWithErrorPath(child)));
|
||
|
|
hashSet.add(key);
|
||
|
|
} else if (this.fields.containsKey(key)) {
|
||
|
|
Field field = this.fields.get(key);
|
||
|
|
try {
|
||
|
|
field.set(t, CustomClassMapper.deserializeToType(entry.getValue(), resolveType(field.getGenericType(), map2), deserializeContext.newInstanceWithErrorPath(child)));
|
||
|
|
hashSet.add(key);
|
||
|
|
} catch (IllegalAccessException e) {
|
||
|
|
throw new RuntimeException(e);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
StringBuilder sb2 = new StringBuilder("No setter/field for ");
|
||
|
|
sb2.append(key);
|
||
|
|
sb2.append(" found on class ");
|
||
|
|
sb2.append(this.clazz.getName());
|
||
|
|
String obj = sb2.toString();
|
||
|
|
if (this.properties.containsKey(key.toLowerCase(Locale.US))) {
|
||
|
|
StringBuilder sb3 = new StringBuilder();
|
||
|
|
sb3.append(obj);
|
||
|
|
sb3.append(" (fields/setters are case sensitive!)");
|
||
|
|
obj = sb3.toString();
|
||
|
|
}
|
||
|
|
if (this.throwOnUnknownProperties) {
|
||
|
|
throw new RuntimeException(obj);
|
||
|
|
}
|
||
|
|
if (this.warnOnUnknownProperties) {
|
||
|
|
Logger.warn("CustomClassMapper", "%s", obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
populateDocumentIdProperties(map2, deserializeContext, t, hashSet);
|
||
|
|
return t;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void populateDocumentIdProperties(Map<TypeVariable<Class<T>>, Type> map, DeserializeContext deserializeContext, T t, HashSet<String> hashSet) {
|
||
|
|
Iterator<String> it = this.documentIdPropertyNames.iterator();
|
||
|
|
while (it.hasNext()) {
|
||
|
|
String next = it.next();
|
||
|
|
if (hashSet.contains(next)) {
|
||
|
|
StringBuilder sb = new StringBuilder("'");
|
||
|
|
sb.append(next);
|
||
|
|
sb.append("' was found from document ");
|
||
|
|
sb.append(deserializeContext.documentRef.getPath());
|
||
|
|
sb.append(", cannot apply @DocumentId on this property for class ");
|
||
|
|
sb.append(this.clazz.getName());
|
||
|
|
throw new RuntimeException(sb.toString());
|
||
|
|
}
|
||
|
|
ErrorPath child = deserializeContext.errorPath.child(next);
|
||
|
|
if (this.setters.containsKey(next)) {
|
||
|
|
Method method = this.setters.get(next);
|
||
|
|
Type[] genericParameterTypes = method.getGenericParameterTypes();
|
||
|
|
if (genericParameterTypes.length != 1) {
|
||
|
|
throw CustomClassMapper.deserializeError(child, "Setter does not have exactly one parameter");
|
||
|
|
}
|
||
|
|
if (resolveType(genericParameterTypes[0], map) == String.class) {
|
||
|
|
ApiUtil.invoke(method, t, deserializeContext.documentRef.getId());
|
||
|
|
} else {
|
||
|
|
ApiUtil.invoke(method, t, deserializeContext.documentRef);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
Field field = this.fields.get(next);
|
||
|
|
try {
|
||
|
|
if (field.getType() == String.class) {
|
||
|
|
field.set(t, deserializeContext.documentRef.getId());
|
||
|
|
} else {
|
||
|
|
field.set(t, deserializeContext.documentRef);
|
||
|
|
}
|
||
|
|
} catch (IllegalAccessException e) {
|
||
|
|
throw new RuntimeException(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private Type resolveType(Type type, Map<TypeVariable<Class<T>>, Type> map) {
|
||
|
|
if (!(type instanceof TypeVariable)) {
|
||
|
|
return type;
|
||
|
|
}
|
||
|
|
Type type2 = map.get(type);
|
||
|
|
if (type2 != null) {
|
||
|
|
return type2;
|
||
|
|
}
|
||
|
|
throw new IllegalStateException("Could not resolve type ".concat(String.valueOf(type)));
|
||
|
|
}
|
||
|
|
|
||
|
|
Map<String, Object> serialize(T t, ErrorPath errorPath) {
|
||
|
|
Object obj;
|
||
|
|
Object serialize;
|
||
|
|
if (!this.clazz.isAssignableFrom(t.getClass())) {
|
||
|
|
StringBuilder sb = new StringBuilder("Can't serialize object of class ");
|
||
|
|
sb.append(t.getClass());
|
||
|
|
sb.append(" with BeanMapper for class ");
|
||
|
|
sb.append(this.clazz);
|
||
|
|
throw new IllegalArgumentException(sb.toString());
|
||
|
|
}
|
||
|
|
HashMap hashMap = new HashMap();
|
||
|
|
for (String str : this.properties.values()) {
|
||
|
|
if (!this.documentIdPropertyNames.contains(str)) {
|
||
|
|
if (this.getters.containsKey(str)) {
|
||
|
|
obj = ApiUtil.invoke(this.getters.get(str), t, new Object[0]);
|
||
|
|
} else {
|
||
|
|
Field field = this.fields.get(str);
|
||
|
|
if (field == null) {
|
||
|
|
throw new IllegalStateException("Bean property without field or getter: ".concat(String.valueOf(str)));
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
obj = field.get(t);
|
||
|
|
} catch (IllegalAccessException e) {
|
||
|
|
throw new RuntimeException(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!this.serverTimestamps.contains(str) || obj != null) {
|
||
|
|
serialize = CustomClassMapper.serialize(obj, errorPath.child(str));
|
||
|
|
} else {
|
||
|
|
serialize = FieldValue.serverTimestamp();
|
||
|
|
}
|
||
|
|
hashMap.put(str, serialize);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return hashMap;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void applyFieldAnnotations(Field field) {
|
||
|
|
if (field.isAnnotationPresent(ServerTimestamp.class)) {
|
||
|
|
Class<?> type = field.getType();
|
||
|
|
if (type != Date.class && type != Timestamp.class) {
|
||
|
|
StringBuilder sb = new StringBuilder("Field ");
|
||
|
|
sb.append(field.getName());
|
||
|
|
sb.append(" is annotated with @ServerTimestamp but is ");
|
||
|
|
sb.append(type);
|
||
|
|
sb.append(" instead of Date or Timestamp.");
|
||
|
|
throw new IllegalArgumentException(sb.toString());
|
||
|
|
}
|
||
|
|
this.serverTimestamps.add(propertyName(field));
|
||
|
|
}
|
||
|
|
if (field.isAnnotationPresent(DocumentId.class)) {
|
||
|
|
ensureValidDocumentIdType("Field", "is", field.getType());
|
||
|
|
this.documentIdPropertyNames.add(propertyName(field));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void applyGetterAnnotations(Method method) {
|
||
|
|
if (method.isAnnotationPresent(ServerTimestamp.class)) {
|
||
|
|
Class<?> returnType = method.getReturnType();
|
||
|
|
if (returnType != Date.class && returnType != Timestamp.class) {
|
||
|
|
StringBuilder sb = new StringBuilder("Method ");
|
||
|
|
sb.append(method.getName());
|
||
|
|
sb.append(" is annotated with @ServerTimestamp but returns ");
|
||
|
|
sb.append(returnType);
|
||
|
|
sb.append(" instead of Date or Timestamp.");
|
||
|
|
throw new IllegalArgumentException(sb.toString());
|
||
|
|
}
|
||
|
|
this.serverTimestamps.add(propertyName(method));
|
||
|
|
}
|
||
|
|
if (method.isAnnotationPresent(DocumentId.class)) {
|
||
|
|
ensureValidDocumentIdType("Method", "returns", method.getReturnType());
|
||
|
|
this.documentIdPropertyNames.add(propertyName(method));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void applySetterAnnotations(Method method) {
|
||
|
|
if (method.isAnnotationPresent(ServerTimestamp.class)) {
|
||
|
|
StringBuilder sb = new StringBuilder("Method ");
|
||
|
|
sb.append(method.getName());
|
||
|
|
sb.append(" is annotated with @ServerTimestamp but should not be. @ServerTimestamp can only be applied to fields and getters, not setters.");
|
||
|
|
throw new IllegalArgumentException(sb.toString());
|
||
|
|
}
|
||
|
|
if (method.isAnnotationPresent(DocumentId.class)) {
|
||
|
|
ensureValidDocumentIdType("Method", "accepts", method.getParameterTypes()[0]);
|
||
|
|
this.documentIdPropertyNames.add(propertyName(method));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void ensureValidDocumentIdType(String str, String str2, Type type) {
|
||
|
|
if (type == String.class || type == DocumentReference.class) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
sb.append(str);
|
||
|
|
sb.append(" is annotated with @DocumentId but ");
|
||
|
|
sb.append(str2);
|
||
|
|
sb.append(" ");
|
||
|
|
sb.append(type);
|
||
|
|
sb.append(" instead of String or DocumentReference.");
|
||
|
|
throw new IllegalArgumentException(sb.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static boolean shouldIncludeGetter(Method method) {
|
||
|
|
return ((!method.getName().startsWith("get") && !method.getName().startsWith("is")) || method.getDeclaringClass().equals(Object.class) || !Modifier.isPublic(method.getModifiers()) || Modifier.isStatic(method.getModifiers()) || method.getReturnType().equals(Void.TYPE) || method.getParameterTypes().length != 0 || method.isAnnotationPresent(Exclude.class)) ? false : true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static boolean shouldIncludeSetter(Method method) {
|
||
|
|
return method.getName().startsWith("set") && !method.getDeclaringClass().equals(Object.class) && !Modifier.isStatic(method.getModifiers()) && method.getReturnType().equals(Void.TYPE) && method.getParameterTypes().length == 1 && !method.isAnnotationPresent(Exclude.class);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static boolean shouldIncludeField(Field field) {
|
||
|
|
return (field.getDeclaringClass().equals(Object.class) || !Modifier.isPublic(field.getModifiers()) || Modifier.isStatic(field.getModifiers()) || Modifier.isTransient(field.getModifiers()) || field.isAnnotationPresent(Exclude.class)) ? false : true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static boolean isSetterOverride(Method method, Method method2) {
|
||
|
|
CustomClassMapper.hardAssert(method.getDeclaringClass().isAssignableFrom(method2.getDeclaringClass()), "Expected override from a base class");
|
||
|
|
CustomClassMapper.hardAssert(method.getReturnType().equals(Void.TYPE), "Expected void return type");
|
||
|
|
CustomClassMapper.hardAssert(method2.getReturnType().equals(Void.TYPE), "Expected void return type");
|
||
|
|
Class<?>[] parameterTypes = method.getParameterTypes();
|
||
|
|
Class<?>[] parameterTypes2 = method2.getParameterTypes();
|
||
|
|
CustomClassMapper.hardAssert(parameterTypes.length == 1, "Expected exactly one parameter");
|
||
|
|
CustomClassMapper.hardAssert(parameterTypes2.length == 1, "Expected exactly one parameter");
|
||
|
|
return method.getName().equals(method2.getName()) && parameterTypes[0].equals(parameterTypes2[0]);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: private */
|
||
|
|
public static String propertyName(Field field) {
|
||
|
|
String annotatedName = annotatedName(field);
|
||
|
|
return annotatedName != null ? annotatedName : field.getName();
|
||
|
|
}
|
||
|
|
|
||
|
|
private static String propertyName(Method method) {
|
||
|
|
String annotatedName = annotatedName(method);
|
||
|
|
return annotatedName != null ? annotatedName : serializedName(method.getName());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static String annotatedName(AccessibleObject accessibleObject) {
|
||
|
|
if (accessibleObject.isAnnotationPresent(PropertyName.class)) {
|
||
|
|
return ((PropertyName) accessibleObject.getAnnotation(PropertyName.class)).value();
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static String serializedName(String str) {
|
||
|
|
String[] strArr = {"get", "set", "is"};
|
||
|
|
String str2 = null;
|
||
|
|
for (int i = 0; i < 3; i++) {
|
||
|
|
String str3 = strArr[i];
|
||
|
|
if (str.startsWith(str3)) {
|
||
|
|
str2 = str3;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (str2 == null) {
|
||
|
|
throw new IllegalArgumentException("Unknown Bean prefix for method: ".concat(String.valueOf(str)));
|
||
|
|
}
|
||
|
|
char[] charArray = str.substring(str2.length()).toCharArray();
|
||
|
|
for (int i2 = 0; i2 < charArray.length && Character.isUpperCase(charArray[i2]); i2++) {
|
||
|
|
charArray[i2] = Character.toLowerCase(charArray[i2]);
|
||
|
|
}
|
||
|
|
return new String(charArray);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
||
|
|
/* loaded from: classes2.dex */
|
||
|
|
public static class ErrorPath {
|
||
|
|
static final ErrorPath EMPTY = new ErrorPath(null, null, 0);
|
||
|
|
private final int length;
|
||
|
|
private final String name;
|
||
|
|
private final ErrorPath parent;
|
||
|
|
|
||
|
|
ErrorPath(ErrorPath errorPath, String str, int i) {
|
||
|
|
this.parent = errorPath;
|
||
|
|
this.name = str;
|
||
|
|
this.length = i;
|
||
|
|
}
|
||
|
|
|
||
|
|
ErrorPath child(String str) {
|
||
|
|
return new ErrorPath(this, str, this.length + 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
public String toString() {
|
||
|
|
int i = this.length;
|
||
|
|
if (i == 0) {
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
if (i == 1) {
|
||
|
|
return this.name;
|
||
|
|
}
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
sb.append(this.parent.toString());
|
||
|
|
sb.append(".");
|
||
|
|
sb.append(this.name);
|
||
|
|
return sb.toString();
|
||
|
|
}
|
||
|
|
|
||
|
|
int getLength() {
|
||
|
|
return this.length;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
||
|
|
/* loaded from: classes2.dex */
|
||
|
|
public static class DeserializeContext {
|
||
|
|
final DocumentReference documentRef;
|
||
|
|
final ErrorPath errorPath;
|
||
|
|
|
||
|
|
DeserializeContext(ErrorPath errorPath, DocumentReference documentReference) {
|
||
|
|
this.errorPath = errorPath;
|
||
|
|
this.documentRef = documentReference;
|
||
|
|
}
|
||
|
|
|
||
|
|
DeserializeContext newInstanceWithErrorPath(ErrorPath errorPath) {
|
||
|
|
return new DeserializeContext(errorPath, this.documentRef);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|