Java 类org.codehaus.jackson.map.BeanProperty 实例源码

public JsonSerializer<Object> findBeanSerializer(SerializationConfig paramSerializationConfig, JavaType paramJavaType, BasicBeanDescription paramBasicBeanDescription, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  JsonSerializer localJsonSerializer;
  if (!isPotentialBeanType(paramJavaType.getRawClass()))
    localJsonSerializer = null;
  while (true)
  {
    return localJsonSerializer;
    localJsonSerializer = constructBeanSerializer(paramSerializationConfig, paramBasicBeanDescription, paramBeanProperty);
    if (!this._factoryConfig.hasSerializerModifiers())
      continue;
    Iterator localIterator = this._factoryConfig.serializerModifiers().iterator();
    while (localIterator.hasNext())
      localJsonSerializer = ((BeanSerializerModifier)localIterator.next()).modifySerializer(paramSerializationConfig, paramBasicBeanDescription, localJsonSerializer);
  }
}

protected JsonDeserializer<Object> findStdBeanDeserializer(DeserializationConfig paramDeserializationConfig, DeserializerProvider paramDeserializerProvider, JavaType paramJavaType, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  JsonDeserializer localJsonDeserializer1 = (JsonDeserializer)_simpleDeserializers.get(paramJavaType);
  if (localJsonDeserializer1 != null)
    return localJsonDeserializer1;
  if (AtomicReference.class.isAssignableFrom(paramJavaType.getRawClass()))
  {
    JavaType[] arrayOfJavaType = paramDeserializationConfig.getTypeFactory().findTypeParameters(paramJavaType, AtomicReference.class);
    if ((arrayOfJavaType == null) || (arrayOfJavaType.length < 1));
    for (JavaType localJavaType = TypeFactory.unknownType(); ; localJavaType = arrayOfJavaType[0])
      return new StdDeserializer.AtomicReferenceDeserializer(localJavaType, paramBeanProperty);
  }
  JsonDeserializer localJsonDeserializer2 = this.optionalHandlers.findDeserializer(paramJavaType, paramDeserializationConfig, paramDeserializerProvider);
  if (localJsonDeserializer2 != null)
    return localJsonDeserializer2;
  return null;
}

protected AsArraySerializer(Class<?> paramClass, JavaType paramJavaType, boolean paramBoolean, TypeSerializer paramTypeSerializer, BeanProperty paramBeanProperty, JsonSerializer<Object> paramJsonSerializer)
{
  super(false);
  this._elementType = paramJavaType;
  boolean bool1;
  if (!paramBoolean)
  {
    bool1 = false;
    if (paramJavaType != null)
    {
      boolean bool2 = paramJavaType.isFinal();
      bool1 = false;
      if (!bool2);
    }
  }
  else
  {
    bool1 = true;
  }
  this._staticTyping = bool1;
  this._valueTypeSerializer = paramTypeSerializer;
  this._property = paramBeanProperty;
  this._elementSerializer = paramJsonSerializer;
  this._dynamicSerializers = PropertySerializerMap.emptyMap();
}

public static MapSerializer construct(String[] paramArrayOfString, JavaType paramJavaType, boolean paramBoolean, TypeSerializer paramTypeSerializer, BeanProperty paramBeanProperty, JsonSerializer<Object> paramJsonSerializer1, JsonSerializer<Object> paramJsonSerializer2)
{
  HashSet localHashSet = toSet(paramArrayOfString);
  JavaType localJavaType2;
  JavaType localJavaType1;
  if (paramJavaType == null)
  {
    localJavaType2 = UNSPECIFIED_TYPE;
    localJavaType1 = localJavaType2;
    if (!paramBoolean)
      if ((localJavaType2 == null) || (!localJavaType2.isFinal()))
        break label75;
  }
  label75: for (paramBoolean = true; ; paramBoolean = false)
  {
    return new MapSerializer(localHashSet, localJavaType1, localJavaType2, paramBoolean, paramTypeSerializer, paramJsonSerializer1, paramJsonSerializer2, paramBeanProperty);
    localJavaType1 = paramJavaType.getKeyType();
    localJavaType2 = paramJavaType.getContentType();
    break;
  }
}

