Java 类com.fasterxml.jackson.databind.util.ClassUtil 实例源码

public ObjBase makeValue(ObjectId id, DBObject rawData, Class<? extends ObjBase> c){

        if (Modifier.isAbstract(c.getModifiers()) || Modifier.isInterface(c.getModifiers())) {
            //extract declared schema from result, use that class
            Object schemaId = rawData.get(ReservedFieldNames.SCHEMA);
            try {
                c = (Class<ObjBase>) ClassUtil.findClass(schemaId.toString());
            } catch (ClassNotFoundException ex) {
                log.warn("Could not find fallback schema {}", schemaId);
                return null;
            }
        }

        ObjBase value = makeStub(id, c, rawData);
        // update stub with the rest of the data, 
        if (value != null && !(value instanceof Swappable)) 
            try {
                unmarshaller.unmarshall(Bson.createDocument(rawData), value, this);
            } catch (MarshallingException me){
                log.warn(me.getMessage(), me);
            }

        return value;
    }

@Override
public JavaType typeFromId(String id) {
    try{
        return super.typeFromId(id);
    } catch (IllegalArgumentException iae){
        try {
            //try the widening type construction instead
            Class<?> cls =  ClassUtil.findClass(id);
            if (cls.isAssignableFrom(_baseType.getRawClass()) || _baseType.getRawClass().equals(JSONFilter.class)) return _baseType;
            //TODO: make this message not suck
            else throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): ");
        } catch (ClassNotFoundException cnfe){
            throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): no such class found");
        } 
        catch (Exception e){
            //could neither narrow or widen that type combination
            throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): "+e.getMessage(), e);
        } 

    }
}

protected BeanPropertyWriter _constructWriter(SerializerProvider paramSerializerProvider, BeanPropertyDefinition paramBeanPropertyDefinition, TypeBindings paramTypeBindings, PropertyBuilder paramPropertyBuilder, boolean paramBoolean, AnnotatedMember paramAnnotatedMember)
{
  String str = paramBeanPropertyDefinition.getName();
  if (paramSerializerProvider.canOverrideAccessModifiers())
    paramAnnotatedMember.fixAccess();
  JavaType localJavaType = paramAnnotatedMember.getType(paramTypeBindings);
  BeanProperty.Std localStd = new BeanProperty.Std(str, localJavaType, paramBeanPropertyDefinition.getWrapperName(), paramPropertyBuilder.getClassAnnotations(), paramAnnotatedMember, paramBeanPropertyDefinition.isRequired());
  JsonSerializer localJsonSerializer1 = findSerializerFromAnnotation(paramSerializerProvider, paramAnnotatedMember);
  JsonSerializer localJsonSerializer2 = localJsonSerializer1;
  if ((localJsonSerializer1 instanceof ResolvableSerializer))
    ((ResolvableSerializer)localJsonSerializer2).resolve(paramSerializerProvider);
  if ((localJsonSerializer2 instanceof ContextualSerializer))
    localJsonSerializer2 = ((ContextualSerializer)localJsonSerializer2).createContextual(paramSerializerProvider, localStd);
  boolean bool = ClassUtil.isCollectionMapOrArray(localJavaType.getRawClass());
  TypeSerializer localTypeSerializer1 = null;
  if (bool)
    localTypeSerializer1 = findPropertyContentTypeSerializer(localJavaType, paramSerializerProvider.getConfig(), paramAnnotatedMember);
  TypeSerializer localTypeSerializer2 = findPropertyTypeSerializer(localJavaType, paramSerializerProvider.getConfig(), paramAnnotatedMember);
  return paramPropertyBuilder.buildWriter(paramBeanPropertyDefinition, localJavaType, localJsonSerializer2, localTypeSerializer2, localTypeSerializer1, paramAnnotatedMember, paramBoolean);
}

private PropertyNamingStrategy _findNamingStrategy()
{
  Object localObject1;
  if (this._annotationIntrospector == null)
    localObject1 = null;
  else
    localObject1 = this._annotationIntrospector.findNamingStrategy(this._classDef);
  Object localObject2 = localObject1;
  if (localObject1 == null)
    return this._config.getPropertyNamingStrategy();
  if ((localObject2 instanceof PropertyNamingStrategy))
    return (PropertyNamingStrategy)localObject2;
  if (!(localObject2 instanceof Class))
    throw new IllegalStateException("AnnotationIntrospector returned PropertyNamingStrategy definition of type " + localObject2.getClass().getName() + "; expected type PropertyNamingStrategy or Class<PropertyNamingStrategy> instead");
  Class localClass = (Class)localObject2;
  if (!PropertyNamingStrategy.class.isAssignableFrom(localClass))
    throw new IllegalStateException("AnnotationIntrospector returned Class " + localClass.getName() + "; expected Class<PropertyNamingStrategy>");
  HandlerInstantiator localHandlerInstantiator = this._config.getHandlerInstantiator();
  if (localHandlerInstantiator != null)
  {
    PropertyNamingStrategy localPropertyNamingStrategy = localHandlerInstantiator.namingStrategyInstance(this._config, this._classDef, localClass);
    if (localPropertyNamingStrategy != null)
      return localPropertyNamingStrategy;
  }
  return (PropertyNamingStrategy)ClassUtil.createInstance(localClass, this._config.canOverrideAccessModifiers());
}

