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

@Override public JsonDeserializer<?> modifyEnumDeserializer(DeserializationConfig config,
                                                            JavaType type,
                                                            BeanDescription beanDesc,
                                                            JsonDeserializer<?> deserializer) {
    JsonDeserializer<?> delegatee = deserializer.getDelegatee();
    if (delegatee != null) {
        JsonDeserializer<?> replacementDelegatee = modifyEnumDeserializer(config, type, beanDesc, delegatee);
        return deserializer.replaceDelegatee(replacementDelegatee);
    } else if (modifyEnum && deserializer.getClass().equals(EnumDeserializer.class)) {
        EnumResolver enumResolver =
                EnumResolver.constructUnsafe(type.getRawClass(), config.getAnnotationIntrospector());
        return new CaseIgnoringEnumDeserializer(enumResolver);
    } else {
        return deserializer;
    }
}

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());
}

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 EnumDeserializer(EnumResolver<?> paramEnumResolver)
{
  super(Enum.class);
  this._resolver = paramEnumResolver;
}

public static KeyDeserializer constructEnumKeyDeserializer(EnumResolver<?> paramEnumResolver)
{
  return new StdKeyDeserializer.EnumKD(paramEnumResolver, null);
}

public static KeyDeserializer constructEnumKeyDeserializer(EnumResolver<?> paramEnumResolver, AnnotatedMethod paramAnnotatedMethod)
{
  return new StdKeyDeserializer.EnumKD(paramEnumResolver, paramAnnotatedMethod);
}

protected EnumKD(EnumResolver<?> paramEnumResolver, AnnotatedMethod paramAnnotatedMethod)
{
  super();
  this._resolver = paramEnumResolver;
  this._factory = paramAnnotatedMethod;
}

public CaseIgnoringEnumDeserializer(EnumResolver enumResolver) {
    super(enumResolver);
}

private KeyDeserializer _createEnumKeyDeserializer(DeserializationContext ctxt,
        JavaType type)
    throws JsonMappingException
{
    final DeserializationConfig config = ctxt.getConfig();
    BeanDescription beanDesc = config.introspect(type);
    JsonDeserializer<?> des = findDeserializerFromAnnotation(ctxt, beanDesc.getClassInfo());
    if (des != null) {
        return StdKeyDeserializers.constructDelegatingKeyDeserializer(config, type, des);
    }
    Class<?> enumClass = type.getRawClass();
    // 23-Nov-2010, tatu: Custom deserializer?
    JsonDeserializer<?> custom = _findCustomEnumDeserializer(enumClass, config, beanDesc);
    if (custom != null) {
        return StdKeyDeserializers.constructDelegatingKeyDeserializer(config, type, des);
    }

    EnumResolver<?> enumRes = constructEnumResolver(enumClass, config, beanDesc.findJsonValueMethod());
    // [JACKSON-193] May have @JsonCreator for static factory method:
    for (AnnotatedMethod factory : beanDesc.getFactoryMethods()) {
        if (config.getAnnotationIntrospector().hasCreatorAnnotation(factory)) {
            int argCount = factory.getParameterCount();
            if (argCount == 1) {
                Class<?> returnType = factory.getRawReturnType();
                // usually should be class, but may be just plain Enum<?> (for Enum.valueOf()?)
                if (returnType.isAssignableFrom(enumClass)) {
                    // note: mostly copied from 'EnumDeserializer.deserializerForCreator(...)'
                    if (factory.getGenericParameterType(0) != String.class) {
                        throw new IllegalArgumentException("Parameter #0 type for factory method ("+factory+") not suitable, must be java.lang.String");
                    }
                    if (config.canOverrideAccessModifiers()) {
                        ClassUtil.checkAndFixAccess(factory.getMember());
                    }
                    return StdKeyDeserializers.constructEnumKeyDeserializer(enumRes, factory);
                }
            }
            throw new IllegalArgumentException("Unsuitable method ("+factory+") decorated with @JsonCreator (for Enum type "
                    +enumClass.getName()+")");
        }
    }
    // [JACKSON-749] Also, need to consider @JsonValue, if one found
    return StdKeyDeserializers.constructEnumKeyDeserializer(enumRes);
}

public EnumDeserializer(EnumResolver<?> res)
{
    super(Enum.class);
    _resolver = res;
}

public static KeyDeserializer constructEnumKeyDeserializer(EnumResolver<?> enumResolver) {
    return new StdKeyDeserializer.EnumKD(enumResolver, null);
}

public static KeyDeserializer constructEnumKeyDeserializer(EnumResolver<?> enumResolver,
        AnnotatedMethod factory) {
    return new StdKeyDeserializer.EnumKD(enumResolver, factory);
}

protected EnumKD(EnumResolver<?> er, AnnotatedMethod factory) {
    super(er.getEnumClass());
    _resolver = er;
    _factory = factory;
}