protected JsonSerializer<Object> _findExplicitUntypedSerializer(Class<?> paramClass, BeanProperty paramBeanProperty)
{
  JsonSerializer localJsonSerializer1 = this._knownSerializers.untypedValueSerializer(paramClass);
  if (localJsonSerializer1 != null)
    return localJsonSerializer1;
  JsonSerializer localJsonSerializer2 = this._serializerCache.untypedValueSerializer(paramClass);
  if (localJsonSerializer2 != null)
    return localJsonSerializer2;
  try
  {
    JsonSerializer localJsonSerializer3 = _createAndCacheUntypedSerializer(paramClass, paramBeanProperty);
    return localJsonSerializer3;
  }
  catch (Exception localException)
  {
  }
  return null;
}

public JsonSerializer<Object> findTypedValueSerializer(Class<?> paramClass, boolean paramBoolean, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  JsonSerializer localJsonSerializer1 = this._knownSerializers.typedValueSerializer(paramClass);
  if (localJsonSerializer1 != null)
    return localJsonSerializer1;
  JsonSerializer localJsonSerializer2 = this._serializerCache.typedValueSerializer(paramClass);
  if (localJsonSerializer2 != null)
    return localJsonSerializer2;
  Object localObject = findValueSerializer(paramClass, paramBeanProperty);
  TypeSerializer localTypeSerializer = this._serializerFactory.createTypeSerializer(this._config, this._config.constructType(paramClass), paramBeanProperty);
  if (localTypeSerializer != null)
    localObject = new WrappedSerializer(localTypeSerializer, (JsonSerializer)localObject);
  if (paramBoolean)
    this._serializerCache.addTypedSerializer(paramClass, (JsonSerializer)localObject);
  return (JsonSerializer<Object>)localObject;
}

public JsonSerializer<Object> findTypedValueSerializer(JavaType paramJavaType, boolean paramBoolean, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  JsonSerializer localJsonSerializer1 = this._knownSerializers.typedValueSerializer(paramJavaType);
  if (localJsonSerializer1 != null)
    return localJsonSerializer1;
  JsonSerializer localJsonSerializer2 = this._serializerCache.typedValueSerializer(paramJavaType);
  if (localJsonSerializer2 != null)
    return localJsonSerializer2;
  Object localObject = findValueSerializer(paramJavaType, paramBeanProperty);
  TypeSerializer localTypeSerializer = this._serializerFactory.createTypeSerializer(this._config, paramJavaType, paramBeanProperty);
  if (localTypeSerializer != null)
    localObject = new WrappedSerializer(localTypeSerializer, (JsonSerializer)localObject);
  if (paramBoolean)
    this._serializerCache.addTypedSerializer(paramJavaType, (JsonSerializer)localObject);
  return (JsonSerializer<Object>)localObject;
}

public JsonSerializer<Object> findValueSerializer(Class<?> paramClass, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  JsonSerializer localJsonSerializer = this._knownSerializers.untypedValueSerializer(paramClass);
  if (localJsonSerializer == null)
  {
    localJsonSerializer = this._serializerCache.untypedValueSerializer(paramClass);
    if (localJsonSerializer == null)
    {
      localJsonSerializer = this._serializerCache.untypedValueSerializer(this._config.constructType(paramClass));
      if (localJsonSerializer == null)
      {
        localJsonSerializer = _createAndCacheUntypedSerializer(paramClass, paramBeanProperty);
        if (localJsonSerializer == null)
          return getUnknownTypeSerializer(paramClass);
      }
    }
  }
  if ((localJsonSerializer instanceof ContextualSerializer))
    return ((ContextualSerializer)localJsonSerializer).createContextual(this._config, paramBeanProperty);
  return localJsonSerializer;
}