protected final void _addMethodMixIns(Class<?> paramClass1, AnnotatedMethodMap paramAnnotatedMethodMap1, Class<?> paramClass2, AnnotatedMethodMap paramAnnotatedMethodMap2)
{
  ArrayList localArrayList = new ArrayList();
  localArrayList.add(paramClass2);
  ClassUtil.findSuperTypes(paramClass2, paramClass1, localArrayList);
  Iterator localIterator = localArrayList.iterator();
  while (localIterator.hasNext())
    for (Method localMethod : ((Class)localIterator.next()).getDeclaredMethods())
      if (_isIncludableMemberMethod(localMethod))
      {
        AnnotatedMethod localAnnotatedMethod = paramAnnotatedMethodMap1.find(localMethod);
        if (localAnnotatedMethod != null)
          _addMixUnders(localMethod, localAnnotatedMethod);
        else
          paramAnnotatedMethodMap2.add(_constructMethod(localMethod));
      }
}

public ValueInstantiator _valueInstantiatorInstance(DeserializationConfig paramDeserializationConfig, Annotated paramAnnotated, Object paramObject)
{
  if (paramObject == null)
    return null;
  if ((paramObject instanceof ValueInstantiator))
    return (ValueInstantiator)paramObject;
  if (!(paramObject instanceof Class))
    throw new IllegalStateException("AnnotationIntrospector returned key deserializer definition of type " + paramObject.getClass().getName() + "; expected type KeyDeserializer or Class<KeyDeserializer> instead");
  Class localClass = (Class)paramObject;
  if (localClass == NoClass.class)
    return null;
  if (!ValueInstantiator.class.isAssignableFrom(localClass))
    throw new IllegalStateException("AnnotationIntrospector returned Class " + localClass.getName() + "; expected Class<ValueInstantiator>");
  HandlerInstantiator localHandlerInstantiator = paramDeserializationConfig.getHandlerInstantiator();
  if (localHandlerInstantiator != null)
  {
    ValueInstantiator localValueInstantiator = localHandlerInstantiator.valueInstantiatorInstance(paramDeserializationConfig, paramAnnotated, localClass);
    if (localValueInstantiator != null)
      return localValueInstantiator;
  }
  return (ValueInstantiator)ClassUtil.createInstance(localClass, paramDeserializationConfig.canOverrideAccessModifiers());
}

public Class<?> deserialize(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext)
{
  JsonToken localJsonToken = paramJsonParser.getCurrentToken();
  if (localJsonToken == JsonToken.VALUE_STRING)
  {
    String str = paramJsonParser.getText().trim();
    try
    {
      Class localClass = paramDeserializationContext.findClass(str);
      return localClass;
    }
    catch (Exception localException)
    {
      throw paramDeserializationContext.instantiationException(this._valueClass, ClassUtil.getRootCause(localException));
    }
  }
  throw paramDeserializationContext.mappingException(this._valueClass, localJsonToken);
}

public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig paramDeserializationConfig, Class<?> paramClass, AnnotatedMethod paramAnnotatedMethod)
{
  Class localClass = paramAnnotatedMethod.getRawParameterType(0);
  Object localObject;
  if (localClass == String.class)
    localObject = null;
  else if ((localClass == Integer.TYPE) || (localClass == Integer.class))
    localObject = Integer.class;
  else if ((localClass == Long.TYPE) || (localClass == Long.class))
    localObject = Long.class;
  else
    throw new IllegalArgumentException("Parameter #0 type for factory method (" + paramAnnotatedMethod + ") not suitable, must be java.lang.String or int/Integer/long/Long");
  if (paramDeserializationConfig.canOverrideAccessModifiers())
    ClassUtil.checkAndFixAccess(paramAnnotatedMethod.getMember());
  return new FactoryBasedDeserializer(paramClass, paramAnnotatedMethod, (Class)localObject);
}

public Object deserialize(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext)
{
  Object localObject1;
  if (this._inputType == null)
    localObject1 = paramJsonParser.getText();
  else if (this._inputType == Integer.class)
    localObject1 = Integer.valueOf(paramJsonParser.getValueAsInt());
  else if (this._inputType == Long.class)
    localObject1 = Long.valueOf(paramJsonParser.getValueAsLong());
  else
    throw paramDeserializationContext.mappingException(this._enumClass);
  try
  {
    Object localObject2 = this._factory.invoke(this._enumClass, new Object[] { localObject1 });
    return localObject2;
  }
  catch (Exception localException)
  {
    ClassUtil.unwrapAndThrowAsIAE(localException);
  }
  return null;
}

