Java 类com.fasterxml.jackson.databind.type.MapLikeType 实例源码

private JsonDeserializer<io.redlink.smarti.model.config.Configuration > buildConfigurationDeserializer(ObjectMapper objectMapper) {
    return new JsonDeserializer<io.redlink.smarti.model.config.Configuration>() {
        @Override
        public io.redlink.smarti.model.config.Configuration deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {

            final TypeFactory tf = ctxt.getTypeFactory();
            final MapLikeType smartiConfigType = tf.constructMapLikeType(Map.class,
                    tf.constructType(String.class),
                    tf.constructCollectionLikeType(List.class,
                            ComponentConfiguration.class));

            final io.redlink.smarti.model.config.Configuration configuration = new io.redlink.smarti.model.config.Configuration();
            configuration.setConfig(objectMapper.readerFor(smartiConfigType).readValue(p, smartiConfigType));
            return configuration;
        }

    };
}

@Override
public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type,
                                                   DeserializationConfig config, BeanDescription beanDesc,
                                                   KeyDeserializer keyDeserializer,
                                                   TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException
{
    Class<?> raw = type.getRawClass();
    if (Map.class.isAssignableFrom(raw)) {
        return new MapDeserializer(type);
    }
    if (Multimap.class.isAssignableFrom(raw)) {
        return new MultimapDeserializer(type);
    }
    return super.findMapLikeDeserializer(type, config, beanDesc, keyDeserializer, elementTypeDeserializer, elementDeserializer);
}

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

private static HashMap<String, String> parseIdsToAccountResponse(ApiRequestResponse response) throws MeekanApiException {
    if (HttpURLConnection.HTTP_OK == response.getMeta().getCode()) {
        MapLikeType constructMapLikeType = Utils.getJSONObjectMapper().getTypeFactory()
                .constructMapLikeType(HashMap.class, String.class, String.class);
        try {
            if (response.getResponse().has("data")) {

                String data = response.getResponse().get("data").toString();
                return Utils.getJSONObjectMapper().readValue(data, constructMapLikeType);
            }
        } catch (Exception e) {
            throw new MeekanApiException(e);
        }
    } else {
        throw new MeekanApiException(response.getMeta().getErrorDetail());
    }
    return new HashMap<String, String>();
}

private JsonSerializer<io.redlink.smarti.model.config.Configuration > buildConfigurationSerializer(ObjectMapper objectMapper) {
    return new JsonSerializer<io.redlink.smarti.model.config.Configuration >() {
        @Override
        public void serialize(io.redlink.smarti.model.config.Configuration  value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
            final TypeFactory tf = provider.getTypeFactory();
            final MapLikeType smartiConfigType = tf.constructMapLikeType(Map.class,
                    tf.constructType(String.class),
                    tf.constructCollectionLikeType(List.class,
                            ComponentConfiguration.class));
            objectMapper.writerFor(smartiConfigType).writeValue(jgen, value.getConfig());
        }
    };
}

@Override
public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType 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 JsonSerializer<?> findMapLikeSerializer(SerializationConfig config,
                                               MapLikeType type, BeanDescription beanDesc,
                                               JsonSerializer<Object> keySerializer,
                                               TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) {
    Class<?> raw = type.getRawClass();
    if (Map.class.isAssignableFrom(raw)) {
        return new MapSerializer(type);
    }
    if (Multimap.class.isAssignableFrom(raw)) {
        return new MultimapSerializer(type);
    }
    return super.findMapLikeSerializer(config, type, beanDesc, keySerializer, elementTypeSerializer, elementValueSerializer);
}

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

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