public TypeDeserializer findTypeDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType, BeanProperty paramBeanProperty)
{
  AnnotatedClass localAnnotatedClass = ((BasicBeanDescription)paramDeserializationConfig.introspectClassAnnotations(paramJavaType.getRawClass())).getClassInfo();
  AnnotationIntrospector localAnnotationIntrospector = paramDeserializationConfig.getAnnotationIntrospector();
  TypeResolverBuilder localTypeResolverBuilder = localAnnotationIntrospector.findTypeResolver(paramDeserializationConfig, localAnnotatedClass, paramJavaType);
  Collection localCollection;
  if (localTypeResolverBuilder == null)
  {
    localTypeResolverBuilder = paramDeserializationConfig.getDefaultTyper(paramJavaType);
    localCollection = null;
    if (localTypeResolverBuilder == null)
      return null;
  }
  else
  {
    localCollection = paramDeserializationConfig.getSubtypeResolver().collectAndResolveSubtypes(localAnnotatedClass, paramDeserializationConfig, localAnnotationIntrospector);
  }
  return localTypeResolverBuilder.buildTypeDeserializer(paramDeserializationConfig, paramJavaType, localCollection, paramBeanProperty);
}

protected JsonSerializer<?> buildCollectionSerializer(SerializationConfig paramSerializationConfig, CollectionType paramCollectionType, BasicBeanDescription paramBasicBeanDescription, BeanProperty paramBeanProperty, boolean paramBoolean, TypeSerializer paramTypeSerializer, JsonSerializer<Object> paramJsonSerializer)
{
  Iterator localIterator = customSerializers().iterator();
  while (localIterator.hasNext())
  {
    JsonSerializer localJsonSerializer = ((Serializers)localIterator.next()).findCollectionSerializer(paramSerializationConfig, paramCollectionType, paramBasicBeanDescription, paramBeanProperty, paramTypeSerializer, paramJsonSerializer);
    if (localJsonSerializer != null)
      return localJsonSerializer;
  }
  Class localClass1 = paramCollectionType.getRawClass();
  if (EnumSet.class.isAssignableFrom(localClass1))
    return buildEnumSetSerializer(paramSerializationConfig, paramCollectionType, paramBasicBeanDescription, paramBeanProperty, paramBoolean, paramTypeSerializer, paramJsonSerializer);
  Class localClass2 = paramCollectionType.getContentType().getRawClass();
  if (isIndexedList(localClass1))
  {
    if (localClass2 == String.class)
      return new IndexedStringListSerializer(paramBeanProperty);
    return ContainerSerializers.indexedListSerializer(paramCollectionType.getContentType(), paramBoolean, paramTypeSerializer, paramBeanProperty, paramJsonSerializer);
  }
  if (localClass2 == String.class)
    return new StringCollectionSerializer(paramBeanProperty);
  return ContainerSerializers.collectionSerializer(paramCollectionType.getContentType(), paramBoolean, paramTypeSerializer, paramBeanProperty, paramJsonSerializer);
}