public static KeyDeserializer findStringBasedKeyDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType)
{
  BeanDescription localBeanDescription = paramDeserializationConfig.introspect(paramJavaType);
  Constructor localConstructor = localBeanDescription.findSingleArgConstructor(new Class[] { String.class });
  if (localConstructor != null)
  {
    if (paramDeserializationConfig.canOverrideAccessModifiers())
      ClassUtil.checkAndFixAccess(localConstructor);
    return new StdKeyDeserializer.StringCtorKeyDeserializer(localConstructor);
  }
  Method localMethod = localBeanDescription.findFactoryMethod(new Class[] { String.class });
  if (localMethod != null)
  {
    if (paramDeserializationConfig.canOverrideAccessModifiers())
      ClassUtil.checkAndFixAccess(localMethod);
    return new StdKeyDeserializer.StringFactoryKeyDeserializer(localMethod);
  }
  return null;
}

public final Object _parse(String paramString, DeserializationContext paramDeserializationContext)
{
  if (this._factory != null)
    try
    {
      Object localObject = this._factory.call1(paramString);
      return localObject;
    }
    catch (Exception localException)
    {
      ClassUtil.unwrapAndThrowAsIAE(localException);
    }
  Enum localEnum = this._resolver.findEnum(paramString);
  if ((localEnum == null) && (!paramDeserializationContext.getConfig().isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)))
    throw paramDeserializationContext.weirdKeyException(this._keyClass, paramString, "not one of values for Enum class");
  return localEnum;
}

protected SettableBeanProperty _resolveInnerClassValuedProperty(DeserializationContext paramDeserializationContext, SettableBeanProperty paramSettableBeanProperty)
{
  JsonDeserializer localJsonDeserializer = paramSettableBeanProperty.getValueDeserializer();
  if (((localJsonDeserializer instanceof BeanDeserializerBase)) && (!((BeanDeserializerBase)localJsonDeserializer).getValueInstantiator().canCreateUsingDefault()))
  {
    Class localClass1 = paramSettableBeanProperty.getType().getRawClass();
    Class localClass2 = ClassUtil.getOuterClass(localClass1);
    if ((localClass2 != null) && (localClass2 == this._beanType.getRawClass()))
      for (Constructor localConstructor : localClass1.getConstructors())
      {
        Class[] arrayOfClass = localConstructor.getParameterTypes();
        if ((arrayOfClass.length == 1) && (arrayOfClass[0] == localClass2))
        {
          if (paramDeserializationContext.getConfig().canOverrideAccessModifiers())
            ClassUtil.checkAndFixAccess(localConstructor);
          return new InnerClassProperty(paramSettableBeanProperty, localConstructor);
        }
      }
  }
  return paramSettableBeanProperty;
}

@Override
public JavaType typeFromId(String id)
{
/* 30-Jan-2010, tatu: Most ids are basic class names; so let's first
 *    check if any generics info is added; and only then ask factory
 *    to do translation when necessary
 */
    if (id.indexOf('<') > 0) {
        JavaType t = typeFactory.constructFromCanonical(id);
        // note: may want to try combining with specialization (esp for EnumMap)?
        return t;
    }
    try {
        Class<?> cls =  ClassUtil.findClass(id);
        return typeFactory.constructSpecializedType(baseType, cls);
    } catch (ClassNotFoundException ignored) {
        throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): no such class found");
    } catch (Exception e) {
        throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): "+e.getMessage(), e);
    }
}

@Override
public ObjectIdGenerator<?> objectIdGeneratorInstance(Annotated annotated,
        ObjectIdInfo objectIdInfo)
    throws JsonMappingException
{
    Class<?> implClass = objectIdInfo.getGeneratorType();
    HandlerInstantiator hi = _config.getHandlerInstantiator();
    ObjectIdGenerator<?> gen;

    if (hi != null) {
        gen =  hi.objectIdGeneratorInstance(_config, annotated, implClass);
    } else {
        gen = (ObjectIdGenerator<?>) ClassUtil.createInstance(implClass,
                _config.canOverrideAccessModifiers());
    }
    return gen.forScope(objectIdInfo.getScope());
}

/**
 * Method called to see if one of primary per-class annotations
 * (or related, like implementing of {@link JsonSerializable})
 * determines the serializer to use.
 *<p>
 * Currently handles things like:
 *<ul>
 * <li>If type implements {@link JsonSerializable}, use that
 *  </li>
 * <li>If type has {@link com.fasterxml.jackson.annotation.JsonValue} annotation (or equivalent), build serializer
 *    based on that property
 *  </li>
 *</ul>
 *
 * @since 2.0
 */
protected final JsonSerializer<?> findSerializerByAnnotations(SerializerProvider prov, 
        JavaType type, BeanDescription beanDesc)
    throws JsonMappingException
{
    Class<?> raw = type.getRawClass();
    // First: JsonSerializable?
    if (JsonSerializable.class.isAssignableFrom(raw)) {
        return SerializableSerializer.instance;
    }
    // Second: @JsonValue for any type
    AnnotatedMethod valueMethod = beanDesc.findJsonValueMethod();
    if (valueMethod != null) {
        Method m = valueMethod.getAnnotated();
        if (prov.canOverrideAccessModifiers()) {
            ClassUtil.checkAndFixAccess(m);
        }
        JsonSerializer<Object> ser = findSerializerFromAnnotation(prov, valueMethod);
        return new JsonValueSerializer(m, ser);
    }
    // No well-known annotations...
    return null;
}