protected final JsonDeserializer<?> _createDeserializer2(DeserializationContext paramDeserializationContext, DeserializerFactory paramDeserializerFactory, JavaType paramJavaType, BeanDescription paramBeanDescription)
{
  DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig();
  if (paramJavaType.isEnumType())
    return paramDeserializerFactory.createEnumDeserializer(paramDeserializationContext, paramJavaType, paramBeanDescription);
  if (paramJavaType.isContainerType())
  {
    if (paramJavaType.isArrayType())
      return paramDeserializerFactory.createArrayDeserializer(paramDeserializationContext, (ArrayType)paramJavaType, paramBeanDescription);
    if (paramJavaType.isMapLikeType())
    {
      MapLikeType localMapLikeType = (MapLikeType)paramJavaType;
      if (localMapLikeType.isTrueMapType())
        return paramDeserializerFactory.createMapDeserializer(paramDeserializationContext, (MapType)localMapLikeType, paramBeanDescription);
      return paramDeserializerFactory.createMapLikeDeserializer(paramDeserializationContext, localMapLikeType, paramBeanDescription);
    }
    if (paramJavaType.isCollectionLikeType())
    {
      JsonFormat.Value localValue = paramBeanDescription.findExpectedFormat(null);
      if ((localValue == null) || (localValue.getShape() != JsonFormat.Shape.OBJECT))
      {
        CollectionLikeType localCollectionLikeType = (CollectionLikeType)paramJavaType;
        if (localCollectionLikeType.isTrueCollectionType())
          return paramDeserializerFactory.createCollectionDeserializer(paramDeserializationContext, (CollectionType)localCollectionLikeType, paramBeanDescription);
        return paramDeserializerFactory.createCollectionLikeDeserializer(paramDeserializationContext, localCollectionLikeType, paramBeanDescription);
      }
    }
  }
  if (JsonNode.class.isAssignableFrom(paramJavaType.getRawClass()))
    return paramDeserializerFactory.createTreeDeserializer(localDeserializationConfig, paramJavaType, paramBeanDescription);
  return paramDeserializerFactory.createBeanDeserializer(paramDeserializationContext, paramJavaType, paramBeanDescription);
}

public static HashMap<String, String> getIdentifierToAccount(MeekanApi meekanApi, Collection<String> idsOfAccounts) throws MeekanApiException,
        IOException, JsonParseException, JsonMappingException {
    ApiRequestResponse response = meekanApi.getIdsToAccounts(idsOfAccounts);
    Assert.assertEquals(HttpURLConnection.HTTP_OK, (int) response.getMeta().getCode());
    MapLikeType constructMapLikeType = Utils.getJSONObjectMapper().getTypeFactory()
            .constructMapLikeType(HashMap.class, String.class, String.class);
    HashMap<String, String> identifierToAccounts = Utils.getJSONObjectMapper().readValue(response.getResponse().get("data").toString(),
            constructMapLikeType);
    return identifierToAccounts;
}

@Override
public JsonSerializer<?> findMapLikeSerializer(SerializationConfig config,
        MapLikeType type, BeanDescription beanDesc,
        JsonSerializer<Object> keySerializer,
        TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) {
    return findSerializer(config, type, beanDesc);
}

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

@Override
JavaType emulatedJavaType(JavaType type, TypeFactory typeFactory) {
    MapLikeType mapLikeType = (MapLikeType) type;
    return typeFactory.constructMapType(LinkedHashMap.class, mapLikeType.getKeyType(), mapLikeType.getContentType());
}

MaplikeDeserializer(JavaType valueType) {
    super(valueType);
    this.javaType = (MapLikeType) valueType;
}

public JsonSerializer<?> modifyMapLikeSerializer(SerializationConfig paramSerializationConfig, MapLikeType paramMapLikeType, BeanDescription paramBeanDescription, JsonSerializer<?> paramJsonSerializer)
{
  return paramJsonSerializer;
}