public JsonDeserializer<Object> buildBeanDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType, BasicBeanDescription paramBasicBeanDescription, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  BeanDeserializerBuilder localBeanDeserializerBuilder = constructBeanDeserializerBuilder(paramBasicBeanDescription);
  localBeanDeserializerBuilder.setCreators(findDeserializerCreators(paramDeserializationConfig, paramBasicBeanDescription));
  addBeanProps(paramDeserializationConfig, paramBasicBeanDescription, localBeanDeserializerBuilder);
  addReferenceProperties(paramDeserializationConfig, paramBasicBeanDescription, localBeanDeserializerBuilder);
  if (this._factoryConfig.hasDeserializerModifiers())
  {
    Iterator localIterator2 = this._factoryConfig.deserializerModifiers().iterator();
    while (localIterator2.hasNext())
      localBeanDeserializerBuilder = ((BeanDeserializerModifier)localIterator2.next()).updateBuilder(paramDeserializationConfig, paramBasicBeanDescription, localBeanDeserializerBuilder);
  }
  JsonDeserializer localJsonDeserializer = localBeanDeserializerBuilder.build(paramBeanProperty);
  if (this._factoryConfig.hasDeserializerModifiers())
  {
    Iterator localIterator1 = this._factoryConfig.deserializerModifiers().iterator();
    while (localIterator1.hasNext())
      localJsonDeserializer = ((BeanDeserializerModifier)localIterator1.next()).modifyDeserializer(paramDeserializationConfig, paramBasicBeanDescription, localJsonDeserializer);
  }
  return localJsonDeserializer;
}

public KeyDeserializer createKeyDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  if (this._factoryConfig.hasKeyDeserializers())
  {
    BasicBeanDescription localBasicBeanDescription = (BasicBeanDescription)paramDeserializationConfig.introspectClassAnnotations(paramJavaType.getRawClass());
    Iterator localIterator = this._factoryConfig.keyDeserializers().iterator();
    while (localIterator.hasNext())
    {
      KeyDeserializer localKeyDeserializer = ((KeyDeserializers)localIterator.next()).findKeyDeserializer(paramJavaType, paramDeserializationConfig, localBasicBeanDescription, paramBeanProperty);
      if (localKeyDeserializer != null)
        return localKeyDeserializer;
    }
  }
  return null;
}

public JsonDeserializer<?> createCollectionLikeDeserializer(DeserializationConfig paramDeserializationConfig, DeserializerProvider paramDeserializerProvider, CollectionLikeType paramCollectionLikeType, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  CollectionLikeType localCollectionLikeType1 = (CollectionLikeType)mapAbstractType(paramDeserializationConfig, paramCollectionLikeType);
  BasicBeanDescription localBasicBeanDescription = (BasicBeanDescription)paramDeserializationConfig.introspectClassAnnotations(localCollectionLikeType1.getRawClass());
  JsonDeserializer localJsonDeserializer1 = findDeserializerFromAnnotation(paramDeserializationConfig, localBasicBeanDescription.getClassInfo(), paramBeanProperty);
  if (localJsonDeserializer1 != null)
    return localJsonDeserializer1;
  CollectionLikeType localCollectionLikeType2 = (CollectionLikeType)modifyTypeByAnnotation(paramDeserializationConfig, localBasicBeanDescription.getClassInfo(), localCollectionLikeType1, null);
  JavaType localJavaType = localCollectionLikeType2.getContentType();
  JsonDeserializer localJsonDeserializer2 = (JsonDeserializer)localJavaType.getValueHandler();
  TypeDeserializer localTypeDeserializer = (TypeDeserializer)localJavaType.getTypeHandler();
  if (localTypeDeserializer == null)
    localTypeDeserializer = findTypeDeserializer(paramDeserializationConfig, localJavaType, paramBeanProperty);
  return _findCustomCollectionLikeDeserializer(localCollectionLikeType2, paramDeserializationConfig, paramDeserializerProvider, localBasicBeanDescription, paramBeanProperty, localTypeDeserializer, localJsonDeserializer2);
}

public JsonDeserializer<Object> findValueDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  JsonDeserializer localJsonDeserializer1 = _findCachedDeserializer(paramJavaType);
  if (localJsonDeserializer1 != null)
  {
    if ((localJsonDeserializer1 instanceof ContextualDeserializer))
      localJsonDeserializer1 = ((ContextualDeserializer)localJsonDeserializer1).createContextual(paramDeserializationConfig, paramBeanProperty);
    return localJsonDeserializer1;
  }
  JsonDeserializer localJsonDeserializer2 = _createAndCacheValueDeserializer(paramDeserializationConfig, paramJavaType, paramBeanProperty);
  if (localJsonDeserializer2 == null)
    localJsonDeserializer2 = _handleUnknownValueDeserializer(paramJavaType);
  if ((localJsonDeserializer2 instanceof ContextualDeserializer))
    localJsonDeserializer2 = ((ContextualDeserializer)localJsonDeserializer2).createContextual(paramDeserializationConfig, paramBeanProperty);
  return localJsonDeserializer2;
}