protected void _addClassMixIns(AnnotationMap annotations, Class<?> toMask,
                               Class<?> mixin)
{
    if (mixin == null) {
        return;
    }
    // Ok, first: annotations from mix-in class itself:
    _addAnnotationsIfNotPresent(annotations, mixin.getDeclaredAnnotations());

    /* And then from its supertypes, if any. But note that we will
     * only consider super-types up until reaching the masked
     * class (if found); this because often mix-in class
     * is a sub-class (for convenience reasons). And if so, we
     * absolutely must NOT include super types of masked class,
     * as that would inverse precedence of annotations.
     */
    for (Class<?> parent : ClassUtil.findSuperTypes(mixin, toMask)) {
        _addAnnotationsIfNotPresent(annotations, parent.getDeclaredAnnotations());
    }
}

/**
 * Method called to add field mix-ins from given mix-in class (and its fields)
 * into already collected actual fields (from introspected classes and their
 * super-classes)
 */
protected void _addFieldMixIns(Class<?> targetClass, Class<?> mixInCls,
        Map<String,AnnotatedField> fields)
{
    List<Class<?>> parents = new ArrayList<Class<?>>();
    parents.add(mixInCls);
    ClassUtil.findSuperTypes(mixInCls, targetClass, parents);
    for (Class<?> mixin : parents) {
        for (Field mixinField : mixin.getDeclaredFields()) {
            // there are some dummy things (static, synthetic); better ignore
            if (!_isIncludableField(mixinField)) {
                continue;
            }
            String name = mixinField.getName();
            // anything to mask? (if not, quietly ignore)
            AnnotatedField maskedField = fields.get(name);
            if (maskedField != null) {
                _addOrOverrideAnnotations(maskedField, mixinField.getDeclaredAnnotations());
            }
        }
    }
}

protected EnumResolver<?> constructEnumResolver(Class<?> enumClass,
        DeserializationConfig config, AnnotatedMethod jsonValueMethod)
{
    if (jsonValueMethod != null) {
        Method accessor = jsonValueMethod.getAnnotated();
        if (config.canOverrideAccessModifiers()) {
            ClassUtil.checkAndFixAccess(accessor);
        }
        return EnumResolver.constructUnsafeUsingMethod(enumClass, accessor);
    }
    // [JACKSON-212]: may need to use Enum.toString()
    if (config.isEnabled(DeserializationFeature.READ_ENUMS_USING_TO_STRING)) {
        return EnumResolver.constructUnsafeUsingToString(enumClass);
    }
    return EnumResolver.constructUnsafe(enumClass, config.getAnnotationIntrospector());
}

@Override
public Class<?> deserialize(JsonParser jp, DeserializationContext ctxt)
    throws IOException, JsonProcessingException
{
    JsonToken curr = jp.getCurrentToken();
    // Currently will only accept if given simple class name
    if (curr == JsonToken.VALUE_STRING) {
        String className = jp.getText().trim();
        try {
            return ctxt.findClass(className);
        } catch (Exception e) {
            throw ctxt.instantiationException(_valueClass, ClassUtil.getRootCause(e));
        }
    }
    throw ctxt.mappingException(_valueClass, curr);
}

/**
 * Factory method used when Enum instances are to be deserialized
 * using a creator (static factory method)
 * 
 * @return Deserializer based on given factory method, if type was suitable;
 *  null if type can not be used
 */
public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig config,
        Class<?> enumClass, AnnotatedMethod factory)
{

    // note: caller has verified there's just one arg; but we must verify its type
    Class<?> paramClass = factory.getRawParameterType(0);
    if (paramClass == String.class) {
        paramClass = null;
    } else  if (paramClass == Integer.TYPE || paramClass == Integer.class) {
        paramClass = Integer.class;
    } else  if (paramClass == Long.TYPE || paramClass == Long.class) {
        paramClass = Long.class;
    } else {
        throw new IllegalArgumentException("Parameter #0 type for factory method ("+factory
                +") not suitable, must be java.lang.String or int/Integer/long/Long");
    }
    if (config.canOverrideAccessModifiers()) {
        ClassUtil.checkAndFixAccess(factory.getMember());
    }
    return new FactoryBasedDeserializer(enumClass, factory, paramClass);
}

@Override
public Object deserialize(JsonParser jp, DeserializationContext ctxt)
    throws IOException, JsonProcessingException
{
    // couple of accepted types...
    Object value;
    if (_inputType == null) {
        value = jp.getText();
    } else  if (_inputType == Integer.class) {
        value = Integer.valueOf(jp.getValueAsInt());
    } else  if (_inputType == Long.class) {
        value = Long.valueOf(jp.getValueAsLong());
    } else {
        throw ctxt.mappingException(_enumClass);
    }
    try {
        return _factory.invoke(_enumClass, value);
    } catch (Exception e) {
        ClassUtil.unwrapAndThrowAsIAE(e);
    }
    return null;
}