protected JsonSerializer<?> buildContainerSerializer(SerializerProvider paramSerializerProvider, JavaType paramJavaType, BeanDescription paramBeanDescription, boolean paramBoolean)
{
  SerializationConfig localSerializationConfig = paramSerializerProvider.getConfig();
  if ((!paramBoolean) && (paramJavaType.useStaticType()) && ((!paramJavaType.isContainerType()) || (paramJavaType.getContentType().getRawClass() != Object.class)))
    paramBoolean = true;
  TypeSerializer localTypeSerializer = createTypeSerializer(localSerializationConfig, paramJavaType.getContentType());
  if (localTypeSerializer != null)
    paramBoolean = false;
  JsonSerializer localJsonSerializer1 = _findContentSerializer(paramSerializerProvider, paramBeanDescription.getClassInfo());
  if (paramJavaType.isMapLikeType())
  {
    MapLikeType localMapLikeType1 = (MapLikeType)paramJavaType;
    JsonSerializer localJsonSerializer4 = _findKeySerializer(paramSerializerProvider, paramBeanDescription.getClassInfo());
    if (localMapLikeType1.isTrueMapType())
      return buildMapSerializer(localSerializationConfig, (MapType)localMapLikeType1, paramBeanDescription, paramBoolean, localJsonSerializer4, localTypeSerializer, localJsonSerializer1);
    Iterator localIterator3 = customSerializers().iterator();
    while (localIterator3.hasNext())
    {
      Serializers localSerializers = (Serializers)localIterator3.next();
      MapLikeType localMapLikeType2 = (MapLikeType)paramJavaType;
      JsonSerializer localJsonSerializer5 = localSerializers.findMapLikeSerializer(localSerializationConfig, localMapLikeType2, paramBeanDescription, localJsonSerializer4, localTypeSerializer, localJsonSerializer1);
      JsonSerializer localJsonSerializer6 = localJsonSerializer5;
      if (localJsonSerializer5 != null)
      {
        if (this._factoryConfig.hasSerializerModifiers())
        {
          Iterator localIterator4 = this._factoryConfig.serializerModifiers().iterator();
          while (localIterator4.hasNext())
            localJsonSerializer6 = ((BeanSerializerModifier)localIterator4.next()).modifyMapLikeSerializer(localSerializationConfig, localMapLikeType2, paramBeanDescription, localJsonSerializer6);
        }
        return localJsonSerializer6;
      }
    }
    return null;
  }
  if (paramJavaType.isCollectionLikeType())
  {
    CollectionLikeType localCollectionLikeType1 = (CollectionLikeType)paramJavaType;
    if (localCollectionLikeType1.isTrueCollectionType())
      return buildCollectionSerializer(localSerializationConfig, (CollectionType)localCollectionLikeType1, paramBeanDescription, paramBoolean, localTypeSerializer, localJsonSerializer1);
    CollectionLikeType localCollectionLikeType2 = (CollectionLikeType)paramJavaType;
    Iterator localIterator1 = customSerializers().iterator();
    while (localIterator1.hasNext())
    {
      JsonSerializer localJsonSerializer2 = ((Serializers)localIterator1.next()).findCollectionLikeSerializer(localSerializationConfig, localCollectionLikeType2, paramBeanDescription, localTypeSerializer, localJsonSerializer1);
      JsonSerializer localJsonSerializer3 = localJsonSerializer2;
      if (localJsonSerializer2 != null)
      {
        if (this._factoryConfig.hasSerializerModifiers())
        {
          Iterator localIterator2 = this._factoryConfig.serializerModifiers().iterator();
          while (localIterator2.hasNext())
            localJsonSerializer3 = ((BeanSerializerModifier)localIterator2.next()).modifyCollectionLikeSerializer(localSerializationConfig, localCollectionLikeType2, paramBeanDescription, localJsonSerializer3);
        }
        return localJsonSerializer3;
      }
    }
    return null;
  }
  if (paramJavaType.isArrayType())
    return buildArraySerializer(localSerializationConfig, (ArrayType)paramJavaType, paramBeanDescription, paramBoolean, localTypeSerializer, localJsonSerializer1);
  return null;
}

public JsonSerializer<?> findMapLikeSerializer(SerializationConfig paramSerializationConfig, MapLikeType paramMapLikeType, BeanDescription paramBeanDescription, JsonSerializer<Object> paramJsonSerializer1, TypeSerializer paramTypeSerializer, JsonSerializer<Object> paramJsonSerializer2)
{
  return null;
}

public JsonSerializer<?> findMapLikeSerializer(SerializationConfig paramSerializationConfig, MapLikeType paramMapLikeType, BeanDescription paramBeanDescription, JsonSerializer<Object> paramJsonSerializer1, TypeSerializer paramTypeSerializer, JsonSerializer<Object> paramJsonSerializer2)
{
  return findSerializer(paramSerializationConfig, paramMapLikeType, paramBeanDescription);
}