@Override
@SuppressWarnings("unchecked")
public JsonDeserializer<Object> createContextual(DeserializationConfig config, BeanProperty property) throws JsonMappingException {
    final Class<?> rawClass = property.getType().getRawClass();
    final Class<?> componentType = rawClass.getComponentType();
    if (componentType == null || !componentType.isEnum()) {
        throw new JsonMappingException("Pick list Enum array expected for " + rawClass);
    }
    return new MultiSelectPicklistDeserializer((Class<? extends Enum>) componentType);
}

@Override
public JsonDeserializer<?> createCollectionDeserializer(final DeserializationConfig config,
                                                        final DeserializerProvider p,
                                                        final CollectionType type,
                                                        final BeanProperty property) throws JsonMappingException {

    if (CollectionPage.class.equals(type.getRawClass())) {
        final JsonDeserializer<Object> contentDeserializer = type.getContentType().getValueHandler();
        return new CollectionPageDeserializer(type, contentDeserializer);
    }

    return nonCollectionPageStrategy.createCollectionDeserializer(config, p, type, property);
}

@Override
public JsonDeserializer<Object> createBeanDeserializer(final DeserializationConfig config,
                                                       final DeserializerProvider p,
                                                       final JavaType type,
                                                       final BeanProperty property) throws JsonMappingException {
    return nonCollectionPageStrategy.createBeanDeserializer(config, p, type, property);
}

@Override
public JsonDeserializer<?> createArrayDeserializer(final DeserializationConfig config,
                                                   final DeserializerProvider p,
                                                   final ArrayType type,
                                                   final BeanProperty property) throws JsonMappingException {
    return nonCollectionPageStrategy.createArrayDeserializer(config, p, type, property);
}

@Override
public JsonDeserializer<?> createCollectionLikeDeserializer(final DeserializationConfig config,
                                                            final DeserializerProvider p,
                                                            final CollectionLikeType type,
                                                            final BeanProperty property)
        throws JsonMappingException {
    return nonCollectionPageStrategy.createCollectionLikeDeserializer(config, p, type, property);
}

@Override
public JsonDeserializer<?> createEnumDeserializer(final DeserializationConfig config,
                                                  final DeserializerProvider p,
                                                  final JavaType type,
                                                  final BeanProperty property)
        throws JsonMappingException {
    return nonCollectionPageStrategy.createEnumDeserializer(config, p, type, property);
}

@Override
public JsonDeserializer<?> createMapDeserializer(final DeserializationConfig config,
                                                 final DeserializerProvider p,
                                                 final MapType type,
                                                 final BeanProperty property)
        throws JsonMappingException {
    return nonCollectionPageStrategy.createMapDeserializer(config, p, type, property);
}

@Override
public JsonDeserializer<?> createMapLikeDeserializer(final DeserializationConfig config,
                                                     final DeserializerProvider p,
                                                     final MapLikeType type,
                                                     final BeanProperty property)
        throws JsonMappingException {
    return nonCollectionPageStrategy.createMapLikeDeserializer(config, p, type, property);
}

@Override
public JsonDeserializer<?> createTreeDeserializer(final DeserializationConfig config,
                                                  final DeserializerProvider p,
                                                  final JavaType type,
                                                  final BeanProperty property)
        throws JsonMappingException {
    return nonCollectionPageStrategy.createTreeDeserializer(config, p, type, property);
}