@Override
public ObjectIdGenerator<?> objectIdGeneratorInstance(Annotated annotated,
        ObjectIdInfo objectIdInfo)
    throws JsonMappingException
{
    Class<?> implClass = objectIdInfo.getGeneratorType();
    HandlerInstantiator hi = _config.getHandlerInstantiator();
    ObjectIdGenerator<?> gen;

    if (hi != null) {
        gen = hi.objectIdGeneratorInstance(_config, annotated, implClass);
    } else {
        gen = (ObjectIdGenerator<?>) ClassUtil.createInstance(implClass,
                _config.canOverrideAccessModifiers());
    }
    return gen.forScope(objectIdInfo.getScope());
}

@Override
public void deserializeAndSet(JsonParser jp, DeserializationContext ctxt,
        Object bean)
    throws IOException, JsonProcessingException
{
    JsonToken t = jp.getCurrentToken();
    Object value;
    if (t == JsonToken.VALUE_NULL) {
        value = (_nullProvider == null) ? null : _nullProvider.nullValue(ctxt);
    } else if (_valueTypeDeserializer != null) {
        value = _valueDeserializer.deserializeWithType(jp, ctxt, _valueTypeDeserializer);
    } else  { // the usual case
        try {
            value = _creator.newInstance(bean);
        } catch (Exception e) {
            ClassUtil.unwrapAndThrowAsIAE(e, "Failed to instantiate class "+_creator.getDeclaringClass().getName()+", problem: "+e.getMessage());
            value = null;
        }
        _valueDeserializer.deserialize(jp, ctxt, value);
    }
    set(bean, value);
}

/**
 * Helper method used to skip processing for types that we know
 * can not be (i.e. are never consider to be) beans: 
 * things like primitives, Arrays, Enums, and proxy types.
 *<p>
 * Note that usually we shouldn't really be getting these sort of
 * types anyway; but better safe than sorry.
 */
protected boolean isPotentialBeanType(Class<?> type)
{
    String typeStr = ClassUtil.canBeABeanType(type);
    if (typeStr != null) {
        throw new IllegalArgumentException("Can not deserialize Class "+type.getName()+" (of type "+typeStr+") as a Bean");
    }
    if (ClassUtil.isProxyType(type)) {
        throw new IllegalArgumentException("Can not deserialize Proxy class "+type.getName()+" as a Bean");
    }
    /* also: can't deserialize some local classes: static are ok; in-method not;
     * and with [JACKSON-594], other non-static inner classes are ok
     */
    typeStr = ClassUtil.isLocalType(type, true);
    if (typeStr != null) {
        throw new IllegalArgumentException("Can not deserialize Class "+type.getName()+" (of type "+typeStr+") as a Bean");
    }
    return true;
}

protected void _reportIncompatibleRootType(Object value, JavaType rootType)
    throws IOException, JsonProcessingException
{
    /* 07-Jan-2010, tatu: As per [JACKSON-456] better handle distinction between wrapper types,
     *    primitives
     */
    if (rootType.isPrimitive()) {
        Class<?> wrapperType = ClassUtil.wrapperType(rootType.getRawClass());
        // If it's just difference between wrapper, primitive, let it slide
        if (wrapperType.isAssignableFrom(value.getClass())) {
            return;
        }
    }
    throw new JsonMappingException("Incompatible types: declared root type ("+rootType+") vs "
            +value.getClass().getName());
}

@Override
protected Class<?> _deserialize(final String value, final DeserializationContext ctxt) throws IOException {
    try {
        return ctxt.findClass(SimpleClassNameIdResolver.getClassName(value));
    } catch (final Exception e) {
        throw ctxt.instantiationException(_valueClass, ClassUtil.getRootCause(e));
    }
}

@SuppressWarnings("unchecked")
private Optional<ClassMappingInternal<Object>> getClassMappingFromSuperTypes(Class<?> type, ClassesMapping serOrDeserClassesMapping, ClassesMapping mergedClassesMapping) {
    List<Class<?>> superTypes = ClassUtil.findSuperTypes(type, Object.class);
    Collections.reverse(superTypes);
    return Stream.concat(Stream.of(Object.class), superTypes.stream())
            .map(superType -> (Class<Object>) superType)
            .map(superType -> Optional.ofNullable(
                            mergedClassesMapping.getOpt(superType)
                                    .orElseGet(() -> mergeAndPutInMergedClassesMapping(mergedClassesMapping, superType,
                                            serOrDeserClassesMapping.getOpt(superType),
                                            classesMappingByOperation.get(ANY).getOpt(superType))))
            )
            .reduce(Optional.empty(), Mergeable::merge);
}

public TypeIdResolver typeIdResolverInstance(Annotated paramAnnotated, Class<? extends TypeIdResolver> paramClass)
{
  HandlerInstantiator localHandlerInstantiator = getHandlerInstantiator();
  if (localHandlerInstantiator != null)
  {
    TypeIdResolver localTypeIdResolver = localHandlerInstantiator.typeIdResolverInstance(this, paramAnnotated, paramClass);
    if (localTypeIdResolver != null)
      return localTypeIdResolver;
  }
  return (TypeIdResolver)ClassUtil.createInstance(paramClass, canOverrideAccessModifiers());
}

