智能工厂.apk(点击下载) / BasicDeserializerFactory.java
package com.fasterxml.jackson.databind.deser;
import com.fasterxml.jackson.core.JsonLocation;
import com.fasterxml.jackson.databind.AbstractTypeResolver;
import com.fasterxml.jackson.databind.AnnotationIntrospector;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.KeyDeserializer;
import com.fasterxml.jackson.databind.PropertyMetadata;
import com.fasterxml.jackson.databind.PropertyName;
import com.fasterxml.jackson.databind.cfg.DeserializerFactoryConfig;
import com.fasterxml.jackson.databind.cfg.HandlerInstantiator;
import com.fasterxml.jackson.databind.deser.impl.CreatorCollector;
import com.fasterxml.jackson.databind.deser.std.ArrayBlockingQueueDeserializer;
import com.fasterxml.jackson.databind.deser.std.CollectionDeserializer;
import com.fasterxml.jackson.databind.deser.std.DateDeserializers;
import com.fasterxml.jackson.databind.deser.std.EnumDeserializer;
import com.fasterxml.jackson.databind.deser.std.EnumMapDeserializer;
import com.fasterxml.jackson.databind.deser.std.EnumSetDeserializer;
import com.fasterxml.jackson.databind.deser.std.JdkDeserializers;
import com.fasterxml.jackson.databind.deser.std.JsonLocationInstantiator;
import com.fasterxml.jackson.databind.deser.std.JsonNodeDeserializer;
import com.fasterxml.jackson.databind.deser.std.MapDeserializer;
import com.fasterxml.jackson.databind.deser.std.NumberDeserializers;
import com.fasterxml.jackson.databind.deser.std.ObjectArrayDeserializer;
import com.fasterxml.jackson.databind.deser.std.PrimitiveArrayDeserializers;
import com.fasterxml.jackson.databind.deser.std.StdKeyDeserializers;
import com.fasterxml.jackson.databind.deser.std.StringArrayDeserializer;
import com.fasterxml.jackson.databind.deser.std.StringCollectionDeserializer;
import com.fasterxml.jackson.databind.deser.std.StringDeserializer;
import com.fasterxml.jackson.databind.deser.std.TokenBufferDeserializer;
import com.fasterxml.jackson.databind.deser.std.UntypedObjectDeserializer;
import com.fasterxml.jackson.databind.introspect.Annotated;
import com.fasterxml.jackson.databind.introspect.AnnotatedClass;
import com.fasterxml.jackson.databind.introspect.AnnotatedConstructor;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
import com.fasterxml.jackson.databind.introspect.AnnotatedParameter;
import com.fasterxml.jackson.databind.introspect.AnnotatedWithParams;
import com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition;
import com.fasterxml.jackson.databind.introspect.VisibilityChecker;
import com.fasterxml.jackson.databind.jsontype.NamedType;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder;
import com.fasterxml.jackson.databind.type.ArrayType;
import com.fasterxml.jackson.databind.type.CollectionLikeType;
import com.fasterxml.jackson.databind.type.CollectionType;
import com.fasterxml.jackson.databind.type.MapLikeType;
import com.fasterxml.jackson.databind.type.MapType;
import com.fasterxml.jackson.databind.type.TypeFactory;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.EnumResolver;
import com.fasterxml.jackson.databind.util.TokenBuffer;
import java.io.PrintStream;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
public abstract class BasicDeserializerFactory extends DeserializerFactory implements Serializable {
private static final Class<?> CLASS_CHAR_BUFFER = CharSequence.class;
private static final Class<?> CLASS_ITERABLE = Iterable.class;
private static final Class<?> CLASS_OBJECT = Object.class;
private static final Class<?> CLASS_STRING = String.class;
protected static final PropertyName UNWRAPPED_CREATOR_PARAM_NAME = new PropertyName("@JsonUnwrapped");
static final HashMap<String, Class<? extends Collection>> _collectionFallbacks = new HashMap<>();
static final HashMap<String, Class<? extends Map>> _mapFallbacks = new HashMap<>();
protected final DeserializerFactoryConfig _factoryConfig;
/* access modifiers changed from: protected */
public abstract DeserializerFactory withConfig(DeserializerFactoryConfig deserializerFactoryConfig);
static {
_mapFallbacks.put(Map.class.getName(), LinkedHashMap.class);
_mapFallbacks.put(ConcurrentMap.class.getName(), ConcurrentHashMap.class);
_mapFallbacks.put(SortedMap.class.getName(), TreeMap.class);
_mapFallbacks.put("java.util.NavigableMap", TreeMap.class);
try {
_mapFallbacks.put(ConcurrentNavigableMap.class.getName(), ConcurrentSkipListMap.class);
} catch (Throwable th) {
PrintStream printStream = System.err;
printStream.println("Problems with (optional) types: " + th);
}
_collectionFallbacks.put(Collection.class.getName(), ArrayList.class);
_collectionFallbacks.put(List.class.getName(), ArrayList.class);
_collectionFallbacks.put(Set.class.getName(), HashSet.class);
_collectionFallbacks.put(SortedSet.class.getName(), TreeSet.class);
_collectionFallbacks.put(Queue.class.getName(), LinkedList.class);
_collectionFallbacks.put("java.util.Deque", LinkedList.class);
_collectionFallbacks.put("java.util.NavigableSet", TreeSet.class);
}
protected BasicDeserializerFactory(DeserializerFactoryConfig deserializerFactoryConfig) {
this._factoryConfig = deserializerFactoryConfig;
}
public DeserializerFactoryConfig getFactoryConfig() {
return this._factoryConfig;
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public final DeserializerFactory withAdditionalDeserializers(Deserializers deserializers) {
return withConfig(this._factoryConfig.withAdditionalDeserializers(deserializers));
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public final DeserializerFactory withAdditionalKeyDeserializers(KeyDeserializers keyDeserializers) {
return withConfig(this._factoryConfig.withAdditionalKeyDeserializers(keyDeserializers));
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public final DeserializerFactory withDeserializerModifier(BeanDeserializerModifier beanDeserializerModifier) {
return withConfig(this._factoryConfig.withDeserializerModifier(beanDeserializerModifier));
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public final DeserializerFactory withAbstractTypeResolver(AbstractTypeResolver abstractTypeResolver) {
return withConfig(this._factoryConfig.withAbstractTypeResolver(abstractTypeResolver));
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public final DeserializerFactory withValueInstantiators(ValueInstantiators valueInstantiators) {
return withConfig(this._factoryConfig.withValueInstantiators(valueInstantiators));
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public JavaType mapAbstractType(DeserializationConfig deserializationConfig, JavaType javaType) throws JsonMappingException {
JavaType _mapAbstractType2;
while (true) {
_mapAbstractType2 = _mapAbstractType2(deserializationConfig, javaType);
if (_mapAbstractType2 == null) {
return javaType;
}
Class<?> rawClass = javaType.getRawClass();
Class<?> rawClass2 = _mapAbstractType2.getRawClass();
if (rawClass == rawClass2 || !rawClass.isAssignableFrom(rawClass2)) {
} else {
javaType = _mapAbstractType2;
}
}
throw new IllegalArgumentException("Invalid abstract type resolution from " + javaType + " to " + _mapAbstractType2 + ": latter is not a subtype of former");
}
private JavaType _mapAbstractType2(DeserializationConfig deserializationConfig, JavaType javaType) throws JsonMappingException {
Class<?> rawClass = javaType.getRawClass();
if (!this._factoryConfig.hasAbstractTypeResolvers()) {
return null;
}
for (AbstractTypeResolver abstractTypeResolver : this._factoryConfig.abstractTypeResolvers()) {
JavaType findTypeMapping = abstractTypeResolver.findTypeMapping(deserializationConfig, javaType);
if (!(findTypeMapping == null || findTypeMapping.getRawClass() == rawClass)) {
return findTypeMapping;
}
}
return null;
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public ValueInstantiator findValueInstantiator(DeserializationContext deserializationContext, BeanDescription beanDescription) throws JsonMappingException {
DeserializationConfig config = deserializationContext.getConfig();
AnnotatedClass classInfo = beanDescription.getClassInfo();
Object findValueInstantiator = deserializationContext.getAnnotationIntrospector().findValueInstantiator(classInfo);
ValueInstantiator _valueInstantiatorInstance = findValueInstantiator != null ? _valueInstantiatorInstance(config, classInfo, findValueInstantiator) : null;
if (_valueInstantiatorInstance == null && (_valueInstantiatorInstance = _findStdValueInstantiator(config, beanDescription)) == null) {
_valueInstantiatorInstance = _constructDefaultValueInstantiator(deserializationContext, beanDescription);
}
if (this._factoryConfig.hasValueInstantiators()) {
for (ValueInstantiators valueInstantiators : this._factoryConfig.valueInstantiators()) {
_valueInstantiatorInstance = valueInstantiators.findValueInstantiator(config, beanDescription, _valueInstantiatorInstance);
if (_valueInstantiatorInstance == null) {
throw new JsonMappingException("Broken registered ValueInstantiators (of type " + valueInstantiators.getClass().getName() + "): returned null ValueInstantiator");
}
}
}
if (_valueInstantiatorInstance.getIncompleteParameter() == null) {
return _valueInstantiatorInstance;
}
AnnotatedParameter incompleteParameter = _valueInstantiatorInstance.getIncompleteParameter();
AnnotatedWithParams owner = incompleteParameter.getOwner();
throw new IllegalArgumentException("Argument #" + incompleteParameter.getIndex() + " of constructor " + owner + " has no property name annotation; must have name when multiple-parameter constructor annotated as Creator");
}
private ValueInstantiator _findStdValueInstantiator(DeserializationConfig deserializationConfig, BeanDescription beanDescription) throws JsonMappingException {
if (beanDescription.getBeanClass() == JsonLocation.class) {
return new JsonLocationInstantiator();
}
return null;
}
/* access modifiers changed from: protected */
public ValueInstantiator _constructDefaultValueInstantiator(DeserializationContext deserializationContext, BeanDescription beanDescription) throws JsonMappingException {
CreatorCollector creatorCollector = new CreatorCollector(beanDescription, deserializationContext.canOverrideAccessModifiers());
AnnotationIntrospector annotationIntrospector = deserializationContext.getAnnotationIntrospector();
DeserializationConfig config = deserializationContext.getConfig();
VisibilityChecker<?> findAutoDetectVisibility = annotationIntrospector.findAutoDetectVisibility(beanDescription.getClassInfo(), config.getDefaultVisibilityChecker());
_addDeserializerFactoryMethods(deserializationContext, beanDescription, findAutoDetectVisibility, annotationIntrospector, creatorCollector);
if (beanDescription.getType().isConcrete()) {
_addDeserializerConstructors(deserializationContext, beanDescription, findAutoDetectVisibility, annotationIntrospector, creatorCollector);
}
return creatorCollector.constructValueInstantiator(config);
}
public ValueInstantiator _valueInstantiatorInstance(DeserializationConfig deserializationConfig, Annotated annotated, Object obj) throws JsonMappingException {
ValueInstantiator valueInstantiatorInstance;
if (obj == null) {
return null;
}
if (obj instanceof ValueInstantiator) {
return (ValueInstantiator) obj;
}
if (obj instanceof Class) {
Class<?> cls = (Class) obj;
if (ClassUtil.isBogusClass(cls)) {
return null;
}
if (ValueInstantiator.class.isAssignableFrom(cls)) {
HandlerInstantiator handlerInstantiator = deserializationConfig.getHandlerInstantiator();
if (handlerInstantiator == null || (valueInstantiatorInstance = handlerInstantiator.valueInstantiatorInstance(deserializationConfig, annotated, cls)) == null) {
return (ValueInstantiator) ClassUtil.createInstance(cls, deserializationConfig.canOverrideAccessModifiers());
}
return valueInstantiatorInstance;
}
throw new IllegalStateException("AnnotationIntrospector returned Class " + cls.getName() + "; expected Class<ValueInstantiator>");
}
throw new IllegalStateException("AnnotationIntrospector returned key deserializer definition of type " + obj.getClass().getName() + "; expected type KeyDeserializer or Class<KeyDeserializer> instead");
}
/* access modifiers changed from: protected */
public void _addDeserializerConstructors(DeserializationContext deserializationContext, BeanDescription beanDescription, VisibilityChecker<?> visibilityChecker, AnnotationIntrospector annotationIntrospector, CreatorCollector creatorCollector) throws JsonMappingException {
VisibilityChecker<?> visibilityChecker2;
boolean z;
AnnotatedConstructor findDefaultConstructor = beanDescription.findDefaultConstructor();
if (findDefaultConstructor != null && (!creatorCollector.hasDefaultCreator() || annotationIntrospector.hasCreatorAnnotation(findDefaultConstructor))) {
creatorCollector.setDefaultCreator(findDefaultConstructor);
}
AnnotatedConstructor annotatedConstructor = null;
PropertyName[] propertyNameArr = null;
for (BeanPropertyDefinition beanPropertyDefinition : beanDescription.findProperties()) {
if (beanPropertyDefinition.getConstructorParameter() != null) {
AnnotatedParameter constructorParameter = beanPropertyDefinition.getConstructorParameter();
AnnotatedWithParams owner = constructorParameter.getOwner();
if (owner instanceof AnnotatedConstructor) {
if (annotatedConstructor == null) {
annotatedConstructor = (AnnotatedConstructor) owner;
propertyNameArr = new PropertyName[annotatedConstructor.getParameterCount()];
}
propertyNameArr[constructorParameter.getIndex()] = beanPropertyDefinition.getFullName();
}
}
}
Iterator<AnnotatedConstructor> it = beanDescription.getConstructors().iterator();
while (it.hasNext()) {
AnnotatedConstructor next = it.next();
int parameterCount = next.getParameterCount();
if (annotationIntrospector.hasCreatorAnnotation(next) || next == annotatedConstructor) {
visibilityChecker2 = visibilityChecker;
z = true;
} else {
visibilityChecker2 = visibilityChecker;
z = false;
}
boolean isCreatorVisible = visibilityChecker2.isCreatorVisible(next);
if (parameterCount == 1) {
_handleSingleArgumentConstructor(deserializationContext, beanDescription, visibilityChecker, annotationIntrospector, creatorCollector, next, z, isCreatorVisible, next == annotatedConstructor ? propertyNameArr[0] : null);
} else if (z || isCreatorVisible) {
CreatorProperty[] creatorPropertyArr = new CreatorProperty[parameterCount];
int i = 0;
int i2 = 0;
AnnotatedParameter annotatedParameter = null;
for (int i3 = 0; i3 < parameterCount; i3++) {
AnnotatedParameter parameter = next.getParameter(i3);
PropertyName propertyName = next == annotatedConstructor ? propertyNameArr[i3] : null;
PropertyName _findParamName = propertyName == null ? _findParamName(parameter, annotationIntrospector) : propertyName;
Object findInjectableValueId = annotationIntrospector.findInjectableValueId(parameter);
if (_findParamName != null && _findParamName.hasSimpleName()) {
i++;
creatorPropertyArr[i3] = constructCreatorProperty(deserializationContext, beanDescription, _findParamName, i3, parameter, findInjectableValueId);
} else if (findInjectableValueId != null) {
i2++;
creatorPropertyArr[i3] = constructCreatorProperty(deserializationContext, beanDescription, _findParamName, i3, parameter, findInjectableValueId);
} else if (annotationIntrospector.findUnwrappingNameTransformer(parameter) != null) {
creatorPropertyArr[i3] = constructCreatorProperty(deserializationContext, beanDescription, UNWRAPPED_CREATOR_PARAM_NAME, i3, parameter, null);
i++;
} else if (annotatedParameter == null) {
annotatedParameter = parameter;
}
}
if (z || i > 0 || i2 > 0) {
if (i + i2 == parameterCount) {
creatorCollector.addPropertyCreator(next, creatorPropertyArr);
} else if (i == 0 && i2 + 1 == parameterCount) {
creatorCollector.addDelegatingCreator(next, creatorPropertyArr);
} else {
creatorCollector.addIncompeteParameter(annotatedParameter);
}
}
}
}
}
/* access modifiers changed from: protected */
public boolean _handleSingleArgumentConstructor(DeserializationContext deserializationContext, BeanDescription beanDescription, VisibilityChecker<?> visibilityChecker, AnnotationIntrospector annotationIntrospector, CreatorCollector creatorCollector, AnnotatedConstructor annotatedConstructor, boolean z, boolean z2, PropertyName propertyName) throws JsonMappingException {
AnnotatedParameter parameter = annotatedConstructor.getParameter(0);
PropertyName _findParamName = propertyName == null ? _findParamName(parameter, annotationIntrospector) : propertyName;
Object findInjectableValueId = annotationIntrospector.findInjectableValueId(parameter);
if (findInjectableValueId != null || (_findParamName != null && _findParamName.hasSimpleName())) {
creatorCollector.addPropertyCreator(annotatedConstructor, new CreatorProperty[]{constructCreatorProperty(deserializationContext, beanDescription, _findParamName, 0, parameter, findInjectableValueId)});
return true;
}
Class<?> rawParameterType = annotatedConstructor.getRawParameterType(0);
if (rawParameterType == String.class) {
if (z || z2) {
creatorCollector.addStringCreator(annotatedConstructor);
}
return true;
} else if (rawParameterType == Integer.TYPE || rawParameterType == Integer.class) {
if (z || z2) {
creatorCollector.addIntCreator(annotatedConstructor);
}
return true;
} else if (rawParameterType == Long.TYPE || rawParameterType == Long.class) {
if (z || z2) {
creatorCollector.addLongCreator(annotatedConstructor);
}
return true;
} else if (rawParameterType == Double.TYPE || rawParameterType == Double.class) {
if (z || z2) {
creatorCollector.addDoubleCreator(annotatedConstructor);
}
return true;
} else if (rawParameterType == Boolean.TYPE || rawParameterType == Boolean.class) {
if (z || z2) {
creatorCollector.addBooleanCreator(annotatedConstructor);
}
return true;
} else if (!z) {
return false;
} else {
creatorCollector.addDelegatingCreator(annotatedConstructor, null);
return true;
}
}
/* access modifiers changed from: protected */
public void _addDeserializerFactoryMethods(DeserializationContext deserializationContext, BeanDescription beanDescription, VisibilityChecker<?> visibilityChecker, AnnotationIntrospector annotationIntrospector, CreatorCollector creatorCollector) throws JsonMappingException {
int i;
DeserializationConfig config = deserializationContext.getConfig();
for (AnnotatedMethod annotatedMethod : beanDescription.getFactoryMethods()) {
boolean hasCreatorAnnotation = annotationIntrospector.hasCreatorAnnotation(annotatedMethod);
int parameterCount = annotatedMethod.getParameterCount();
if (parameterCount != 0) {
if (parameterCount == 1) {
AnnotatedParameter parameter = annotatedMethod.getParameter(0);
PropertyName _findParamName = _findParamName(parameter, annotationIntrospector);
String simpleName = _findParamName == null ? null : _findParamName.getSimpleName();
if (annotationIntrospector.findInjectableValueId(parameter) == null && (simpleName == null || simpleName.length() == 0)) {
_handleSingleArgumentFactory(config, beanDescription, visibilityChecker, annotationIntrospector, creatorCollector, annotatedMethod, hasCreatorAnnotation);
}
} else if (!annotationIntrospector.hasCreatorAnnotation(annotatedMethod)) {
continue;
}
CreatorProperty[] creatorPropertyArr = new CreatorProperty[parameterCount];
AnnotatedParameter annotatedParameter = null;
int i2 = 0;
int i3 = 0;
int i4 = 0;
while (i2 < parameterCount) {
AnnotatedParameter parameter2 = annotatedMethod.getParameter(i2);
PropertyName _findParamName2 = _findParamName(parameter2, annotationIntrospector);
Object findInjectableValueId = annotationIntrospector.findInjectableValueId(parameter2);
if (_findParamName2 == null || !_findParamName2.hasSimpleName()) {
i = i2;
if (findInjectableValueId != null) {
i4++;
creatorPropertyArr[i] = constructCreatorProperty(deserializationContext, beanDescription, _findParamName2, i, parameter2, findInjectableValueId);
} else if (annotationIntrospector.findUnwrappingNameTransformer(parameter2) != null) {
creatorPropertyArr[i] = constructCreatorProperty(deserializationContext, beanDescription, UNWRAPPED_CREATOR_PARAM_NAME, i, parameter2, null);
i3++;
} else if (annotatedParameter == null) {
annotatedParameter = parameter2;
}
} else {
i3++;
i = i2;
creatorPropertyArr[i] = constructCreatorProperty(deserializationContext, beanDescription, _findParamName2, i2, parameter2, findInjectableValueId);
}
i2 = i + 1;
}
if (hasCreatorAnnotation || i3 > 0 || i4 > 0) {
if (i3 + i4 == parameterCount) {
creatorCollector.addPropertyCreator(annotatedMethod, creatorPropertyArr);
} else if (i3 == 0 && i4 + 1 == parameterCount) {
creatorCollector.addDelegatingCreator(annotatedMethod, creatorPropertyArr);
} else {
throw new IllegalArgumentException("Argument #" + annotatedParameter.getIndex() + " of factory method " + annotatedMethod + " has no property name annotation; must have name when multiple-parameter constructor annotated as Creator");
}
}
} else if (hasCreatorAnnotation) {
creatorCollector.setDefaultCreator(annotatedMethod);
}
}
}
/* access modifiers changed from: protected */
public boolean _handleSingleArgumentFactory(DeserializationConfig deserializationConfig, BeanDescription beanDescription, VisibilityChecker<?> visibilityChecker, AnnotationIntrospector annotationIntrospector, CreatorCollector creatorCollector, AnnotatedMethod annotatedMethod, boolean z) throws JsonMappingException {
Class<?> rawParameterType = annotatedMethod.getRawParameterType(0);
if (rawParameterType == String.class) {
if (z || visibilityChecker.isCreatorVisible(annotatedMethod)) {
creatorCollector.addStringCreator(annotatedMethod);
}
return true;
} else if (rawParameterType == Integer.TYPE || rawParameterType == Integer.class) {
if (z || visibilityChecker.isCreatorVisible(annotatedMethod)) {
creatorCollector.addIntCreator(annotatedMethod);
}
return true;
} else if (rawParameterType == Long.TYPE || rawParameterType == Long.class) {
if (z || visibilityChecker.isCreatorVisible(annotatedMethod)) {
creatorCollector.addLongCreator(annotatedMethod);
}
return true;
} else if (rawParameterType == Double.TYPE || rawParameterType == Double.class) {
if (z || visibilityChecker.isCreatorVisible(annotatedMethod)) {
creatorCollector.addDoubleCreator(annotatedMethod);
}
return true;
} else if (rawParameterType == Boolean.TYPE || rawParameterType == Boolean.class) {
if (z || visibilityChecker.isCreatorVisible(annotatedMethod)) {
creatorCollector.addBooleanCreator(annotatedMethod);
}
return true;
} else if (!annotationIntrospector.hasCreatorAnnotation(annotatedMethod)) {
return false;
} else {
creatorCollector.addDelegatingCreator(annotatedMethod, null);
return true;
}
}
/* access modifiers changed from: protected */
public CreatorProperty constructCreatorProperty(DeserializationContext deserializationContext, BeanDescription beanDescription, PropertyName propertyName, int i, AnnotatedParameter annotatedParameter, Object obj) throws JsonMappingException {
Boolean bool;
String str;
DeserializationConfig config = deserializationContext.getConfig();
AnnotationIntrospector annotationIntrospector = deserializationContext.getAnnotationIntrospector();
Integer num = null;
if (annotationIntrospector == null) {
bool = null;
} else {
bool = annotationIntrospector.hasRequiredMarker(annotatedParameter);
}
boolean z = bool != null && bool.booleanValue();
if (annotationIntrospector == null) {
str = null;
} else {
str = annotationIntrospector.findPropertyDescription(annotatedParameter);
}
if (annotationIntrospector != null) {
num = annotationIntrospector.findPropertyIndex(annotatedParameter);
}
PropertyMetadata construct = PropertyMetadata.construct(z, str, num);
JavaType constructType = config.getTypeFactory().constructType(annotatedParameter.getParameterType(), beanDescription.bindingsForBeanType());
BeanProperty.Std std = new BeanProperty.Std(propertyName, constructType, annotationIntrospector.findWrapperName(annotatedParameter), beanDescription.getClassAnnotations(), annotatedParameter, construct);
JavaType resolveType = resolveType(deserializationContext, beanDescription, constructType, annotatedParameter);
if (resolveType != constructType) {
std = std.withType(resolveType);
}
JsonDeserializer<?> findDeserializerFromAnnotation = findDeserializerFromAnnotation(deserializationContext, annotatedParameter);
JavaType modifyTypeByAnnotation = modifyTypeByAnnotation(deserializationContext, annotatedParameter, resolveType);
TypeDeserializer typeDeserializer = (TypeDeserializer) modifyTypeByAnnotation.getTypeHandler();
CreatorProperty creatorProperty = new CreatorProperty(propertyName, modifyTypeByAnnotation, std.getWrapperName(), typeDeserializer == null ? findTypeDeserializer(config, modifyTypeByAnnotation) : typeDeserializer, beanDescription.getClassAnnotations(), annotatedParameter, i, obj, construct);
return findDeserializerFromAnnotation != null ? creatorProperty.withValueDeserializer(deserializationContext.handlePrimaryContextualization(findDeserializerFromAnnotation, creatorProperty)) : creatorProperty;
}
/* access modifiers changed from: protected */
public PropertyName _findParamName(AnnotatedParameter annotatedParameter, AnnotationIntrospector annotationIntrospector) {
if (annotatedParameter == null || annotationIntrospector == null) {
return null;
}
PropertyName findNameForDeserialization = annotationIntrospector.findNameForDeserialization(annotatedParameter);
if (findNameForDeserialization != null) {
return findNameForDeserialization;
}
String findImplicitPropertyName = annotationIntrospector.findImplicitPropertyName(annotatedParameter);
if (findImplicitPropertyName == null || findImplicitPropertyName.isEmpty()) {
return null;
}
return new PropertyName(findImplicitPropertyName);
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public JsonDeserializer<?> createArrayDeserializer(DeserializationContext deserializationContext, ArrayType arrayType, BeanDescription beanDescription) throws JsonMappingException {
DeserializationConfig config = deserializationContext.getConfig();
JavaType contentType = arrayType.getContentType();
JsonDeserializer<?> jsonDeserializer = (JsonDeserializer) contentType.getValueHandler();
TypeDeserializer typeDeserializer = (TypeDeserializer) contentType.getTypeHandler();
TypeDeserializer findTypeDeserializer = typeDeserializer == null ? findTypeDeserializer(config, contentType) : typeDeserializer;
JsonDeserializer<?> _findCustomArrayDeserializer = _findCustomArrayDeserializer(arrayType, config, beanDescription, findTypeDeserializer, jsonDeserializer);
if (_findCustomArrayDeserializer == null) {
if (jsonDeserializer == null) {
Class<?> rawClass = contentType.getRawClass();
if (contentType.isPrimitive()) {
return PrimitiveArrayDeserializers.forType(rawClass);
}
if (rawClass == String.class) {
return StringArrayDeserializer.instance;
}
}
_findCustomArrayDeserializer = new ObjectArrayDeserializer(arrayType, jsonDeserializer, findTypeDeserializer);
}
if (this._factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier beanDeserializerModifier : this._factoryConfig.deserializerModifiers()) {
_findCustomArrayDeserializer = beanDeserializerModifier.modifyArrayDeserializer(config, arrayType, beanDescription, _findCustomArrayDeserializer);
}
}
return _findCustomArrayDeserializer;
}
/* access modifiers changed from: protected */
public JsonDeserializer<?> _findCustomArrayDeserializer(ArrayType arrayType, DeserializationConfig deserializationConfig, BeanDescription beanDescription, TypeDeserializer typeDeserializer, JsonDeserializer<?> jsonDeserializer) throws JsonMappingException {
for (Deserializers deserializers : this._factoryConfig.deserializers()) {
JsonDeserializer<?> findArrayDeserializer = deserializers.findArrayDeserializer(arrayType, deserializationConfig, beanDescription, typeDeserializer, jsonDeserializer);
if (findArrayDeserializer != null) {
return findArrayDeserializer;
}
}
return null;
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public JsonDeserializer<?> createCollectionDeserializer(DeserializationContext deserializationContext, CollectionType collectionType, BeanDescription beanDescription) throws JsonMappingException {
CollectionType collectionType2;
JavaType contentType = collectionType.getContentType();
JsonDeserializer<?> jsonDeserializer = (JsonDeserializer) contentType.getValueHandler();
DeserializationConfig config = deserializationContext.getConfig();
TypeDeserializer typeDeserializer = (TypeDeserializer) contentType.getTypeHandler();
TypeDeserializer findTypeDeserializer = typeDeserializer == null ? findTypeDeserializer(config, contentType) : typeDeserializer;
JsonDeserializer<?> _findCustomCollectionDeserializer = _findCustomCollectionDeserializer(collectionType, config, beanDescription, findTypeDeserializer, jsonDeserializer);
if (_findCustomCollectionDeserializer == null) {
Class<?> rawClass = collectionType.getRawClass();
if (jsonDeserializer == null && EnumSet.class.isAssignableFrom(rawClass)) {
_findCustomCollectionDeserializer = new EnumSetDeserializer(contentType, null);
}
}
if (_findCustomCollectionDeserializer == null) {
if (collectionType.isInterface() || collectionType.isAbstract()) {
collectionType2 = _mapAbstractCollectionType(collectionType, config);
if (collectionType2 != null) {
beanDescription = config.introspectForCreation(collectionType2);
} else if (collectionType.getTypeHandler() != null) {
_findCustomCollectionDeserializer = AbstractDeserializer.constructForNonPOJO(beanDescription);
collectionType2 = collectionType;
} else {
throw new IllegalArgumentException("Can not find a deserializer for non-concrete Collection type " + collectionType);
}
} else {
collectionType2 = collectionType;
}
if (_findCustomCollectionDeserializer == null) {
ValueInstantiator findValueInstantiator = findValueInstantiator(deserializationContext, beanDescription);
if (!findValueInstantiator.canCreateUsingDefault() && collectionType2.getRawClass() == ArrayBlockingQueue.class) {
return new ArrayBlockingQueueDeserializer(collectionType2, jsonDeserializer, findTypeDeserializer, findValueInstantiator, null);
}
if (contentType.getRawClass() == String.class) {
_findCustomCollectionDeserializer = new StringCollectionDeserializer(collectionType2, jsonDeserializer, findValueInstantiator);
} else {
_findCustomCollectionDeserializer = new CollectionDeserializer(collectionType2, jsonDeserializer, findTypeDeserializer, findValueInstantiator);
}
}
} else {
collectionType2 = collectionType;
}
if (this._factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier beanDeserializerModifier : this._factoryConfig.deserializerModifiers()) {
_findCustomCollectionDeserializer = beanDeserializerModifier.modifyCollectionDeserializer(config, collectionType2, beanDescription, _findCustomCollectionDeserializer);
}
}
return _findCustomCollectionDeserializer;
}
/* access modifiers changed from: protected */
public CollectionType _mapAbstractCollectionType(JavaType javaType, DeserializationConfig deserializationConfig) {
Class<? extends Collection> cls = _collectionFallbacks.get(javaType.getRawClass().getName());
if (cls == null) {
return null;
}
return (CollectionType) deserializationConfig.constructSpecializedType(javaType, cls);
}
/* access modifiers changed from: protected */
public JsonDeserializer<?> _findCustomCollectionDeserializer(CollectionType collectionType, DeserializationConfig deserializationConfig, BeanDescription beanDescription, TypeDeserializer typeDeserializer, JsonDeserializer<?> jsonDeserializer) throws JsonMappingException {
for (Deserializers deserializers : this._factoryConfig.deserializers()) {
JsonDeserializer<?> findCollectionDeserializer = deserializers.findCollectionDeserializer(collectionType, deserializationConfig, beanDescription, typeDeserializer, jsonDeserializer);
if (findCollectionDeserializer != null) {
return findCollectionDeserializer;
}
}
return null;
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public JsonDeserializer<?> createCollectionLikeDeserializer(DeserializationContext deserializationContext, CollectionLikeType collectionLikeType, BeanDescription beanDescription) throws JsonMappingException {
JavaType contentType = collectionLikeType.getContentType();
JsonDeserializer<?> jsonDeserializer = (JsonDeserializer) contentType.getValueHandler();
DeserializationConfig config = deserializationContext.getConfig();
TypeDeserializer typeDeserializer = (TypeDeserializer) contentType.getTypeHandler();
JsonDeserializer<?> _findCustomCollectionLikeDeserializer = _findCustomCollectionLikeDeserializer(collectionLikeType, config, beanDescription, typeDeserializer == null ? findTypeDeserializer(config, contentType) : typeDeserializer, jsonDeserializer);
if (_findCustomCollectionLikeDeserializer != null && this._factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier beanDeserializerModifier : this._factoryConfig.deserializerModifiers()) {
_findCustomCollectionLikeDeserializer = beanDeserializerModifier.modifyCollectionLikeDeserializer(config, collectionLikeType, beanDescription, _findCustomCollectionLikeDeserializer);
}
}
return _findCustomCollectionLikeDeserializer;
}
/* access modifiers changed from: protected */
public JsonDeserializer<?> _findCustomCollectionLikeDeserializer(CollectionLikeType collectionLikeType, DeserializationConfig deserializationConfig, BeanDescription beanDescription, TypeDeserializer typeDeserializer, JsonDeserializer<?> jsonDeserializer) throws JsonMappingException {
for (Deserializers deserializers : this._factoryConfig.deserializers()) {
JsonDeserializer<?> findCollectionLikeDeserializer = deserializers.findCollectionLikeDeserializer(collectionLikeType, deserializationConfig, beanDescription, typeDeserializer, jsonDeserializer);
if (findCollectionLikeDeserializer != null) {
return findCollectionLikeDeserializer;
}
}
return null;
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public JsonDeserializer<?> createMapDeserializer(DeserializationContext deserializationContext, MapType mapType, BeanDescription beanDescription) throws JsonMappingException {
BeanDescription beanDescription2;
MapType mapType2 = mapType;
DeserializationConfig config = deserializationContext.getConfig();
JavaType keyType = mapType.getKeyType();
JavaType contentType = mapType.getContentType();
JsonDeserializer<?> jsonDeserializer = (JsonDeserializer) contentType.getValueHandler();
KeyDeserializer keyDeserializer = (KeyDeserializer) keyType.getValueHandler();
TypeDeserializer typeDeserializer = (TypeDeserializer) contentType.getTypeHandler();
TypeDeserializer findTypeDeserializer = typeDeserializer == null ? findTypeDeserializer(config, contentType) : typeDeserializer;
JsonDeserializer<?> _findCustomMapDeserializer = _findCustomMapDeserializer(mapType, config, beanDescription, keyDeserializer, findTypeDeserializer, jsonDeserializer);
if (_findCustomMapDeserializer == null) {
Class<?> rawClass = mapType.getRawClass();
if (EnumMap.class.isAssignableFrom(rawClass)) {
Class<?> rawClass2 = keyType.getRawClass();
if (rawClass2 == null || !rawClass2.isEnum()) {
throw new IllegalArgumentException("Can not construct EnumMap; generic (key) type not available");
}
_findCustomMapDeserializer = new EnumMapDeserializer(mapType2, null, jsonDeserializer, findTypeDeserializer);
}
if (_findCustomMapDeserializer == null) {
if (mapType.isInterface() || mapType.isAbstract()) {
Class<? extends Map> cls = _mapFallbacks.get(rawClass.getName());
if (cls != null) {
MapType mapType3 = (MapType) config.constructSpecializedType(mapType2, cls);
beanDescription2 = config.introspectForCreation(mapType3);
mapType2 = mapType3;
} else if (mapType.getTypeHandler() != null) {
_findCustomMapDeserializer = AbstractDeserializer.constructForNonPOJO(beanDescription);
beanDescription2 = beanDescription;
} else {
throw new IllegalArgumentException("Can not find a deserializer for non-concrete Map type " + mapType2);
}
} else {
beanDescription2 = beanDescription;
}
if (_findCustomMapDeserializer == null) {
MapDeserializer mapDeserializer = new MapDeserializer(mapType2, findValueInstantiator(deserializationContext, beanDescription2), keyDeserializer, jsonDeserializer, findTypeDeserializer);
mapDeserializer.setIgnorableProperties(config.getAnnotationIntrospector().findPropertiesToIgnore(beanDescription2.getClassInfo()));
_findCustomMapDeserializer = mapDeserializer;
}
} else {
beanDescription2 = beanDescription;
}
} else {
beanDescription2 = beanDescription;
}
if (this._factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier beanDeserializerModifier : this._factoryConfig.deserializerModifiers()) {
_findCustomMapDeserializer = beanDeserializerModifier.modifyMapDeserializer(config, mapType2, beanDescription2, _findCustomMapDeserializer);
}
}
return _findCustomMapDeserializer;
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public JsonDeserializer<?> createMapLikeDeserializer(DeserializationContext deserializationContext, MapLikeType mapLikeType, BeanDescription beanDescription) throws JsonMappingException {
JavaType keyType = mapLikeType.getKeyType();
JavaType contentType = mapLikeType.getContentType();
DeserializationConfig config = deserializationContext.getConfig();
JsonDeserializer<?> jsonDeserializer = (JsonDeserializer) contentType.getValueHandler();
KeyDeserializer keyDeserializer = (KeyDeserializer) keyType.getValueHandler();
TypeDeserializer typeDeserializer = (TypeDeserializer) contentType.getTypeHandler();
JsonDeserializer<?> _findCustomMapLikeDeserializer = _findCustomMapLikeDeserializer(mapLikeType, config, beanDescription, keyDeserializer, typeDeserializer == null ? findTypeDeserializer(config, contentType) : typeDeserializer, jsonDeserializer);
if (_findCustomMapLikeDeserializer != null && this._factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier beanDeserializerModifier : this._factoryConfig.deserializerModifiers()) {
_findCustomMapLikeDeserializer = beanDeserializerModifier.modifyMapLikeDeserializer(config, mapLikeType, beanDescription, _findCustomMapLikeDeserializer);
}
}
return _findCustomMapLikeDeserializer;
}
/* access modifiers changed from: protected */
public JsonDeserializer<?> _findCustomMapDeserializer(MapType mapType, DeserializationConfig deserializationConfig, BeanDescription beanDescription, KeyDeserializer keyDeserializer, TypeDeserializer typeDeserializer, JsonDeserializer<?> jsonDeserializer) throws JsonMappingException {
for (Deserializers deserializers : this._factoryConfig.deserializers()) {
JsonDeserializer<?> findMapDeserializer = deserializers.findMapDeserializer(mapType, deserializationConfig, beanDescription, keyDeserializer, typeDeserializer, jsonDeserializer);
if (findMapDeserializer != null) {
return findMapDeserializer;
}
}
return null;
}
/* access modifiers changed from: protected */
public JsonDeserializer<?> _findCustomMapLikeDeserializer(MapLikeType mapLikeType, DeserializationConfig deserializationConfig, BeanDescription beanDescription, KeyDeserializer keyDeserializer, TypeDeserializer typeDeserializer, JsonDeserializer<?> jsonDeserializer) throws JsonMappingException {
for (Deserializers deserializers : this._factoryConfig.deserializers()) {
JsonDeserializer<?> findMapLikeDeserializer = deserializers.findMapLikeDeserializer(mapLikeType, deserializationConfig, beanDescription, keyDeserializer, typeDeserializer, jsonDeserializer);
if (findMapLikeDeserializer != null) {
return findMapLikeDeserializer;
}
}
return null;
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public JsonDeserializer<?> createEnumDeserializer(DeserializationContext deserializationContext, JavaType javaType, BeanDescription beanDescription) throws JsonMappingException {
DeserializationConfig config = deserializationContext.getConfig();
Class<?> rawClass = javaType.getRawClass();
JsonDeserializer<?> _findCustomEnumDeserializer = _findCustomEnumDeserializer(rawClass, config, beanDescription);
if (_findCustomEnumDeserializer == null) {
Iterator<AnnotatedMethod> it = beanDescription.getFactoryMethods().iterator();
while (true) {
if (!it.hasNext()) {
break;
}
AnnotatedMethod next = it.next();
if (deserializationContext.getAnnotationIntrospector().hasCreatorAnnotation(next)) {
if (next.getParameterCount() != 1 || !next.getRawReturnType().isAssignableFrom(rawClass)) {
throw new IllegalArgumentException("Unsuitable method (" + next + ") decorated with @JsonCreator (for Enum type " + rawClass.getName() + ")");
}
_findCustomEnumDeserializer = EnumDeserializer.deserializerForCreator(config, rawClass, next);
}
}
if (_findCustomEnumDeserializer == null) {
_findCustomEnumDeserializer = new EnumDeserializer(constructEnumResolver(rawClass, config, beanDescription.findJsonValueMethod()));
}
}
if (this._factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier beanDeserializerModifier : this._factoryConfig.deserializerModifiers()) {
_findCustomEnumDeserializer = beanDeserializerModifier.modifyEnumDeserializer(config, javaType, beanDescription, _findCustomEnumDeserializer);
}
}
return _findCustomEnumDeserializer;
}
/* access modifiers changed from: protected */
public JsonDeserializer<?> _findCustomEnumDeserializer(Class<?> cls, DeserializationConfig deserializationConfig, BeanDescription beanDescription) throws JsonMappingException {
for (Deserializers deserializers : this._factoryConfig.deserializers()) {
JsonDeserializer<?> findEnumDeserializer = deserializers.findEnumDeserializer(cls, deserializationConfig, beanDescription);
if (findEnumDeserializer != null) {
return findEnumDeserializer;
}
}
return null;
}
/* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.fasterxml.jackson.databind.deser.BasicDeserializerFactory */
/* JADX WARN: Multi-variable type inference failed */
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public JsonDeserializer<?> createTreeDeserializer(DeserializationConfig deserializationConfig, JavaType javaType, BeanDescription beanDescription) throws JsonMappingException {
Class<?> rawClass = javaType.getRawClass();
JsonDeserializer<?> _findCustomTreeNodeDeserializer = _findCustomTreeNodeDeserializer(rawClass, deserializationConfig, beanDescription);
if (_findCustomTreeNodeDeserializer != null) {
return _findCustomTreeNodeDeserializer;
}
return JsonNodeDeserializer.getDeserializer(rawClass);
}
/* access modifiers changed from: protected */
public JsonDeserializer<?> _findCustomTreeNodeDeserializer(Class<? extends JsonNode> cls, DeserializationConfig deserializationConfig, BeanDescription beanDescription) throws JsonMappingException {
for (Deserializers deserializers : this._factoryConfig.deserializers()) {
JsonDeserializer<?> findTreeNodeDeserializer = deserializers.findTreeNodeDeserializer(cls, deserializationConfig, beanDescription);
if (findTreeNodeDeserializer != null) {
return findTreeNodeDeserializer;
}
}
return null;
}
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public TypeDeserializer findTypeDeserializer(DeserializationConfig deserializationConfig, JavaType javaType) throws JsonMappingException {
JavaType mapAbstractType;
AnnotatedClass classInfo = deserializationConfig.introspectClassAnnotations(javaType.getRawClass()).getClassInfo();
AnnotationIntrospector annotationIntrospector = deserializationConfig.getAnnotationIntrospector();
TypeResolverBuilder<?> findTypeResolver = annotationIntrospector.findTypeResolver(deserializationConfig, classInfo, javaType);
Collection<NamedType> collection = null;
if (findTypeResolver == null) {
findTypeResolver = deserializationConfig.getDefaultTyper(javaType);
if (findTypeResolver == null) {
return null;
}
} else {
collection = deserializationConfig.getSubtypeResolver().collectAndResolveSubtypes(classInfo, deserializationConfig, annotationIntrospector);
}
if (findTypeResolver.getDefaultImpl() == null && javaType.isAbstract() && (mapAbstractType = mapAbstractType(deserializationConfig, javaType)) != null && mapAbstractType.getRawClass() != javaType.getRawClass()) {
findTypeResolver = findTypeResolver.defaultImpl(mapAbstractType.getRawClass());
}
return findTypeResolver.buildTypeDeserializer(deserializationConfig, javaType, collection);
}
/* JADX WARNING: Removed duplicated region for block: B:5:0x0025 */
@Override // com.fasterxml.jackson.databind.deser.DeserializerFactory
public KeyDeserializer createKeyDeserializer(DeserializationContext deserializationContext, JavaType javaType) throws JsonMappingException {
DeserializationConfig config = deserializationContext.getConfig();
KeyDeserializer keyDeserializer = null;
if (this._factoryConfig.hasKeyDeserializers()) {
BeanDescription introspectClassAnnotations = config.introspectClassAnnotations(javaType.getRawClass());
Iterator<KeyDeserializers> it = this._factoryConfig.keyDeserializers().iterator();
while (it.hasNext() && (keyDeserializer = it.next().findKeyDeserializer(javaType, config, introspectClassAnnotations)) == null) {
while (it.hasNext()) {
while (it.hasNext()) {
}
}
}
}
if (keyDeserializer == null) {
if (javaType.isEnumType()) {
return _createEnumKeyDeserializer(deserializationContext, javaType);
}
keyDeserializer = StdKeyDeserializers.findStringBasedKeyDeserializer(config, javaType);
}
if (keyDeserializer != null && this._factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier beanDeserializerModifier : this._factoryConfig.deserializerModifiers()) {
keyDeserializer = beanDeserializerModifier.modifyKeyDeserializer(config, javaType, keyDeserializer);
}
}
return keyDeserializer;
}
private KeyDeserializer _createEnumKeyDeserializer(DeserializationContext deserializationContext, JavaType javaType) throws JsonMappingException {
DeserializationConfig config = deserializationContext.getConfig();
BeanDescription introspect = config.introspect(javaType);
JsonDeserializer<Object> findDeserializerFromAnnotation = findDeserializerFromAnnotation(deserializationContext, introspect.getClassInfo());
if (findDeserializerFromAnnotation != null) {
return StdKeyDeserializers.constructDelegatingKeyDeserializer(config, javaType, findDeserializerFromAnnotation);
}
Class<?> rawClass = javaType.getRawClass();
JsonDeserializer<?> _findCustomEnumDeserializer = _findCustomEnumDeserializer(rawClass, config, introspect);
if (_findCustomEnumDeserializer != null) {
return StdKeyDeserializers.constructDelegatingKeyDeserializer(config, javaType, _findCustomEnumDeserializer);
}
EnumResolver<?> constructEnumResolver = constructEnumResolver(rawClass, config, introspect.findJsonValueMethod());
for (AnnotatedMethod annotatedMethod : introspect.getFactoryMethods()) {
if (config.getAnnotationIntrospector().hasCreatorAnnotation(annotatedMethod)) {
if (annotatedMethod.getParameterCount() != 1 || !annotatedMethod.getRawReturnType().isAssignableFrom(rawClass)) {
throw new IllegalArgumentException("Unsuitable method (" + annotatedMethod + ") decorated with @JsonCreator (for Enum type " + rawClass.getName() + ")");
} else if (annotatedMethod.getGenericParameterType(0) == String.class) {
if (config.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(annotatedMethod.getMember());
}
return StdKeyDeserializers.constructEnumKeyDeserializer(constructEnumResolver, annotatedMethod);
} else {
throw new IllegalArgumentException("Parameter #0 type for factory method (" + annotatedMethod + ") not suitable, must be java.lang.String");
}
}
}
return StdKeyDeserializers.constructEnumKeyDeserializer(constructEnumResolver);
}
public TypeDeserializer findPropertyTypeDeserializer(DeserializationConfig deserializationConfig, JavaType javaType, AnnotatedMember annotatedMember) throws JsonMappingException {
AnnotationIntrospector annotationIntrospector = deserializationConfig.getAnnotationIntrospector();
TypeResolverBuilder<?> findPropertyTypeResolver = annotationIntrospector.findPropertyTypeResolver(deserializationConfig, annotatedMember, javaType);
if (findPropertyTypeResolver == null) {
return findTypeDeserializer(deserializationConfig, javaType);
}
return findPropertyTypeResolver.buildTypeDeserializer(deserializationConfig, javaType, deserializationConfig.getSubtypeResolver().collectAndResolveSubtypes(annotatedMember, deserializationConfig, annotationIntrospector, javaType));
}
public TypeDeserializer findPropertyContentTypeDeserializer(DeserializationConfig deserializationConfig, JavaType javaType, AnnotatedMember annotatedMember) throws JsonMappingException {
AnnotationIntrospector annotationIntrospector = deserializationConfig.getAnnotationIntrospector();
TypeResolverBuilder<?> findPropertyContentTypeResolver = annotationIntrospector.findPropertyContentTypeResolver(deserializationConfig, annotatedMember, javaType);
JavaType contentType = javaType.getContentType();
if (findPropertyContentTypeResolver == null) {
return findTypeDeserializer(deserializationConfig, contentType);
}
return findPropertyContentTypeResolver.buildTypeDeserializer(deserializationConfig, contentType, deserializationConfig.getSubtypeResolver().collectAndResolveSubtypes(annotatedMember, deserializationConfig, annotationIntrospector, contentType));
}
public JsonDeserializer<?> findDefaultDeserializer(DeserializationContext deserializationContext, JavaType javaType, BeanDescription beanDescription) throws JsonMappingException {
Class<?> rawClass = javaType.getRawClass();
if (rawClass == CLASS_OBJECT) {
return new UntypedObjectDeserializer();
}
if (rawClass == CLASS_STRING || rawClass == CLASS_CHAR_BUFFER) {
return StringDeserializer.instance;
}
if (rawClass == CLASS_ITERABLE) {
return createCollectionDeserializer(deserializationContext, deserializationContext.getTypeFactory().constructCollectionType(Collection.class, javaType.containedTypeCount() > 0 ? javaType.containedType(0) : TypeFactory.unknownType()), beanDescription);
}
String name = rawClass.getName();
if (rawClass.isPrimitive() || name.startsWith("java.")) {
JsonDeserializer<?> find = NumberDeserializers.find(rawClass, name);
if (find == null) {
find = DateDeserializers.find(rawClass, name);
}
if (find != null) {
return find;
}
}
if (rawClass == TokenBuffer.class) {
return new TokenBufferDeserializer();
}
return JdkDeserializers.find(rawClass, name);
}
/* access modifiers changed from: protected */
public JsonDeserializer<Object> findDeserializerFromAnnotation(DeserializationContext deserializationContext, Annotated annotated) throws JsonMappingException {
Object findDeserializer = deserializationContext.getAnnotationIntrospector().findDeserializer(annotated);
if (findDeserializer == null) {
return null;
}
return deserializationContext.deserializerInstance(annotated, findDeserializer);
}
/* access modifiers changed from: protected */
public <T extends JavaType> T modifyTypeByAnnotation(DeserializationContext deserializationContext, Annotated annotated, T t) throws JsonMappingException {
JsonDeserializer<Object> deserializerInstance;
KeyDeserializer keyDeserializerInstance;
AnnotationIntrospector annotationIntrospector = deserializationContext.getAnnotationIntrospector();
Class<?> findDeserializationType = annotationIntrospector.findDeserializationType(annotated, t);
if (findDeserializationType != null) {
try {
t = (T) t.narrowBy(findDeserializationType);
} catch (IllegalArgumentException e) {
throw new JsonMappingException("Failed to narrow type " + t + " with concrete-type annotation (value " + findDeserializationType.getName() + "), method '" + annotated.getName() + "': " + e.getMessage(), null, e);
}
}
if (!t.isContainerType()) {
return t;
}
Class<?> findDeserializationKeyType = annotationIntrospector.findDeserializationKeyType(annotated, t.getKeyType());
if (findDeserializationKeyType != null) {
if (t instanceof MapLikeType) {
try {
t = (T) ((MapLikeType) t).narrowKey(findDeserializationKeyType);
} catch (IllegalArgumentException e2) {
throw new JsonMappingException("Failed to narrow key type " + t + " with key-type annotation (" + findDeserializationKeyType.getName() + "): " + e2.getMessage(), null, e2);
}
} else {
throw new JsonMappingException("Illegal key-type annotation: type " + t + " is not a Map(-like) type");
}
}
JavaType keyType = t.getKeyType();
if (!(keyType == null || keyType.getValueHandler() != null || (keyDeserializerInstance = deserializationContext.keyDeserializerInstance(annotated, annotationIntrospector.findKeyDeserializer(annotated))) == null)) {
t = ((MapLikeType) t).withKeyValueHandler(keyDeserializerInstance);
t.getKeyType();
}
Class<?> findDeserializationContentType = annotationIntrospector.findDeserializationContentType(annotated, t.getContentType());
if (findDeserializationContentType != null) {
try {
t = (T) t.narrowContentsBy(findDeserializationContentType);
} catch (IllegalArgumentException e3) {
throw new JsonMappingException("Failed to narrow content type " + t + " with content-type annotation (" + findDeserializationContentType.getName() + "): " + e3.getMessage(), null, e3);
}
}
return (t.getContentType().getValueHandler() != null || (deserializerInstance = deserializationContext.deserializerInstance(annotated, annotationIntrospector.findContentDeserializer(annotated))) == null) ? t : (T) t.withContentValueHandler(deserializerInstance);
}
/* access modifiers changed from: protected */
public JavaType resolveType(DeserializationContext deserializationContext, BeanDescription beanDescription, JavaType javaType, AnnotatedMember annotatedMember) throws JsonMappingException {
TypeDeserializer typeDeserializer;
TypeDeserializer findPropertyContentTypeDeserializer;
KeyDeserializer keyDeserializerInstance;
if (javaType.isContainerType()) {
AnnotationIntrospector annotationIntrospector = deserializationContext.getAnnotationIntrospector();
if (!(javaType.getKeyType() == null || (keyDeserializerInstance = deserializationContext.keyDeserializerInstance(annotatedMember, annotationIntrospector.findKeyDeserializer(annotatedMember))) == null)) {
javaType = ((MapLikeType) javaType).withKeyValueHandler(keyDeserializerInstance);
javaType.getKeyType();
}
JsonDeserializer<Object> deserializerInstance = deserializationContext.deserializerInstance(annotatedMember, annotationIntrospector.findContentDeserializer(annotatedMember));
if (deserializerInstance != null) {
javaType = javaType.withContentValueHandler(deserializerInstance);
}
if ((annotatedMember instanceof AnnotatedMember) && (findPropertyContentTypeDeserializer = findPropertyContentTypeDeserializer(deserializationContext.getConfig(), javaType, annotatedMember)) != null) {
javaType = javaType.withContentTypeHandler(findPropertyContentTypeDeserializer);
}
}
if (annotatedMember instanceof AnnotatedMember) {
typeDeserializer = findPropertyTypeDeserializer(deserializationContext.getConfig(), javaType, annotatedMember);
} else {
typeDeserializer = findTypeDeserializer(deserializationContext.getConfig(), javaType);
}
return typeDeserializer != null ? javaType.withTypeHandler(typeDeserializer) : javaType;
}
/* access modifiers changed from: protected */
public EnumResolver<?> constructEnumResolver(Class<?> cls, DeserializationConfig deserializationConfig, AnnotatedMethod annotatedMethod) {
if (annotatedMethod != null) {
Method annotated = annotatedMethod.getAnnotated();
if (deserializationConfig.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(annotated);
}
return EnumResolver.constructUnsafeUsingMethod(cls, annotated);
} else if (deserializationConfig.isEnabled(DeserializationFeature.READ_ENUMS_USING_TO_STRING)) {
return EnumResolver.constructUnsafeUsingToString(cls);
} else {
return EnumResolver.constructUnsafe(cls, deserializationConfig.getAnnotationIntrospector());
}
}
/* access modifiers changed from: protected */
public AnnotatedMethod _findJsonValueFor(DeserializationConfig deserializationConfig, JavaType javaType) {
if (javaType == null) {
return null;
}
return deserializationConfig.introspect(javaType).findJsonValueMethod();
}
}