@Override
public JsonSerializer<Object> createSerializer(SerializationConfig config, JavaType baseType, BeanProperty property) {
    if (baseType.getRawClass() == TestBeanSimple.class) {
        return new TestBeanSimpleSerializer();
    }
    else {
        return super.createSerializer(config, baseType, property);
    }
}

public TypeDeserializer findPropertyContentTypeDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType, AnnotatedMember paramAnnotatedMember, BeanProperty paramBeanProperty)
{
  AnnotationIntrospector localAnnotationIntrospector = paramDeserializationConfig.getAnnotationIntrospector();
  TypeResolverBuilder localTypeResolverBuilder = localAnnotationIntrospector.findPropertyContentTypeResolver(paramDeserializationConfig, paramAnnotatedMember, paramJavaType);
  JavaType localJavaType = paramJavaType.getContentType();
  if (localTypeResolverBuilder == null)
    return findTypeDeserializer(paramDeserializationConfig, localJavaType, paramBeanProperty);
  return localTypeResolverBuilder.buildTypeDeserializer(paramDeserializationConfig, localJavaType, paramDeserializationConfig.getSubtypeResolver().collectAndResolveSubtypes(paramAnnotatedMember, paramDeserializationConfig, localAnnotationIntrospector), paramBeanProperty);
}

public JsonDeserializer<Object> findTypedValueDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  Object localObject = findValueDeserializer(paramDeserializationConfig, paramJavaType, paramBeanProperty);
  TypeDeserializer localTypeDeserializer = this._factory.findTypeDeserializer(paramDeserializationConfig, paramJavaType, paramBeanProperty);
  if (localTypeDeserializer != null)
    localObject = new WrappedDeserializer(localTypeDeserializer, (JsonDeserializer)localObject);
  return (JsonDeserializer<Object>)localObject;
}

public TypeDeserializer buildTypeDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType, Collection<NamedType> paramCollection, BeanProperty paramBeanProperty)
{
  TypeIdResolver localTypeIdResolver = idResolver(paramDeserializationConfig, paramJavaType, paramCollection, false, true);
  switch (1.$SwitchMap$org$codehaus$jackson$annotate$JsonTypeInfo$As[this._includeAs.ordinal()])
  {
  default:
    throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: " + this._includeAs);
  case 1:
    return new AsArrayTypeDeserializer(paramJavaType, localTypeIdResolver, paramBeanProperty);
  case 2:
    return new AsPropertyTypeDeserializer(paramJavaType, localTypeIdResolver, paramBeanProperty, this._typeProperty);
  case 3:
  }
  return new AsWrapperTypeDeserializer(paramJavaType, localTypeIdResolver, paramBeanProperty);
}

public TypeSerializer buildTypeSerializer(SerializationConfig paramSerializationConfig, JavaType paramJavaType, Collection<NamedType> paramCollection, BeanProperty paramBeanProperty)
{
  TypeIdResolver localTypeIdResolver = idResolver(paramSerializationConfig, paramJavaType, paramCollection, true, false);
  switch (1.$SwitchMap$org$codehaus$jackson$annotate$JsonTypeInfo$As[this._includeAs.ordinal()])
  {
  default:
    throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: " + this._includeAs);
  case 1:
    return new AsArrayTypeSerializer(localTypeIdResolver, paramBeanProperty);
  case 2:
    return new AsPropertyTypeSerializer(localTypeIdResolver, paramBeanProperty, this._typeProperty);
  case 3:
  }
  return new AsWrapperTypeSerializer(localTypeIdResolver, paramBeanProperty);
}