public TypeResolverBuilder<?> typeResolverBuilderInstance(Annotated paramAnnotated, Class<? extends TypeResolverBuilder<?>> paramClass)
{
  HandlerInstantiator localHandlerInstantiator = getHandlerInstantiator();
  if (localHandlerInstantiator != null)
  {
    TypeResolverBuilder localTypeResolverBuilder = localHandlerInstantiator.typeResolverBuilderInstance(this, paramAnnotated, paramClass);
    if (localTypeResolverBuilder != null)
      return localTypeResolverBuilder;
  }
  return (TypeResolverBuilder)ClassUtil.createInstance(paramClass, canOverrideAccessModifiers());
}

protected final String _idFrom(Object paramObject, Class<?> paramClass)
{
  if ((Enum.class.isAssignableFrom(paramClass)) && (!paramClass.isEnum()))
    paramClass = paramClass.getSuperclass();
  String str1 = paramClass.getName();
  String str2 = str1;
  if (str1.startsWith("java.util"))
  {
    if ((paramObject instanceof EnumSet))
    {
      Class localClass2 = ClassUtil.findEnumType((EnumSet)paramObject);
      return TypeFactory.defaultInstance().constructCollectionType(EnumSet.class, localClass2).toCanonical();
    }
    if ((paramObject instanceof EnumMap))
    {
      Class localClass1 = ClassUtil.findEnumType((EnumMap)paramObject);
      return TypeFactory.defaultInstance().constructMapType(EnumMap.class, localClass1, Object.class).toCanonical();
    }
    String str3 = str2.substring(9);
    if (((str3.startsWith(".Arrays$")) || (str3.startsWith(".Collections$"))) && (str2.indexOf("List") >= 0))
      str2 = "java.util.ArrayList";
    return str2;
  }
  if ((str2.indexOf('$') >= 0) && (ClassUtil.getOuterClass(paramClass) != null) && (ClassUtil.getOuterClass(this._baseType.getRawClass()) == null))
    str2 = this._baseType.getRawClass().getName();
  return str2;
}

public JsonSerializer<Object> serializerInstance(Annotated paramAnnotated, Object paramObject)
{
  if (paramObject == null)
    return null;
  Object localObject;
  if ((paramObject instanceof JsonSerializer))
  {
    localObject = (JsonSerializer)paramObject;
  }
  else
  {
    if (!(paramObject instanceof Class))
      throw new IllegalStateException("AnnotationIntrospector returned serializer definition of type " + paramObject.getClass().getName() + "; expected type JsonSerializer or Class<JsonSerializer> instead");
    Class localClass = (Class)paramObject;
    if ((localClass == JsonSerializer.None.class) || (localClass == NoClass.class))
      return null;
    if (!JsonSerializer.class.isAssignableFrom(localClass))
      throw new IllegalStateException("AnnotationIntrospector returned Class " + localClass.getName() + "; expected Class<JsonSerializer>");
    HandlerInstantiator localHandlerInstantiator = this._config.getHandlerInstantiator();
    JsonSerializer localJsonSerializer;
    if (localHandlerInstantiator == null)
      localJsonSerializer = null;
    else
      localJsonSerializer = localHandlerInstantiator.serializerInstance(this._config, paramAnnotated, localClass);
    localObject = localJsonSerializer;
    if (localJsonSerializer == null)
      localObject = (JsonSerializer)ClassUtil.createInstance(localClass, this._config.canOverrideAccessModifiers());
  }
  return _handleResolvable((JsonSerializer)localObject);
}

protected final JsonSerializer<?> findSerializerByAnnotations(SerializerProvider paramSerializerProvider, JavaType paramJavaType, BeanDescription paramBeanDescription)
{
  if (JsonSerializable.class.isAssignableFrom(paramJavaType.getRawClass()))
    return SerializableSerializer.instance;
  AnnotatedMethod localAnnotatedMethod = paramBeanDescription.findJsonValueMethod();
  if (localAnnotatedMethod != null)
  {
    Method localMethod = localAnnotatedMethod.getAnnotated();
    if (paramSerializerProvider.canOverrideAccessModifiers())
      ClassUtil.checkAndFixAccess(localMethod);
    return new JsonValueSerializer(localMethod, findSerializerFromAnnotation(paramSerializerProvider, localAnnotatedMethod));
  }
  return null;
}

protected final void _addClassMixIns(AnnotationMap paramAnnotationMap, Class<?> paramClass1, Class<?> paramClass2)
{
  if (paramClass2 == null)
    return;
  _addAnnotationsIfNotPresent(paramAnnotationMap, paramClass2.getDeclaredAnnotations());
  Iterator localIterator = ClassUtil.findSuperTypes(paramClass2, paramClass1).iterator();
  while (localIterator.hasNext())
    _addAnnotationsIfNotPresent(paramAnnotationMap, ((Class)localIterator.next()).getDeclaredAnnotations());
}

protected final void _addFieldMixIns(Class<?> paramClass1, Class<?> paramClass2, Map<String, AnnotatedField> paramMap)
{
  ArrayList localArrayList = new ArrayList();
  localArrayList.add(paramClass2);
  ClassUtil.findSuperTypes(paramClass2, paramClass1, localArrayList);
  Iterator localIterator = localArrayList.iterator();
  while (localIterator.hasNext())
    for (Field localField : ((Class)localIterator.next()).getDeclaredFields())
      if (_isIncludableField(localField))
      {
        AnnotatedField localAnnotatedField = (AnnotatedField)paramMap.get(localField.getName());
        if (localAnnotatedField != null)
          _addOrOverrideAnnotations(localAnnotatedField, localField.getDeclaredAnnotations());
      }
}