public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType paramMapLikeType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer)
{
  if (this._classMappings == null)
    return null;
  return (JsonDeserializer)this._classMappings.get(new ClassKey(paramMapLikeType.getRawClass()));
}

protected <T extends JavaType> T modifyTypeByAnnotation(DeserializationContext paramDeserializationContext, Annotated paramAnnotated, T paramT)
{
  AnnotationIntrospector localAnnotationIntrospector = paramDeserializationContext.getAnnotationIntrospector();
  Class localClass1 = localAnnotationIntrospector.findDeserializationType(paramAnnotated, paramT);
  if (localClass1 != null)
    try
    {
      paramT = paramT.narrowBy(localClass1);
    }
    catch (IllegalArgumentException localIllegalArgumentException3)
    {
      throw new JsonMappingException("Failed to narrow type " + paramT + " with concrete-type annotation (value " + localClass1.getName() + "), method '" + paramAnnotated.getName() + "': " + localIllegalArgumentException3.getMessage(), null, localIllegalArgumentException3);
    }
  if (paramT.isContainerType())
  {
    Class localClass2 = localAnnotationIntrospector.findDeserializationKeyType(paramAnnotated, paramT.getKeyType());
    if (localClass2 != null)
    {
      if (!(paramT instanceof MapLikeType))
        throw new JsonMappingException("Illegal key-type annotation: type " + paramT + " is not a Map(-like) type");
      try
      {
        paramT = ((MapLikeType)paramT).narrowKey(localClass2);
      }
      catch (IllegalArgumentException localIllegalArgumentException2)
      {
        throw new JsonMappingException("Failed to narrow key type " + paramT + " with key-type annotation (" + localClass2.getName() + "): " + localIllegalArgumentException2.getMessage(), null, localIllegalArgumentException2);
      }
    }
    JavaType localJavaType = paramT.getKeyType();
    if ((localJavaType != null) && (localJavaType.getValueHandler() == null))
    {
      KeyDeserializer localKeyDeserializer = paramDeserializationContext.keyDeserializerInstance(paramAnnotated, localAnnotationIntrospector.findKeyDeserializer(paramAnnotated));
      if (localKeyDeserializer != null)
      {
        MapLikeType localMapLikeType = ((MapLikeType)paramT).withKeyValueHandler(localKeyDeserializer);
        paramT = localMapLikeType;
        localMapLikeType.getKeyType();
      }
    }
    Class localClass3 = localAnnotationIntrospector.findDeserializationContentType(paramAnnotated, paramT.getContentType());
    if (localClass3 != null)
      try
      {
        paramT = paramT.narrowContentsBy(localClass3);
      }
      catch (IllegalArgumentException localIllegalArgumentException1)
      {
        throw new JsonMappingException("Failed to narrow content type " + paramT + " with content-type annotation (" + localClass3.getName() + "): " + localIllegalArgumentException1.getMessage(), null, localIllegalArgumentException1);
      }
    if (paramT.getContentType().getValueHandler() == null)
    {
      JsonDeserializer localJsonDeserializer = paramDeserializationContext.deserializerInstance(paramAnnotated, localAnnotationIntrospector.findContentDeserializer(paramAnnotated));
      if (localJsonDeserializer != null)
        paramT = paramT.withContentValueHandler(localJsonDeserializer);
    }
  }
  return paramT;
}

public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType paramMapLikeType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer)
{
  return null;
}

public JsonDeserializer<?> modifyMapLikeDeserializer(DeserializationConfig paramDeserializationConfig, MapLikeType paramMapLikeType, BeanDescription paramBeanDescription, JsonDeserializer<?> paramJsonDeserializer)
{
  return paramJsonDeserializer;
}