protected JsonDeserializer<Object> _findCustomBeanDeserializer(JavaType paramJavaType, DeserializationConfig paramDeserializationConfig, DeserializerProvider paramDeserializerProvider, BasicBeanDescription paramBasicBeanDescription, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  Iterator localIterator = this._factoryConfig.deserializers().iterator();
  while (localIterator.hasNext())
  {
    JsonDeserializer localJsonDeserializer = ((Deserializers)localIterator.next()).findBeanDeserializer(paramJavaType, paramDeserializationConfig, paramDeserializerProvider, paramBasicBeanDescription, paramBeanProperty);
    if (localJsonDeserializer != null)
      return localJsonDeserializer;
  }
  return null;
}

protected TypeDeserializerBase(JavaType paramJavaType, TypeIdResolver paramTypeIdResolver, BeanProperty paramBeanProperty)
{
  this._baseType = paramJavaType;
  this._idResolver = paramTypeIdResolver;
  this._property = paramBeanProperty;
  this._deserializers = new HashMap();
}

public JsonSerializer<Object> createSerializer(SerializationConfig paramSerializationConfig, JavaType paramJavaType, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  JsonSerializer localJsonSerializer = findCustomSerializer(paramJavaType.getRawClass(), paramSerializationConfig);
  if (localJsonSerializer != null)
    return localJsonSerializer;
  return super.createSerializer(paramSerializationConfig, paramJavaType, paramBeanProperty);
}

public JsonValueSerializer(Method paramMethod, JsonSerializer<Object> paramJsonSerializer, BeanProperty paramBeanProperty)
{
  super(Object.class);
  this._accessorMethod = paramMethod;
  this._valueSerializer = paramJsonSerializer;
  this._property = paramBeanProperty;
}

public JsonDeserializer<?> createTreeDeserializer(DeserializationConfig paramDeserializationConfig, DeserializerProvider paramDeserializerProvider, JavaType paramJavaType, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  Class localClass = paramJavaType.getRawClass();
  JsonDeserializer localJsonDeserializer = _findCustomTreeNodeDeserializer(localClass, paramDeserializationConfig, paramBeanProperty);
  if (localJsonDeserializer != null)
    return localJsonDeserializer;
  return JsonNodeDeserializer.getDeserializer(localClass);
}

public TypeSerializer findPropertyContentTypeSerializer(JavaType paramJavaType, SerializationConfig paramSerializationConfig, AnnotatedMember paramAnnotatedMember, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  JavaType localJavaType = paramJavaType.getContentType();
  AnnotationIntrospector localAnnotationIntrospector = paramSerializationConfig.getAnnotationIntrospector();
  TypeResolverBuilder localTypeResolverBuilder = localAnnotationIntrospector.findPropertyContentTypeResolver(paramSerializationConfig, paramAnnotatedMember, paramJavaType);
  if (localTypeResolverBuilder == null)
    return createTypeSerializer(paramSerializationConfig, localJavaType, paramBeanProperty);
  return localTypeResolverBuilder.buildTypeSerializer(paramSerializationConfig, localJavaType, paramSerializationConfig.getSubtypeResolver().collectAndResolveSubtypes(paramAnnotatedMember, paramSerializationConfig, localAnnotationIntrospector), paramBeanProperty);
}

public TypeSerializer findPropertyTypeSerializer(JavaType paramJavaType, SerializationConfig paramSerializationConfig, AnnotatedMember paramAnnotatedMember, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  AnnotationIntrospector localAnnotationIntrospector = paramSerializationConfig.getAnnotationIntrospector();
  TypeResolverBuilder localTypeResolverBuilder = localAnnotationIntrospector.findPropertyTypeResolver(paramSerializationConfig, paramAnnotatedMember, paramJavaType);
  if (localTypeResolverBuilder == null)
    return createTypeSerializer(paramSerializationConfig, paramJavaType, paramBeanProperty);
  return localTypeResolverBuilder.buildTypeSerializer(paramSerializationConfig, paramJavaType, paramSerializationConfig.getSubtypeResolver().collectAndResolveSubtypes(paramAnnotatedMember, paramSerializationConfig, localAnnotationIntrospector), paramBeanProperty);
}