private KeyDeserializer _createEnumKeyDeserializer(DeserializationContext paramDeserializationContext, JavaType paramJavaType)
{
  DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig();
  BeanDescription localBeanDescription = localDeserializationConfig.introspect(paramJavaType);
  JsonDeserializer localJsonDeserializer = findDeserializerFromAnnotation(paramDeserializationContext, localBeanDescription.getClassInfo());
  if (localJsonDeserializer != null)
    return StdKeyDeserializers.constructDelegatingKeyDeserializer(localDeserializationConfig, paramJavaType, localJsonDeserializer);
  Class localClass = paramJavaType.getRawClass();
  if (_findCustomEnumDeserializer(localClass, localDeserializationConfig, localBeanDescription) != null)
    return StdKeyDeserializers.constructDelegatingKeyDeserializer(localDeserializationConfig, paramJavaType, localJsonDeserializer);
  EnumResolver localEnumResolver = constructEnumResolver(localClass, localDeserializationConfig, localBeanDescription.findJsonValueMethod());
  Iterator localIterator = localBeanDescription.getFactoryMethods().iterator();
  while (localIterator.hasNext())
  {
    AnnotatedMethod localAnnotatedMethod = (AnnotatedMethod)localIterator.next();
    if (localDeserializationConfig.getAnnotationIntrospector().hasCreatorAnnotation(localAnnotatedMethod))
    {
      if ((localAnnotatedMethod.getParameterCount() == 1) && (localAnnotatedMethod.getRawReturnType().isAssignableFrom(localClass)))
      {
        if (localAnnotatedMethod.getGenericParameterType(0) != String.class)
          throw new IllegalArgumentException("Parameter #0 type for factory method (" + localAnnotatedMethod + ") not suitable, must be java.lang.String");
        if (localDeserializationConfig.canOverrideAccessModifiers())
          ClassUtil.checkAndFixAccess(localAnnotatedMethod.getMember());
        return StdKeyDeserializers.constructEnumKeyDeserializer(localEnumResolver, localAnnotatedMethod);
      }
      throw new IllegalArgumentException("Unsuitable method (" + localAnnotatedMethod + ") decorated with @JsonCreator (for Enum type " + localClass.getName() + ")");
    }
  }
  return StdKeyDeserializers.constructEnumKeyDeserializer(localEnumResolver);
}

protected EnumResolver<?> constructEnumResolver(Class<?> paramClass, DeserializationConfig paramDeserializationConfig, AnnotatedMethod paramAnnotatedMethod)
{
  if (paramAnnotatedMethod != null)
  {
    Method localMethod = paramAnnotatedMethod.getAnnotated();
    if (paramDeserializationConfig.canOverrideAccessModifiers())
      ClassUtil.checkAndFixAccess(localMethod);
    return EnumResolver.constructUnsafeUsingMethod(paramClass, localMethod);
  }
  if (paramDeserializationConfig.isEnabled(DeserializationFeature.READ_ENUMS_USING_TO_STRING))
    return EnumResolver.constructUnsafeUsingToString(paramClass);
  return EnumResolver.constructUnsafe(paramClass, paramDeserializationConfig.getAnnotationIntrospector());
}

public KeyDeserializer findKeyDeserializer(JavaType paramJavaType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription)
{
  Class localClass1 = paramJavaType.getRawClass();
  Class localClass2 = localClass1;
  if ((localClass1 == String.class) || (localClass2 == Object.class))
    return StdKeyDeserializer.StringKD.forType(localClass2);
  if (localClass2 == UUID.class)
    return new StdKeyDeserializer.UuidKD();
  if (localClass2.isPrimitive())
    localClass2 = ClassUtil.wrapperType(localClass2);
  if (localClass2 == Integer.class)
    return new StdKeyDeserializer.IntKD();
  if (localClass2 == Long.class)
    return new StdKeyDeserializer.LongKD();
  if (localClass2 == Date.class)
    return new StdKeyDeserializer.DateKD();
  if (localClass2 == Calendar.class)
    return new StdKeyDeserializer.CalendarKD();
  if (localClass2 == Boolean.class)
    return new StdKeyDeserializer.BoolKD();
  if (localClass2 == Byte.class)
    return new StdKeyDeserializer.ByteKD();
  if (localClass2 == Character.class)
    return new StdKeyDeserializer.CharKD();
  if (localClass2 == Short.class)
    return new StdKeyDeserializer.ShortKD();
  if (localClass2 == Float.class)
    return new StdKeyDeserializer.FloatKD();
  if (localClass2 == Double.class)
    return new StdKeyDeserializer.DoubleKD();
  if (localClass2 == Locale.class)
    return new StdKeyDeserializer.LocaleKD();
  return null;
}

public final void deserializeAndSet(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext, Object paramObject)
{
  Object localObject;
  if (paramJsonParser.getCurrentToken() == JsonToken.VALUE_NULL)
  {
    if (this._nullProvider == null)
      localObject = null;
    else
      localObject = this._nullProvider.nullValue(paramDeserializationContext);
  }
  else if (this._valueTypeDeserializer != null)
  {
    localObject = this._valueDeserializer.deserializeWithType(paramJsonParser, paramDeserializationContext, this._valueTypeDeserializer);
  }
  else
  {
    try
    {
      localObject = this._creator.newInstance(new Object[] { paramObject });
    }
    catch (Exception localException)
    {
      ClassUtil.unwrapAndThrowAsIAE(localException, "Failed to instantiate class " + this._creator.getDeclaringClass().getName() + ", problem: " + localException.getMessage());
      localObject = null;
    }
    this._valueDeserializer.deserialize(paramJsonParser, paramDeserializationContext, localObject);
  }
  set(paramObject, localObject);
}

public static PropertyBasedCreator construct(DeserializationContext paramDeserializationContext, ValueInstantiator paramValueInstantiator, SettableBeanProperty[] paramArrayOfSettableBeanProperty)
{
  int i = paramArrayOfSettableBeanProperty.length;
  SettableBeanProperty[] arrayOfSettableBeanProperty = new SettableBeanProperty[i];
  Object[] arrayOfObject = null;
  for (int j = 0; j < i; j++)
  {
    SettableBeanProperty localSettableBeanProperty1 = paramArrayOfSettableBeanProperty[j];
    SettableBeanProperty localSettableBeanProperty2 = localSettableBeanProperty1;
    if (!localSettableBeanProperty1.hasValueDeserializer())
      localSettableBeanProperty2 = localSettableBeanProperty2.withValueDeserializer(paramDeserializationContext.findContextualValueDeserializer(localSettableBeanProperty2.getType(), localSettableBeanProperty2));
    arrayOfSettableBeanProperty[j] = localSettableBeanProperty2;
    JsonDeserializer localJsonDeserializer = localSettableBeanProperty2.getValueDeserializer();
    Object localObject1;
    if (localJsonDeserializer == null)
      localObject1 = null;
    else
      localObject1 = localJsonDeserializer.getNullValue();
    Object localObject2 = localObject1;
    if ((localObject1 == null) && (localSettableBeanProperty2.getType().isPrimitive()))
      localObject2 = ClassUtil.defaultValue(localSettableBeanProperty2.getType().getRawClass());
    if (localObject2 != null)
    {
      if (arrayOfObject == null)
        arrayOfObject = new Object[i];
      arrayOfObject[j] = localObject2;
    }
  }
  return new PropertyBasedCreator(paramValueInstantiator, arrayOfSettableBeanProperty, arrayOfObject);
}

protected JsonDeserializer<Object> buildBuilderBasedDeserializer(DeserializationContext paramDeserializationContext, JavaType paramJavaType, BeanDescription paramBeanDescription)
{
  ValueInstantiator localValueInstantiator = findValueInstantiator(paramDeserializationContext, paramBeanDescription);
  DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig();
  BeanDeserializerBuilder localBeanDeserializerBuilder1 = constructBeanDeserializerBuilder(paramDeserializationContext, paramBeanDescription);
  BeanDeserializerBuilder localBeanDeserializerBuilder2 = localBeanDeserializerBuilder1;
  localBeanDeserializerBuilder1.setValueInstantiator(localValueInstantiator);
  addBeanProps(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2);
  addObjectIdReader(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2);
  addReferenceProperties(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2);
  addInjectables(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2);
  JsonPOJOBuilder.Value localValue = paramBeanDescription.findPOJOBuilderConfig();
  String str;
  if (localValue == null)
    str = "build";
  else
    str = localValue.buildMethodName;
  AnnotatedMethod localAnnotatedMethod = paramBeanDescription.findMethod(str, null);
  if ((localAnnotatedMethod != null) && (localDeserializationConfig.canOverrideAccessModifiers()))
    ClassUtil.checkAndFixAccess(localAnnotatedMethod.getMember());
  localBeanDeserializerBuilder2.setPOJOBuilder(localAnnotatedMethod, localValue);
  if (this._factoryConfig.hasDeserializerModifiers())
  {
    Iterator localIterator2 = this._factoryConfig.deserializerModifiers().iterator();
    while (localIterator2.hasNext())
      localBeanDeserializerBuilder2 = ((BeanDeserializerModifier)localIterator2.next()).updateBuilder(localDeserializationConfig, paramBeanDescription, localBeanDeserializerBuilder2);
  }
  JsonDeserializer localJsonDeserializer = localBeanDeserializerBuilder2.buildBuilderBased(paramJavaType, str);
  if (this._factoryConfig.hasDeserializerModifiers())
  {
    Iterator localIterator1 = this._factoryConfig.deserializerModifiers().iterator();
    while (localIterator1.hasNext())
      localJsonDeserializer = ((BeanDeserializerModifier)localIterator1.next()).modifyDeserializer(localDeserializationConfig, paramBeanDescription, localJsonDeserializer);
  }
  return localJsonDeserializer;
}