private JavaType modifyTypeByAnnotation(DeserializationContext paramDeserializationContext, Annotated paramAnnotated, JavaType paramJavaType)
{
  AnnotationIntrospector localAnnotationIntrospector = paramDeserializationContext.getAnnotationIntrospector();
  Class localClass1 = localAnnotationIntrospector.findDeserializationType(paramAnnotated, paramJavaType);
  if (localClass1 != null)
    try
    {
      paramJavaType = paramJavaType.narrowBy(localClass1);
    }
    catch (IllegalArgumentException localIllegalArgumentException3)
    {
      throw new JsonMappingException("Failed to narrow type " + paramJavaType + " with concrete-type annotation (value " + localClass1.getName() + "), method '" + paramAnnotated.getName() + "': " + localIllegalArgumentException3.getMessage(), null, localIllegalArgumentException3);
    }
  if (paramJavaType.isContainerType())
  {
    Class localClass2 = localAnnotationIntrospector.findDeserializationKeyType(paramAnnotated, paramJavaType.getKeyType());
    if (localClass2 != null)
    {
      if (!(paramJavaType instanceof MapLikeType))
        throw new JsonMappingException("Illegal key-type annotation: type " + paramJavaType + " is not a Map(-like) type");
      try
      {
        paramJavaType = ((MapLikeType)paramJavaType).narrowKey(localClass2);
      }
      catch (IllegalArgumentException localIllegalArgumentException2)
      {
        throw new JsonMappingException("Failed to narrow key type " + paramJavaType + " with key-type annotation (" + localClass2.getName() + "): " + localIllegalArgumentException2.getMessage(), null, localIllegalArgumentException2);
      }
    }
    JavaType localJavaType = paramJavaType.getKeyType();
    if ((localJavaType != null) && (localJavaType.getValueHandler() == null))
    {
      Object localObject2 = localAnnotationIntrospector.findKeyDeserializer(paramAnnotated);
      if (localObject2 != null)
      {
        KeyDeserializer localKeyDeserializer = paramDeserializationContext.keyDeserializerInstance(paramAnnotated, localObject2);
        if (localKeyDeserializer != null)
        {
          MapLikeType localMapLikeType = ((MapLikeType)paramJavaType).withKeyValueHandler(localKeyDeserializer);
          paramJavaType = localMapLikeType;
          localMapLikeType.getKeyType();
        }
      }
    }
    Class localClass3 = localAnnotationIntrospector.findDeserializationContentType(paramAnnotated, paramJavaType.getContentType());
    if (localClass3 != null)
      try
      {
        paramJavaType = paramJavaType.narrowContentsBy(localClass3);
      }
      catch (IllegalArgumentException localIllegalArgumentException1)
      {
        throw new JsonMappingException("Failed to narrow content type " + paramJavaType + " with content-type annotation (" + localClass3.getName() + "): " + localIllegalArgumentException1.getMessage(), null, localIllegalArgumentException1);
      }
    if (paramJavaType.getContentType().getValueHandler() == null)
    {
      Object localObject1 = localAnnotationIntrospector.findContentDeserializer(paramAnnotated);
      if (localObject1 != null)
      {
        boolean bool = localObject1 instanceof JsonDeserializer;
        JsonDeserializer localJsonDeserializer = null;
        if (!bool)
        {
          Class localClass4 = _verifyAsClass(localObject1, "findContentDeserializer", JsonDeserializer.None.class);
          localJsonDeserializer = null;
          if (localClass4 != null)
            localJsonDeserializer = paramDeserializationContext.deserializerInstance(paramAnnotated, localClass4);
        }
        if (localJsonDeserializer != null)
          paramJavaType = paramJavaType.withContentValueHandler(localJsonDeserializer);
      }
    }
  }
  return paramJavaType;
}

public abstract JsonSerializer<?> findMapLikeSerializer(SerializationConfig paramSerializationConfig, MapLikeType paramMapLikeType, BeanDescription paramBeanDescription, JsonSerializer<Object> paramJsonSerializer1, TypeSerializer paramTypeSerializer, JsonSerializer<Object> paramJsonSerializer2);

public abstract JsonDeserializer<?> createMapLikeDeserializer(DeserializationContext paramDeserializationContext, MapLikeType paramMapLikeType, BeanDescription paramBeanDescription);

public abstract JsonDeserializer<?> findMapLikeDeserializer(MapLikeType paramMapLikeType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer);