Java 类com.fasterxml.jackson.databind.KeyDeserializer 实例源码

public JsonDeserializer<?> createMapLikeDeserializer(DeserializationContext paramDeserializationContext, MapLikeType paramMapLikeType, BeanDescription paramBeanDescription)
{
  JavaType localJavaType1 = paramMapLikeType.getKeyType();
  JavaType localJavaType2 = paramMapLikeType.getContentType();
  DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig();
  JsonDeserializer localJsonDeserializer1 = (JsonDeserializer)localJavaType2.getValueHandler();
  KeyDeserializer localKeyDeserializer = (KeyDeserializer)localJavaType1.getValueHandler();
  TypeDeserializer localTypeDeserializer1 = (TypeDeserializer)localJavaType2.getTypeHandler();
  TypeDeserializer localTypeDeserializer2 = localTypeDeserializer1;
  if (localTypeDeserializer1 == null)
    localTypeDeserializer2 = findTypeDeserializer(localDeserializationConfig, localJavaType2);
  JsonDeserializer localJsonDeserializer2 = _findCustomMapLikeDeserializer(paramMapLikeType, localDeserializationConfig, paramBeanDescription, localKeyDeserializer, localTypeDeserializer2, localJsonDeserializer1);
  JsonDeserializer localJsonDeserializer3 = localJsonDeserializer2;
  if ((localJsonDeserializer2 != null) && (this._factoryConfig.hasDeserializerModifiers()))
  {
    Iterator localIterator = this._factoryConfig.deserializerModifiers().iterator();
    while (localIterator.hasNext())
      localJsonDeserializer3 = ((BeanDeserializerModifier)localIterator.next()).modifyMapLikeDeserializer(localDeserializationConfig, paramMapLikeType, paramBeanDescription, localJsonDeserializer3);
  }
  return localJsonDeserializer3;
}

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 JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
    KeyDeserializer keyDeser = keyDeserializer;
    JsonDeserializer<?> deser = valueDeserializer;
    TypeDeserializer typeDeser = typeDeserializerForValue;

    if ((keyDeser != null) && (deser != null) && (typeDeser == null)) {
        return this;
    }
    if (keyDeser == null) {
        keyDeser = ctxt.findKeyDeserializer(mapType.getKeyType(), property);
    }
    if (deser == null) {
        deser = ctxt.findContextualValueDeserializer(mapType.getContentType(), property);
    }
    if (typeDeser != null) {
        typeDeser = typeDeser.forProperty(property);
    }
    return withResolved(keyDeser, typeDeser, deser);
}

@SuppressWarnings("unchecked")
protected T _deserializeEntries(JsonParser jp, DeserializationContext ctxt) throws IOException {
    final KeyDeserializer keyDes = keyDeserializer;
    final JsonDeserializer<?> valueDes = valueDeserializer;
    final TypeDeserializer typeDeser = typeDeserializerForValue;

    MapF<Object, Object> map = newInstance();

    for (; jp.getCurrentToken() == JsonToken.FIELD_NAME; jp.nextToken()) {
        String fieldName = jp.getCurrentName();
        Object key = (keyDes == null) ? fieldName : keyDes.deserializeKey(fieldName, ctxt);
        JsonToken t = jp.nextToken();
        Object value;
        if (t == JsonToken.VALUE_NULL) {
            value = null;
        } else if (typeDeser == null) {
            value = valueDes.deserialize(jp, ctxt);
        } else {
            value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
        }
        map.put(key, value);
    }
    return (T) map.unmodifiable();
}

@Override
public JsonDeserializer<?> findMapDeserializer(MapType type, DeserializationConfig config,
                                               BeanDescription beanDesc, KeyDeserializer keyDeserializer,
                                               TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) {

    return forJavaType(type);
}

@Override
public JsonDeserializer<?> findMapDeserializer(MapType type,
                                               DeserializationConfig config, BeanDescription beanDesc,
                                               KeyDeserializer keyDeserializer,
                                               TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {
    return null;
}

@Override
public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type,
                                                   DeserializationConfig config, BeanDescription beanDesc,
                                                   KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer,
                                                   JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {
    return null;
}

@Override
public JsonDeserializer<?> findMapDeserializer(MapType type,
                                               DeserializationConfig config, BeanDescription beanDesc,
                                               KeyDeserializer keyDeserializer,
                                               TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {
    return null;
}

@Override
public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type,
                                                   DeserializationConfig config, BeanDescription beanDesc,
                                                   KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer,
                                                   JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {
    return null;
}

@Override
public KeyDeserializer keyDeserializerInstance(
        DeserializationConfig deserializationConfig,
        Annotated annotated,
        Class<?> keyDeserializerClass) {
    return null;
}

@Override
public KeyDeserializer keyDeserializerInstance(
        DeserializationConfig deserializationConfig,
        Annotated annotated,
        Class<?> keyDeserializerClass) {
    return null;
}

@Override
public KeyDeserializer findKeyDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException {
    final Class<?> candidateTT = type.getRawClass();
    if (MetaTinyTypes.isTinyType(candidateTT)) {
        return new TinyTypesKeyDeserializer(candidateTT);
    }

    return null;
}

@Theory
public void yieldsKeyDeserializerForAnyKindOfTinyType(Class<?> tinyType) throws JsonMappingException {
    final JavaType tinyTypeType = TypeFactory.defaultInstance().uncheckedSimpleType(tinyType);
    final KeyDeserializer got = new TinyTypesKeyDeserializers().findKeyDeserializer(tinyTypeType, null, null);
    Assert.assertNotNull(got);

}

public SimpleKeyDeserializers addDeserializer(Class<?> paramClass, KeyDeserializer paramKeyDeserializer)
{
  if (this._classMappings == null)
    this._classMappings = new HashMap();
  this._classMappings.put(new ClassKey(paramClass), paramKeyDeserializer);
  return this;
}

public SimpleModule addKeyDeserializer(Class<?> paramClass, KeyDeserializer paramKeyDeserializer)
{
  if (this._keyDeserializers == null)
    this._keyDeserializers = new SimpleKeyDeserializers();
  this._keyDeserializers.addDeserializer(paramClass, paramKeyDeserializer);
  return this;
}

public Class<? extends KeyDeserializer> findKeyDeserializer(Annotated paramAnnotated)
{
  JsonDeserialize localJsonDeserialize = (JsonDeserialize)paramAnnotated.getAnnotation(JsonDeserialize.class);
  if (localJsonDeserialize != null)
  {
    Class localClass = localJsonDeserialize.keyUsing();
    if (localClass != KeyDeserializer.None.class)
      return localClass;
  }
  return null;
}

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 JsonDeserializer<?> _findCustomMapDeserializer(MapType paramMapType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer)
{
  Iterator localIterator = this._factoryConfig.deserializers().iterator();
  while (localIterator.hasNext())
  {
    JsonDeserializer localJsonDeserializer = ((Deserializers)localIterator.next()).findMapDeserializer(paramMapType, paramDeserializationConfig, paramBeanDescription, paramKeyDeserializer, paramTypeDeserializer, paramJsonDeserializer);
    if (localJsonDeserializer != null)
      return localJsonDeserializer;
  }
  return null;
}

protected JsonDeserializer<?> _findCustomMapLikeDeserializer(MapLikeType paramMapLikeType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer)
{
  Iterator localIterator = this._factoryConfig.deserializers().iterator();
  while (localIterator.hasNext())
  {
    JsonDeserializer localJsonDeserializer = ((Deserializers)localIterator.next()).findMapLikeDeserializer(paramMapLikeType, paramDeserializationConfig, paramBeanDescription, paramKeyDeserializer, paramTypeDeserializer, paramJsonDeserializer);
    if (localJsonDeserializer != null)
      return localJsonDeserializer;
  }
  return null;
}

public KeyDeserializer createKeyDeserializer(DeserializationContext paramDeserializationContext, JavaType paramJavaType)
{
  DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig();
  boolean bool = this._factoryConfig.hasKeyDeserializers();
  Object localObject = null;
  if (bool)
  {
    BeanDescription localBeanDescription = localDeserializationConfig.introspectClassAnnotations(paramJavaType.getRawClass());
    Iterator localIterator2 = this._factoryConfig.keyDeserializers().iterator();
    KeyDeserializer localKeyDeserializer;
    do
    {
      if (!localIterator2.hasNext())
        break;
      localKeyDeserializer = ((KeyDeserializers)localIterator2.next()).findKeyDeserializer(paramJavaType, localDeserializationConfig, localBeanDescription);
      localObject = localKeyDeserializer;
    }
    while (localKeyDeserializer == null);
  }
  if (localObject == null)
  {
    if (paramJavaType.isEnumType())
      return _createEnumKeyDeserializer(paramDeserializationContext, paramJavaType);
    localObject = StdKeyDeserializers.findStringBasedKeyDeserializer(localDeserializationConfig, paramJavaType);
  }
  if ((localObject != null) && (this._factoryConfig.hasDeserializerModifiers()))
  {
    Iterator localIterator1 = this._factoryConfig.deserializerModifiers().iterator();
    while (localIterator1.hasNext())
      localObject = ((BeanDeserializerModifier)localIterator1.next()).modifyKeyDeserializer(localDeserializationConfig, paramJavaType, (KeyDeserializer)localObject);
  }
  return localObject;
}

protected JavaType resolveType(DeserializationContext paramDeserializationContext, BeanDescription paramBeanDescription, JavaType paramJavaType, AnnotatedMember paramAnnotatedMember)
{
  if (paramJavaType.isContainerType())
  {
    AnnotationIntrospector localAnnotationIntrospector = paramDeserializationContext.getAnnotationIntrospector();
    if (paramJavaType.getKeyType() != null)
    {
      KeyDeserializer localKeyDeserializer = paramDeserializationContext.keyDeserializerInstance(paramAnnotatedMember, localAnnotationIntrospector.findKeyDeserializer(paramAnnotatedMember));
      if (localKeyDeserializer != null)
      {
        MapLikeType localMapLikeType = ((MapLikeType)paramJavaType).withKeyValueHandler(localKeyDeserializer);
        paramJavaType = localMapLikeType;
        localMapLikeType.getKeyType();
      }
    }
    JsonDeserializer localJsonDeserializer = paramDeserializationContext.deserializerInstance(paramAnnotatedMember, localAnnotationIntrospector.findContentDeserializer(paramAnnotatedMember));
    if (localJsonDeserializer != null)
      paramJavaType = paramJavaType.withContentValueHandler(localJsonDeserializer);
    if ((paramAnnotatedMember instanceof AnnotatedMember))
    {
      TypeDeserializer localTypeDeserializer2 = findPropertyContentTypeDeserializer(paramDeserializationContext.getConfig(), paramJavaType, paramAnnotatedMember);
      if (localTypeDeserializer2 != null)
        paramJavaType = paramJavaType.withContentTypeHandler(localTypeDeserializer2);
    }
  }
  TypeDeserializer localTypeDeserializer1;
  if ((paramAnnotatedMember instanceof AnnotatedMember))
    localTypeDeserializer1 = findPropertyTypeDeserializer(paramDeserializationContext.getConfig(), paramJavaType, paramAnnotatedMember);
  else
    localTypeDeserializer1 = findTypeDeserializer(paramDeserializationContext.getConfig(), paramJavaType);
  if (localTypeDeserializer1 != null)
    paramJavaType = paramJavaType.withTypeHandler(localTypeDeserializer1);
  return paramJavaType;
}

public MapDeserializer(JavaType paramJavaType, ValueInstantiator paramValueInstantiator, KeyDeserializer paramKeyDeserializer, JsonDeserializer<Object> paramJsonDeserializer, TypeDeserializer paramTypeDeserializer)
{
  super(Map.class);
  this._mapType = paramJavaType;
  this._keyDeserializer = paramKeyDeserializer;
  this._valueDeserializer = paramJsonDeserializer;
  this._valueTypeDeserializer = paramTypeDeserializer;
  this._valueInstantiator = paramValueInstantiator;
  this._hasDefaultCreator = paramValueInstantiator.canCreateUsingDefault();
  this._delegateDeserializer = null;
  this._propertyBasedCreator = null;
  this._standardStringKey = _isStdKeyDeser(paramJavaType, paramKeyDeserializer);
}

protected MapDeserializer(MapDeserializer paramMapDeserializer, KeyDeserializer paramKeyDeserializer, JsonDeserializer<Object> paramJsonDeserializer, TypeDeserializer paramTypeDeserializer, HashSet<String> paramHashSet)
{
  super(paramMapDeserializer._valueClass);
  this._mapType = paramMapDeserializer._mapType;
  this._keyDeserializer = paramKeyDeserializer;
  this._valueDeserializer = paramJsonDeserializer;
  this._valueTypeDeserializer = paramTypeDeserializer;
  this._valueInstantiator = paramMapDeserializer._valueInstantiator;
  this._propertyBasedCreator = paramMapDeserializer._propertyBasedCreator;
  this._delegateDeserializer = paramMapDeserializer._delegateDeserializer;
  this._hasDefaultCreator = paramMapDeserializer._hasDefaultCreator;
  this._ignorableProperties = paramHashSet;
  this._standardStringKey = _isStdKeyDeser(this._mapType, paramKeyDeserializer);
}

protected final boolean _isStdKeyDeser(JavaType paramJavaType, KeyDeserializer paramKeyDeserializer)
{
  if (paramKeyDeserializer == null)
    return true;
  JavaType localJavaType = paramJavaType.getKeyType();
  if (localJavaType == null)
    return true;
  Class localClass = localJavaType.getRawClass();
  return ((localClass == String.class) || (localClass == Object.class)) && (isDefaultKeyDeserializer(paramKeyDeserializer));
}

protected final void _readAndBind(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext, Map<Object, Object> paramMap)
{
  JsonToken localJsonToken1 = paramJsonParser.getCurrentToken();
  JsonToken localJsonToken2 = localJsonToken1;
  if (localJsonToken1 == JsonToken.START_OBJECT)
    localJsonToken2 = paramJsonParser.nextToken();
  KeyDeserializer localKeyDeserializer = this._keyDeserializer;
  JsonDeserializer localJsonDeserializer = this._valueDeserializer;
  TypeDeserializer localTypeDeserializer = this._valueTypeDeserializer;
  while (localJsonToken2 == JsonToken.FIELD_NAME)
  {
    String str = paramJsonParser.getCurrentName();
    Object localObject1 = localKeyDeserializer.deserializeKey(str, paramDeserializationContext);
    JsonToken localJsonToken3 = paramJsonParser.nextToken();
    if ((this._ignorableProperties != null) && (this._ignorableProperties.contains(str)))
    {
      paramJsonParser.skipChildren();
    }
    else
    {
      Object localObject2;
      if (localJsonToken3 == JsonToken.VALUE_NULL)
        localObject2 = null;
      else if (localTypeDeserializer == null)
        localObject2 = localJsonDeserializer.deserialize(paramJsonParser, paramDeserializationContext);
      else
        localObject2 = localJsonDeserializer.deserializeWithType(paramJsonParser, paramDeserializationContext, localTypeDeserializer);
      paramMap.put(localObject1, localObject2);
    }
    localJsonToken2 = paramJsonParser.nextToken();
  }
}

public JsonDeserializer<?> createContextual(DeserializationContext paramDeserializationContext, BeanProperty paramBeanProperty)
{
  KeyDeserializer localKeyDeserializer1 = this._keyDeserializer;
  KeyDeserializer localKeyDeserializer2 = localKeyDeserializer1;
  if (localKeyDeserializer1 == null)
    localKeyDeserializer2 = paramDeserializationContext.findKeyDeserializer(this._mapType.getKeyType(), paramBeanProperty);
  else if ((localKeyDeserializer2 instanceof ContextualKeyDeserializer))
    localKeyDeserializer2 = ((ContextualKeyDeserializer)localKeyDeserializer2).createContextual(paramDeserializationContext, paramBeanProperty);
  JsonDeserializer localJsonDeserializer1 = findConvertingContentDeserializer(paramDeserializationContext, paramBeanProperty, this._valueDeserializer);
  JsonDeserializer localJsonDeserializer2 = localJsonDeserializer1;
  if (localJsonDeserializer1 == null)
    localJsonDeserializer2 = paramDeserializationContext.findContextualValueDeserializer(this._mapType.getContentType(), paramBeanProperty);
  else if ((localJsonDeserializer2 instanceof ContextualDeserializer))
    localJsonDeserializer2 = ((ContextualDeserializer)localJsonDeserializer2).createContextual(paramDeserializationContext, paramBeanProperty);
  TypeDeserializer localTypeDeserializer1 = this._valueTypeDeserializer;
  TypeDeserializer localTypeDeserializer2 = localTypeDeserializer1;
  if (localTypeDeserializer1 != null)
    localTypeDeserializer2 = localTypeDeserializer2.forProperty(paramBeanProperty);
  Object localObject = this._ignorableProperties;
  AnnotationIntrospector localAnnotationIntrospector = paramDeserializationContext.getAnnotationIntrospector();
  if ((localAnnotationIntrospector != null) && (paramBeanProperty != null))
  {
    String[] arrayOfString = localAnnotationIntrospector.findPropertiesToIgnore(paramBeanProperty.getMember());
    if (arrayOfString != null)
    {
      HashSet localHashSet;
      if (localObject == null)
        localHashSet = new HashSet();
      else
        localHashSet = new HashSet((Collection)localObject);
      localObject = localHashSet;
      int i = arrayOfString.length;
      for (int j = 0; j < i; j++)
        ((HashSet)localObject).add(arrayOfString[j]);
    }
  }
  return withResolved(localKeyDeserializer2, localTypeDeserializer2, localJsonDeserializer2, (HashSet)localObject);
}

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 KeyDeserializer findKeyDeserializer(DeserializationContext paramDeserializationContext, DeserializerFactory paramDeserializerFactory, JavaType paramJavaType)
{
  KeyDeserializer localKeyDeserializer = paramDeserializerFactory.createKeyDeserializer(paramDeserializationContext, paramJavaType);
  if (localKeyDeserializer == null)
    return _handleUnknownKeyDeserializer(paramJavaType);
  if ((localKeyDeserializer instanceof ResolvableDeserializer))
    ((ResolvableDeserializer)localKeyDeserializer).resolve(paramDeserializationContext);
  return localKeyDeserializer;
}

@Override
public JsonDeserializer<?> findMapDeserializer(MapType type, DeserializationConfig config, BeanDescription beanDesc,
        KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException
{
    if (MapF.class.isAssignableFrom(type.getRawClass())) {
        return new MapFDeserializer(type, keyDeserializer, elementTypeDeserializer, elementDeserializer);
    }
    return null;
}

protected MapDeserializer(MapType type, KeyDeserializer keyDeser, TypeDeserializer typeDeser,
        JsonDeserializer<?> deser)
{
    mapType = type;
    keyDeserializer = keyDeser;
    typeDeserializerForValue = typeDeser;
    valueDeserializer = deser;
}

@Override
public KeyDeserializer createContextual( DeserializationContext ctxt, BeanProperty property ) throws JsonMappingException {
    if ( ctxt.getContextualType() == null || ctxt.getContextualType().containedType( 0 ) == null || ctxt.getContextualType().containedType( 0 ).containedType( 0 ) == null ) {
        throw JsonMappingException.from( ctxt, "Cannot deserialize Ref<T>. Cannot find the Generic Type T." );
    }
    return new RefStdKeyDeserializer( ctxt.getContextualType().containedType( 0 ).containedType( 0 ) );
}

@Override
public KeyDeserializer keyDeserializerInstance(Annotated annotated, Object deserDef)
        throws JsonMappingException {
    return this.keyDeserializerInstance(annotated, deserDef);
}

@Override
public KeyDeserializer keyDeserializerInstance(DeserializationConfig config,
        Annotated annotated, Class<?> serClass) {
    return (KeyDeserializer) this.beanFactory.createBean(serClass);
}

@Override
public Class<? extends KeyDeserializer> keyUsing() {
    return keyUsing;
}

@Override
public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type, DeserializationConfig config, BeanDescription beanDesc, KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) {
    return forJavaType(type);
}

@Override
public KeyDeserializer keyDeserializerInstance(DeserializationConfig config, Annotated annotated,
        Class<?> keyDeserClass) {
    return (KeyDeserializer) findHandlerInstance(keyDeserClass);
}

@Override
public KeyDeserializer keyDeserializerInstance(DeserializationConfig config, Annotated annotated,
                                               Class<?> keyDeserClass) {
    return (KeyDeserializer) findInstance(keyDeserClass);
}

@Override
public KeyDeserializer keyDeserializerInstance(DeserializationConfig config, Annotated annotated, Class<?> keyDeserClass) {
    return null;
}

@Override
public KeyDeserializer keyDeserializerInstance(DeserializationConfig config, Annotated annotated, Class<?> keyDeserClass) {
    return null;
}

@Override
public KeyDeserializer keyDeserializerInstance(DeserializationConfig config,
                                               Annotated annotated, Class<?> serClass) {
    return (KeyDeserializer) this.beanFactory.createBean(serClass);
}