protected JsonDeserializer<?> _findCustomMapDeserializer(MapType paramMapType, DeserializationConfig paramDeserializationConfig, DeserializerProvider paramDeserializerProvider, BasicBeanDescription paramBasicBeanDescription, BeanProperty paramBeanProperty, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer)
  throws JsonMappingException
{
  Iterator localIterator = this._factoryConfig.deserializers().iterator();
  while (localIterator.hasNext())
  {
    JsonDeserializer localJsonDeserializer = ((Deserializers)localIterator.next()).findMapDeserializer(paramMapType, paramDeserializationConfig, paramDeserializerProvider, paramBasicBeanDescription, paramBeanProperty, paramKeyDeserializer, paramTypeDeserializer, paramJsonDeserializer);
    if (localJsonDeserializer != null)
      return localJsonDeserializer;
  }
  return null;
}

protected JsonDeserializer<?> _findCustomCollectionLikeDeserializer(CollectionLikeType paramCollectionLikeType, DeserializationConfig paramDeserializationConfig, DeserializerProvider paramDeserializerProvider, BasicBeanDescription paramBasicBeanDescription, BeanProperty paramBeanProperty, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer)
  throws JsonMappingException
{
  Iterator localIterator = this._factoryConfig.deserializers().iterator();
  while (localIterator.hasNext())
  {
    JsonDeserializer localJsonDeserializer = ((Deserializers)localIterator.next()).findCollectionLikeDeserializer(paramCollectionLikeType, paramDeserializationConfig, paramDeserializerProvider, paramBasicBeanDescription, paramBeanProperty, paramTypeDeserializer, paramJsonDeserializer);
    if (localJsonDeserializer != null)
      return localJsonDeserializer;
  }
  return null;
}

public JsonDeserializer<?> createEnumDeserializer(DeserializationConfig paramDeserializationConfig, DeserializerProvider paramDeserializerProvider, JavaType paramJavaType, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  if (this._directClassMappings != null)
  {
    ClassKey localClassKey = new ClassKey(paramJavaType.getRawClass());
    JsonDeserializer localJsonDeserializer = (JsonDeserializer)this._directClassMappings.get(localClassKey);
    if (localJsonDeserializer != null)
      return localJsonDeserializer;
  }
  return super.createEnumDeserializer(paramDeserializationConfig, paramDeserializerProvider, paramJavaType, paramBeanProperty);
}

protected MapSerializer(HashSet<String> paramHashSet, JavaType paramJavaType1, JavaType paramJavaType2, boolean paramBoolean, TypeSerializer paramTypeSerializer, JsonSerializer<Object> paramJsonSerializer1, JsonSerializer<Object> paramJsonSerializer2, BeanProperty paramBeanProperty)
{
  super(Map.class, false);
  this._property = paramBeanProperty;
  this._ignoredEntries = paramHashSet;
  this._keyType = paramJavaType1;
  this._valueType = paramJavaType2;
  this._valueTypeIsStatic = paramBoolean;
  this._valueTypeSerializer = paramTypeSerializer;
  this._keySerializer = paramJsonSerializer1;
  this._valueSerializer = paramJsonSerializer2;
  this._dynamicValueSerializers = PropertySerializerMap.emptyMap();
}

protected JsonSerializer<Object> _createAndCacheUntypedSerializer(Class<?> paramClass, BeanProperty paramBeanProperty)
  throws JsonMappingException
{
  try
  {
    JsonSerializer localJsonSerializer = _createUntypedSerializer(this._config.constructType(paramClass), paramBeanProperty);
    if (localJsonSerializer != null)
      this._serializerCache.addAndResolveNonTypedSerializer(paramClass, localJsonSerializer, this);
    return localJsonSerializer;
  }
  catch (IllegalArgumentException localIllegalArgumentException)
  {
  }
  throw new JsonMappingException(localIllegalArgumentException.getMessage(), null, localIllegalArgumentException);
}