Java 类com.fasterxml.jackson.databind.ser.impl.PropertySerializerMap 实例源码

protected JsonSerializer<Object> findSerializer(
        SerializerProvider provider, Object value) throws IOException,
        JsonProcessingException {
    /*
     * TODO: if Hibernate did use generics, or we wanted to allow use of
     * Jackson annotations to indicate type, should take that into user.
     */
    Class<?> type = value.getClass();
    /*
     * we will use a map to contain serializers found so far, keyed by type:
     * this avoids potentially costly lookup from global caches and/or
     * construction of new serializers
     */
    /*
     * 18-Oct-2013, tatu: Whether this is for the primary property or
     * secondary is really anyone's guess at this point; proxies can exist
     * at any level?
     */
    PropertySerializerMap.SerializerAndMapResult result = _dynamicSerializers
            .findAndAddPrimarySerializer(type, provider, null);
    if (_dynamicSerializers != result.map) {
        _dynamicSerializers = result.map;
    }
    return result.serializer;
}

protected JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
        Class<?> type, SerializerProvider provider) throws JsonMappingException
{
    PropertySerializerMap.SerializerAndMapResult result;
    if (_nonTrivialBaseType != null) {
        JavaType t = provider.constructSpecializedType(_nonTrivialBaseType, type);
        result = map.findAndAddPrimarySerializer(t, provider, this);
    } else {
        result = map.findAndAddPrimarySerializer(type, provider, this);
    }
    // did we get a new map of serializers? If so, start using it
    if (map != result.map) {
        _dynamicSerializers = result.map;
    }
    return result.serializer;
}

protected JsonSerializer<Object> findSerializer(SerializerProvider provider, Object value)
    throws IOException, JsonProcessingException
    {
/* TODO: if Hibernate did use generics, or we wanted to allow use of Jackson
 *  annotations to indicate type, should take that into account.
 */
Class<?> type = value.getClass();
/* we will use a map to contain serializers found so far, keyed by type:
 * this avoids potentially costly lookup from global caches and/or construction
 * of new serializers
 */
PropertySerializerMap.SerializerAndMapResult result = _dynamicSerializers.findAndAddSerializer(type,
        provider, _property);
if (_dynamicSerializers != result.map) {
    _dynamicSerializers = result.map;
}
return result.serializer;
    }

@SuppressWarnings("unchecked")
protected MapSerializer(HashSet<String> ignoredEntries,
        JavaType keyType, JavaType valueType, boolean valueTypeIsStatic,
        TypeSerializer vts,
        JsonSerializer<?> keySerializer, JsonSerializer<?> valueSerializer)
{
    super(Map.class, false);
    _ignoredEntries = ignoredEntries;
    _keyType = keyType;
    _valueType = valueType;
    _valueTypeIsStatic = valueTypeIsStatic;
    _valueTypeSerializer = vts;
    _keySerializer = (JsonSerializer<Object>) keySerializer;
    _valueSerializer = (JsonSerializer<Object>) valueSerializer;
    _dynamicValueSerializers = PropertySerializerMap.emptyMap();
    _property = null;
}

protected JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
        Class<?> type, SerializerProvider provider) throws JsonMappingException
{
    PropertySerializerMap.SerializerAndMapResult result;
    if (_nonTrivialBaseType != null) {
        JavaType t = provider.constructSpecializedType(_nonTrivialBaseType, type);
        result = map.findAndAddSerializer(t, provider, this);
    } else {
        result = map.findAndAddSerializer(type, provider, this);
    }
    // did we get a new map of serializers? If so, start using it
    if (map != result.map) {
        _dynamicSerializers = result.map;
    }
    return result.serializer;
}

@SuppressWarnings("unchecked")
public BeanPropertyWriter(BeanPropertyDefinition propDef,
        AnnotatedMember member, Annotations contextAnnotations,
        JavaType declaredType,
        JsonSerializer<?> ser, TypeSerializer typeSer, JavaType serType,
        boolean suppressNulls, Object suppressableValue)
{
    _member = member;
    _contextAnnotations = contextAnnotations;
    _name = new SerializedString(propDef.getName());
    _wrapperName = propDef.getWrapperName();
    _declaredType = declaredType;
    _serializer = (JsonSerializer<Object>) ser;
    _dynamicSerializers = (ser == null) ? PropertySerializerMap.emptyMap() : null;
    _typeSerializer = typeSer;
    _cfgSerializationType = serType;
    _metadata = propDef.getMetadata();

    if (member instanceof AnnotatedField) {
        _accessorMethod = null;
        _field = (Field) member.getMember();
    } else if (member instanceof AnnotatedMethod) {
        _accessorMethod = (Method) member.getMember();
        _field = null;
    } else {
        throw new IllegalArgumentException("Can not pass member of type "+member.getClass().getName());
    }
    _suppressNulls = suppressNulls;
    _suppressableValue = suppressableValue;
    _includeInViews = propDef.findViews();

    // this will be resolved later on, unless nulls are to be suppressed
    _nullSerializer = null;
}

protected MapSerializer(HashSet<String> paramHashSet, JavaType paramJavaType1, JavaType paramJavaType2, boolean paramBoolean, TypeSerializer paramTypeSerializer, JsonSerializer<?> paramJsonSerializer1, JsonSerializer<?> paramJsonSerializer2)
{
  super(Map.class, false);
  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();
  this._property = null;
}

protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap paramPropertySerializerMap, JavaType paramJavaType, SerializerProvider paramSerializerProvider)
{
  PropertySerializerMap.SerializerAndMapResult localSerializerAndMapResult = paramPropertySerializerMap.findAndAddSerializer(paramJavaType, paramSerializerProvider, this._property);
  if (paramPropertySerializerMap != localSerializerAndMapResult.map)
    this._dynamicValueSerializers = localSerializerAndMapResult.map;
  return localSerializerAndMapResult.serializer;
}

protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap paramPropertySerializerMap, Class<?> paramClass, SerializerProvider paramSerializerProvider)
{
  PropertySerializerMap.SerializerAndMapResult localSerializerAndMapResult = paramPropertySerializerMap.findAndAddSerializer(paramClass, paramSerializerProvider, this._property);
  if (paramPropertySerializerMap != localSerializerAndMapResult.map)
    this._dynamicValueSerializers = localSerializerAndMapResult.map;
  return localSerializerAndMapResult.serializer;
}

protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap paramPropertySerializerMap, JavaType paramJavaType, SerializerProvider paramSerializerProvider)
{
  PropertySerializerMap.SerializerAndMapResult localSerializerAndMapResult = paramPropertySerializerMap.findAndAddSerializer(paramJavaType, paramSerializerProvider, this._property);
  if (paramPropertySerializerMap != localSerializerAndMapResult.map)
    this._dynamicSerializers = localSerializerAndMapResult.map;
  return localSerializerAndMapResult.serializer;
}

protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap paramPropertySerializerMap, Class<?> paramClass, SerializerProvider paramSerializerProvider)
{
  PropertySerializerMap.SerializerAndMapResult localSerializerAndMapResult = paramPropertySerializerMap.findAndAddSerializer(paramClass, paramSerializerProvider, this._property);
  if (paramPropertySerializerMap != localSerializerAndMapResult.map)
    this._dynamicSerializers = localSerializerAndMapResult.map;
  return localSerializerAndMapResult.serializer;
}

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

public final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap paramPropertySerializerMap, JavaType paramJavaType, SerializerProvider paramSerializerProvider)
{
  PropertySerializerMap.SerializerAndMapResult localSerializerAndMapResult = paramPropertySerializerMap.findAndAddSerializer(paramJavaType, paramSerializerProvider, this._property);
  if (paramPropertySerializerMap != localSerializerAndMapResult.map)
    this._dynamicSerializers = localSerializerAndMapResult.map;
  return localSerializerAndMapResult.serializer;
}

public final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap paramPropertySerializerMap, Class<?> paramClass, SerializerProvider paramSerializerProvider)
{
  PropertySerializerMap.SerializerAndMapResult localSerializerAndMapResult = paramPropertySerializerMap.findAndAddSerializer(paramClass, paramSerializerProvider, this._property);
  if (paramPropertySerializerMap != localSerializerAndMapResult.map)
    this._dynamicSerializers = localSerializerAndMapResult.map;
  return localSerializerAndMapResult.serializer;
}

public BeanPropertyWriter(BeanPropertyDefinition paramBeanPropertyDefinition, AnnotatedMember paramAnnotatedMember, Annotations paramAnnotations, JavaType paramJavaType1, JsonSerializer<?> paramJsonSerializer, TypeSerializer paramTypeSerializer, JavaType paramJavaType2, boolean paramBoolean, Object paramObject)
{
  this._member = paramAnnotatedMember;
  this._contextAnnotations = paramAnnotations;
  this._name = new SerializedString(paramBeanPropertyDefinition.getName());
  this._wrapperName = paramBeanPropertyDefinition.getWrapperName();
  this._declaredType = paramJavaType1;
  this._serializer = paramJsonSerializer;
  PropertySerializerMap localPropertySerializerMap;
  if (paramJsonSerializer == null)
    localPropertySerializerMap = PropertySerializerMap.emptyMap();
  else
    localPropertySerializerMap = null;
  this._dynamicSerializers = localPropertySerializerMap;
  this._typeSerializer = paramTypeSerializer;
  this._cfgSerializationType = paramJavaType2;
  this._isRequired = paramBeanPropertyDefinition.isRequired();
  if ((paramAnnotatedMember instanceof AnnotatedField))
  {
    this._accessorMethod = null;
    this._field = ((Field)paramAnnotatedMember.getMember());
  }
  else if ((paramAnnotatedMember instanceof AnnotatedMethod))
  {
    this._accessorMethod = ((Method)paramAnnotatedMember.getMember());
    this._field = null;
  }
  else
  {
    throw new IllegalArgumentException("Can not pass member of type " + paramAnnotatedMember.getClass().getName());
  }
  this._suppressNulls = paramBoolean;
  this._suppressableValue = paramObject;
  this._includeInViews = paramBeanPropertyDefinition.findViews();
  this._nullSerializer = null;
}

public JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap paramPropertySerializerMap, Class<?> paramClass, SerializerProvider paramSerializerProvider)
{
  PropertySerializerMap.SerializerAndMapResult localSerializerAndMapResult;
  if (this._nonTrivialBaseType != null)
    localSerializerAndMapResult = paramPropertySerializerMap.findAndAddSerializer(paramSerializerProvider.constructSpecializedType(this._nonTrivialBaseType, paramClass), paramSerializerProvider, this);
  else
    localSerializerAndMapResult = paramPropertySerializerMap.findAndAddSerializer(paramClass, paramSerializerProvider, this);
  if (paramPropertySerializerMap != localSerializerAndMapResult.map)
    this._dynamicSerializers = localSerializerAndMapResult.map;
  return localSerializerAndMapResult.serializer;
}

public void serializeAsField(Object paramObject, JsonGenerator paramJsonGenerator, SerializerProvider paramSerializerProvider)
{
  Object localObject1 = get(paramObject);
  if (localObject1 == null)
  {
    if (this._nullSerializer != null)
    {
      paramJsonGenerator.writeFieldName(this._name);
      this._nullSerializer.serialize(null, paramJsonGenerator, paramSerializerProvider);
    }
    return;
  }
  JsonSerializer localJsonSerializer1 = this._serializer;
  Object localObject2 = localJsonSerializer1;
  if (localJsonSerializer1 == null)
  {
    Class localClass = localObject1.getClass();
    PropertySerializerMap localPropertySerializerMap = this._dynamicSerializers;
    JsonSerializer localJsonSerializer2 = localPropertySerializerMap.serializerFor(localClass);
    localObject2 = localJsonSerializer2;
    if (localJsonSerializer2 == null)
      localObject2 = _findAndAddDynamic(localPropertySerializerMap, localClass, paramSerializerProvider);
  }
  if (this._suppressableValue != null)
    if (MARKER_FOR_EMPTY == this._suppressableValue)
    {
      if (!((JsonSerializer)localObject2).isEmpty(localObject1));
    }
    else if (this._suppressableValue.equals(localObject1))
      return;
  if (localObject1 == paramObject)
    _handleSelfReference(paramObject, (JsonSerializer)localObject2);
  paramJsonGenerator.writeFieldName(this._name);
  if (this._typeSerializer == null)
  {
    ((JsonSerializer)localObject2).serialize(localObject1, paramJsonGenerator, paramSerializerProvider);
    return;
  }
  ((JsonSerializer)localObject2).serializeWithType(localObject1, paramJsonGenerator, paramSerializerProvider, this._typeSerializer);
}

protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
        Class<?> type, SerializerProvider provider) throws JsonMappingException
{
    PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSerializer(type, provider, _property);
    // did we get a new map of serializers? If so, start using it
    if (map != result.map) {
        _dynamicValueSerializers = result.map;
    }
    return result.serializer;
}

protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
        JavaType type, SerializerProvider provider) throws JsonMappingException
{
    PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSerializer(type, provider, _property);
    if (map != result.map) {
        _dynamicValueSerializers = result.map;
    }
    return result.serializer;
}

public ObjectArraySerializer(JavaType elemType, boolean staticTyping,
        TypeSerializer vts, JsonSerializer<Object> elementSerializer)
{
    super(Object[].class, null);
    _elementType = elemType;
    _staticTyping = staticTyping;
    _valueTypeSerializer = vts;
    _dynamicSerializers = PropertySerializerMap.emptyMap();
    _elementSerializer = elementSerializer;
}

public void serializeTypedContents(Object[] value, JsonGenerator jgen, SerializerProvider provider)
    throws IOException, JsonGenerationException
{
    final int len = value.length;
    final TypeSerializer typeSer = _valueTypeSerializer;
    int i = 0;
    Object elem = null;
    try {
        PropertySerializerMap serializers = _dynamicSerializers;
        for (; i < len; ++i) {
            elem = value[i];
            if (elem == null) {
                provider.defaultSerializeNull(jgen);
                continue;
            }
            Class<?> cc = elem.getClass();
            JsonSerializer<Object> serializer = serializers.serializerFor(cc);
            if (serializer == null) {
                serializer = _findAndAddDynamic(serializers, cc, provider);
            }
            serializer.serializeWithType(elem, jgen, provider, typeSer);
        }
    } catch (IOException ioe) {
        throw ioe;
    } catch (Exception e) {
        Throwable t = e;
        while (t instanceof InvocationTargetException && t.getCause() != null) {
            t = t.getCause();
        }
        if (t instanceof Error) {
            throw (Error) t;
        }
        throw JsonMappingException.wrapWithPath(t, elem, i);
    }
}

protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
        Class<?> type, SerializerProvider provider) throws JsonMappingException
{
    PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSerializer(type, provider, _property);
    // did we get a new map of serializers? If so, start using it
    if (map != result.map) {
        _dynamicSerializers = result.map;
    }
    return result.serializer;
}

protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
        JavaType type, SerializerProvider provider) throws JsonMappingException
{
    PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSerializer(type, provider, _property);
    // did we get a new map of serializers? If so, start using it
    if (map != result.map) {
        _dynamicSerializers = result.map;
    }
    return result.serializer;
}

protected AsArraySerializerBase(Class<?> cls, JavaType et, boolean staticTyping,
        TypeSerializer vts, BeanProperty property, JsonSerializer<Object> elementSerializer)
{
    // typing with generics is messy... have to resort to this:
    super(cls, false);
    _elementType = et;
    // static if explicitly requested, or if element type is final
    _staticTyping = staticTyping || (et != null && et.isFinal());
    _valueTypeSerializer = vts;
    _property = property;
    _elementSerializer = elementSerializer;
    _dynamicSerializers = PropertySerializerMap.emptyMap();
}

protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
        Class<?> type, SerializerProvider provider) throws JsonMappingException
{
    PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSerializer(type, provider, _property);
    // did we get a new map of serializers? If so, start using it
    if (map != result.map) {
        _dynamicSerializers = result.map;
    }
    return result.serializer;
}

protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
        JavaType type, SerializerProvider provider) throws JsonMappingException
{
    PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSerializer(type, provider, _property);
    if (map != result.map) {
        _dynamicSerializers = result.map;
    }
    return result.serializer;
}

@SuppressWarnings("unchecked")
public BeanPropertyWriter(BeanPropertyDefinition propDef,
        AnnotatedMember member, Annotations contextAnnotations,
        JavaType declaredType,
        JsonSerializer<?> ser, TypeSerializer typeSer, JavaType serType,
        boolean suppressNulls, Object suppressableValue)
{

    _member = member;
    _contextAnnotations = contextAnnotations;
    _name = new SerializedString(propDef.getName());
    _declaredType = declaredType;
    _serializer = (JsonSerializer<Object>) ser;
    _dynamicSerializers = (ser == null) ? PropertySerializerMap.emptyMap() : null;
    _typeSerializer = typeSer;
    _cfgSerializationType = serType;

    if (member instanceof AnnotatedField) {
        _accessorMethod = null;
        _field = (Field) member.getMember();
    } else if (member instanceof AnnotatedMethod) {
        _accessorMethod = (Method) member.getMember();
        _field = null;
    } else {
        throw new IllegalArgumentException("Can not pass member of type "+member.getClass().getName());
    }
    _suppressNulls = suppressNulls;
    _suppressableValue = suppressableValue;
    _includeInViews = propDef.findViews();

    // this will be resolved later on, unless nulls are to be suppressed
    _nullSerializer = null;
}

/**
     * Method called to access property that this bean stands for, from
     * within given bean, and to serialize it as a JSON Object field
     * using appropriate serializer.
     */
    @Override
    public void serializeAsField(Object bean, JsonGenerator jgen, SerializerProvider prov)
        throws Exception
    {
        Object value = get(bean);
        // Null handling is bit different, check that first
        if (value == null) {//如果为null，直接过滤
//            if (_nullSerializer != null) {
//                jgen.writeFieldName(_name);
//                _nullSerializer.serialize(null, jgen, prov);
//            }
            return;
        }
        // then find serializer to use
        JsonSerializer<Object> ser = _serializer;
        if (ser == null) {
            Class<?> cls = value.getClass();
            PropertySerializerMap map = _dynamicSerializers;
            ser = map.serializerFor(cls);
            if (ser == null) {
                ser = _findAndAddDynamic(map, cls, prov);
            }
        }
        // and then see if we must suppress certain values (default, empty)
        if (_suppressableValue != null) {
            if (MARKER_FOR_EMPTY == _suppressableValue) {
                if (ser.isEmpty(value)) {
                    return;
                }
            } else if (_suppressableValue.equals(value)) {
                return;
            }
        }
        // For non-nulls: simple check for direct cycles
        if (value == bean) {
            _handleSelfReference(bean, ser);
        }
        jgen.writeFieldName(_name);
        if (_typeSerializer == null) {
            ser.serialize(value, jgen, prov);
        } else {
            ser.serializeWithType(value, jgen, prov, _typeSerializer);
        }
    }

/**
 * Alternative to {@link #serializeAsField} that is used when a POJO
 * is serialized as JSON Array; the difference is that no field names
 * are written.
 * 
 * @since 2.3
 */
@Override
public void serializeAsElement(Object bean, JsonGenerator jgen, SerializerProvider prov)
    throws Exception
{
    Object value = get(bean);
    if (value == null) { // nulls need specialized handling
        if (_nullSerializer != null) {
            _nullSerializer.serialize(null, jgen, prov);
        } else { // can NOT suppress entries in tabular output
            jgen.writeNull();
        }
        return;
    }
    // otherwise find serializer to use
    JsonSerializer<Object> ser = _serializer;
    if (ser == null) {
        Class<?> cls = value.getClass();
        PropertySerializerMap map = _dynamicSerializers;
        ser = map.serializerFor(cls);
        if (ser == null) {
            ser = _findAndAddDynamic(map, cls, prov);
        }
    }
    // and then see if we must suppress certain values (default, empty)
    if (_suppressableValue != null) {
        if (MARKER_FOR_EMPTY == _suppressableValue) {
            if (ser.isEmpty(value)) { // can NOT suppress entries in tabular output
                serializeAsPlaceholder(bean, jgen, prov);
                return;
            }
        } else if (_suppressableValue.equals(value)) { // can NOT suppress entries in tabular output
            serializeAsPlaceholder(bean, jgen, prov);
            return;
        }
    }
    // For non-nulls: simple check for direct cycles
    if (value == bean) {
        _handleSelfReference(bean, ser);
    }
    if (_typeSerializer == null) {
        ser.serialize(value, jgen, prov);
    } else {
        ser.serializeWithType(value, jgen, prov, _typeSerializer);
    }
}

public HibernateProxySerializer(boolean forceLazyLoading)
{
    _property = null;
    _forceLazyLoading = forceLazyLoading;
    _dynamicSerializers = PropertySerializerMap.emptyMap();
}

public void serializeFields(Map<?, ?> paramMap, JsonGenerator paramJsonGenerator, SerializerProvider paramSerializerProvider)
{
  if (this._valueTypeSerializer != null)
  {
    serializeTypedFields(paramMap, paramJsonGenerator, paramSerializerProvider);
    return;
  }
  JsonSerializer localJsonSerializer1 = this._keySerializer;
  HashSet localHashSet = this._ignoredEntries;
  int i;
  if (!paramSerializerProvider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES))
    i = 1;
  else
    i = 0;
  PropertySerializerMap localPropertySerializerMap = this._dynamicValueSerializers;
  Iterator localIterator = paramMap.entrySet().iterator();
  while (localIterator.hasNext())
  {
    Map.Entry localEntry = (Map.Entry)localIterator.next();
    Object localObject1 = localEntry.getValue();
    Object localObject2 = localEntry.getKey();
    if (localObject2 == null)
    {
      paramSerializerProvider.findNullKeySerializer(this._keyType, this._property).serialize(null, paramJsonGenerator, paramSerializerProvider);
    }
    else
    {
      if (((i != 0) && (localObject1 == null)) || ((localHashSet != null) && (localHashSet.contains(localObject2))))
        continue;
      localJsonSerializer1.serialize(localObject2, paramJsonGenerator, paramSerializerProvider);
    }
    if (localObject1 == null)
    {
      paramSerializerProvider.defaultSerializeNull(paramJsonGenerator);
    }
    else
    {
      Class localClass = localObject1.getClass();
      JsonSerializer localJsonSerializer2 = localPropertySerializerMap.serializerFor(localClass);
      JsonSerializer localJsonSerializer3 = localJsonSerializer2;
      if (localJsonSerializer2 == null)
      {
        if (this._valueType.hasGenericTypes())
          localJsonSerializer3 = _findAndAddDynamic(localPropertySerializerMap, paramSerializerProvider.constructSpecializedType(this._valueType, localClass), paramSerializerProvider);
        else
          localJsonSerializer3 = _findAndAddDynamic(localPropertySerializerMap, localClass, paramSerializerProvider);
        localPropertySerializerMap = this._dynamicValueSerializers;
      }
      try
      {
        localJsonSerializer3.serialize(localObject1, paramJsonGenerator, paramSerializerProvider);
      }
      catch (Exception localException)
      {
        wrapAndThrow(paramSerializerProvider, localException, paramMap, String.valueOf(localObject2));
      }
    }
  }
}

public void serializeContents(Object[] paramArrayOfObject, JsonGenerator paramJsonGenerator, SerializerProvider paramSerializerProvider)
{
  int i = paramArrayOfObject.length;
  if (i == 0)
    return;
  if (this._elementSerializer != null)
  {
    serializeContentsUsing(paramArrayOfObject, paramJsonGenerator, paramSerializerProvider, this._elementSerializer);
    return;
  }
  if (this._valueTypeSerializer != null)
  {
    serializeTypedContents(paramArrayOfObject, paramJsonGenerator, paramSerializerProvider);
    return;
  }
  int j = 0;
  Object localObject1 = null;
  while (true)
  {
    try
    {
      PropertySerializerMap localPropertySerializerMap = this._dynamicSerializers;
      if (j < i)
      {
        Object localObject2 = paramArrayOfObject[j];
        localObject1 = localObject2;
        if (localObject2 == null)
        {
          paramSerializerProvider.defaultSerializeNull(paramJsonGenerator);
        }
        else
        {
          Class localClass = localObject1.getClass();
          JsonSerializer localJsonSerializer1 = localPropertySerializerMap.serializerFor(localClass);
          JsonSerializer localJsonSerializer2 = localJsonSerializer1;
          if (localJsonSerializer1 == null)
            if (this._elementType.hasGenericTypes())
              localJsonSerializer2 = _findAndAddDynamic(localPropertySerializerMap, paramSerializerProvider.constructSpecializedType(this._elementType, localClass), paramSerializerProvider);
            else
              localJsonSerializer2 = _findAndAddDynamic(localPropertySerializerMap, localClass, paramSerializerProvider);
          localJsonSerializer2.serialize(localObject1, paramJsonGenerator, paramSerializerProvider);
        }
      }
      else
      {
        return;
      }
    }
    catch (IOException localIOException)
    {
      throw localIOException;
    }
    catch (Exception localException)
    {
      Throwable localThrowable;
      if (((localException instanceof InvocationTargetException)) && (localException.getCause() != null))
      {
        localThrowable = localException.getCause();
        continue;
      }
      if ((localThrowable instanceof Error))
        throw ((Error)localThrowable);
      throw JsonMappingException.wrapWithPath(localThrowable, localObject1, j);
    }
    j++;
  }
}

public void serializeTypedContents(Object[] paramArrayOfObject, JsonGenerator paramJsonGenerator, SerializerProvider paramSerializerProvider)
{
  int i = paramArrayOfObject.length;
  TypeSerializer localTypeSerializer = this._valueTypeSerializer;
  int j = 0;
  Object localObject1 = null;
  while (true)
  {
    try
    {
      PropertySerializerMap localPropertySerializerMap = this._dynamicSerializers;
      if (j < i)
      {
        Object localObject2 = paramArrayOfObject[j];
        localObject1 = localObject2;
        if (localObject2 == null)
        {
          paramSerializerProvider.defaultSerializeNull(paramJsonGenerator);
        }
        else
        {
          Class localClass = localObject1.getClass();
          JsonSerializer localJsonSerializer1 = localPropertySerializerMap.serializerFor(localClass);
          JsonSerializer localJsonSerializer2 = localJsonSerializer1;
          if (localJsonSerializer1 == null)
            localJsonSerializer2 = _findAndAddDynamic(localPropertySerializerMap, localClass, paramSerializerProvider);
          localJsonSerializer2.serializeWithType(localObject1, paramJsonGenerator, paramSerializerProvider, localTypeSerializer);
        }
      }
      else
      {
        return;
      }
    }
    catch (IOException localIOException)
    {
      throw localIOException;
    }
    catch (Exception localException)
    {
      Throwable localThrowable;
      if (((localException instanceof InvocationTargetException)) && (localException.getCause() != null))
      {
        localThrowable = localException.getCause();
        continue;
      }
      if ((localThrowable instanceof Error))
        throw ((Error)localThrowable);
      throw JsonMappingException.wrapWithPath(localThrowable, localObject1, j);
    }
    j++;
  }
}

public void serializeContents(Collection<?> paramCollection, JsonGenerator paramJsonGenerator, SerializerProvider paramSerializerProvider)
{
  if (this._elementSerializer != null)
  {
    serializeContentsUsing(paramCollection, paramJsonGenerator, paramSerializerProvider, this._elementSerializer);
    return;
  }
  Iterator localIterator = paramCollection.iterator();
  if (!localIterator.hasNext())
    return;
  PropertySerializerMap localPropertySerializerMap = this._dynamicSerializers;
  TypeSerializer localTypeSerializer = this._valueTypeSerializer;
  int i = 0;
  try
  {
    do
    {
      Object localObject = localIterator.next();
      if (localObject == null)
      {
        paramSerializerProvider.defaultSerializeNull(paramJsonGenerator);
      }
      else
      {
        Class localClass = localObject.getClass();
        JsonSerializer localJsonSerializer1 = localPropertySerializerMap.serializerFor(localClass);
        JsonSerializer localJsonSerializer2 = localJsonSerializer1;
        if (localJsonSerializer1 == null)
        {
          if (this._elementType.hasGenericTypes())
            localJsonSerializer2 = _findAndAddDynamic(localPropertySerializerMap, paramSerializerProvider.constructSpecializedType(this._elementType, localClass), paramSerializerProvider);
          else
            localJsonSerializer2 = _findAndAddDynamic(localPropertySerializerMap, localClass, paramSerializerProvider);
          localPropertySerializerMap = this._dynamicSerializers;
        }
        if (localTypeSerializer == null)
          localJsonSerializer2.serialize(localObject, paramJsonGenerator, paramSerializerProvider);
        else
          localJsonSerializer2.serializeWithType(localObject, paramJsonGenerator, paramSerializerProvider, localTypeSerializer);
      }
      i++;
    }
    while (localIterator.hasNext());
    return;
  }
  catch (Exception localException)
  {
    wrapAndThrow(paramSerializerProvider, localException, paramCollection, i);
  }
}

public void serializeAsColumn(Object paramObject, JsonGenerator paramJsonGenerator, SerializerProvider paramSerializerProvider)
{
  Object localObject1 = get(paramObject);
  if (localObject1 == null)
  {
    if (this._nullSerializer != null)
    {
      this._nullSerializer.serialize(null, paramJsonGenerator, paramSerializerProvider);
      return;
    }
    paramJsonGenerator.writeNull();
    return;
  }
  JsonSerializer localJsonSerializer1 = this._serializer;
  Object localObject2 = localJsonSerializer1;
  if (localJsonSerializer1 == null)
  {
    Class localClass = localObject1.getClass();
    PropertySerializerMap localPropertySerializerMap = this._dynamicSerializers;
    JsonSerializer localJsonSerializer2 = localPropertySerializerMap.serializerFor(localClass);
    localObject2 = localJsonSerializer2;
    if (localJsonSerializer2 == null)
      localObject2 = _findAndAddDynamic(localPropertySerializerMap, localClass, paramSerializerProvider);
  }
  if (this._suppressableValue != null)
    if (MARKER_FOR_EMPTY == this._suppressableValue)
    {
      if (((JsonSerializer)localObject2).isEmpty(localObject1))
        serializeAsPlaceholder(paramObject, paramJsonGenerator, paramSerializerProvider);
    }
    else if (this._suppressableValue.equals(localObject1))
    {
      serializeAsPlaceholder(paramObject, paramJsonGenerator, paramSerializerProvider);
      return;
    }
  if (localObject1 == paramObject)
    _handleSelfReference(paramObject, (JsonSerializer)localObject2);
  if (this._typeSerializer == null)
  {
    ((JsonSerializer)localObject2).serialize(localObject1, paramJsonGenerator, paramSerializerProvider);
    return;
  }
  ((JsonSerializer)localObject2).serializeWithType(localObject1, paramJsonGenerator, paramSerializerProvider, this._typeSerializer);
}

/**
 * Method called to serialize fields, when the value type is not statically known.
 */
public void serializeFields(Map<?,?> value, JsonGenerator jgen, SerializerProvider provider)
    throws IOException, JsonGenerationException
{
    // If value type needs polymorphic type handling, some more work needed:
    if (_valueTypeSerializer != null) {
        serializeTypedFields(value, jgen, provider);
        return;
    }
    final JsonSerializer<Object> keySerializer = _keySerializer;

    final HashSet<String> ignored = _ignoredEntries;
    final boolean skipNulls = !provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES);

    PropertySerializerMap serializers = _dynamicValueSerializers;

    for (Map.Entry<?,?> entry : value.entrySet()) {
        Object valueElem = entry.getValue();
        // First, serialize key
        Object keyElem = entry.getKey();
        if (keyElem == null) {
            provider.findNullKeySerializer(_keyType, _property).serialize(null, jgen, provider);
        } else {
            // [JACKSON-314] skip entries with null values?
            if (skipNulls && valueElem == null) continue;
            // One twist: is entry ignorable? If so, skip
            if (ignored != null && ignored.contains(keyElem)) continue;
            keySerializer.serialize(keyElem, jgen, provider);
        }

        // And then value
        if (valueElem == null) {
            provider.defaultSerializeNull(jgen);
        } else {
            Class<?> cc = valueElem.getClass();
            JsonSerializer<Object> serializer = serializers.serializerFor(cc);
            if (serializer == null) {
                if (_valueType.hasGenericTypes()) {
                    serializer = _findAndAddDynamic(serializers,
                            provider.constructSpecializedType(_valueType, cc), provider);
                } else {
                    serializer = _findAndAddDynamic(serializers, cc, provider);
                }
                serializers = _dynamicValueSerializers;
            }
            try {
                serializer.serialize(valueElem, jgen, provider);
            } catch (Exception e) {
                // [JACKSON-55] Need to add reference information
                String keyDesc = ""+keyElem;
                wrapAndThrow(provider, e, value, keyDesc);
            }
        }
    }
}

@Override
public void serializeContents(Object[] value, JsonGenerator jgen, SerializerProvider provider)
    throws IOException, JsonGenerationException
{
    final int len = value.length;
    if (len == 0) {
        return;
    }
    if (_elementSerializer != null) {
        serializeContentsUsing(value, jgen, provider, _elementSerializer);
        return;
    }
    if (_valueTypeSerializer != null) {
        serializeTypedContents(value, jgen, provider);
        return;
    }
    int i = 0;
    Object elem = null;
    try {
        PropertySerializerMap serializers = _dynamicSerializers;
        for (; i < len; ++i) {
            elem = value[i];
            if (elem == null) {
                provider.defaultSerializeNull(jgen);
                continue;
            }
            Class<?> cc = elem.getClass();
            JsonSerializer<Object> serializer = serializers.serializerFor(cc);
            if (serializer == null) {
                // To fix [JACKSON-508]
                if (_elementType.hasGenericTypes()) {
                    serializer = _findAndAddDynamic(serializers,
                            provider.constructSpecializedType(_elementType, cc), provider);
                } else {
                    serializer = _findAndAddDynamic(serializers, cc, provider);
                }
            }
            serializer.serialize(elem, jgen, provider);
        }
    } catch (IOException ioe) {
        throw ioe;
    } catch (Exception e) {
        // [JACKSON-55] Need to add reference information
        /* 05-Mar-2009, tatu: But one nasty edge is when we get
         *   StackOverflow: usually due to infinite loop. But that gets
         *   hidden within an InvocationTargetException...
         */
        Throwable t = e;
        while (t instanceof InvocationTargetException && t.getCause() != null) {
            t = t.getCause();
        }
        if (t instanceof Error) {
            throw (Error) t;
        }
        throw JsonMappingException.wrapWithPath(t, elem, i);
    }
}

@Override
public void serializeContents(Collection<?> value, JsonGenerator jgen, SerializerProvider provider)
    throws IOException, JsonGenerationException
{
    if (_elementSerializer != null) {
        serializeContentsUsing(value, jgen, provider, _elementSerializer);
        return;
    }
    Iterator<?> it = value.iterator();
    if (!it.hasNext()) {
        return;
    }
    PropertySerializerMap serializers = _dynamicSerializers;
    final TypeSerializer typeSer = _valueTypeSerializer;

    int i = 0;
    try {
        do {
            Object elem = it.next();
            if (elem == null) {
                provider.defaultSerializeNull(jgen);
            } else {
                Class<?> cc = elem.getClass();
                JsonSerializer<Object> serializer = serializers.serializerFor(cc);
                if (serializer == null) {
                    // To fix [JACKSON-508]
                    if (_elementType.hasGenericTypes()) {
                        serializer = _findAndAddDynamic(serializers,
                                provider.constructSpecializedType(_elementType, cc), provider);
                    } else {
                        serializer = _findAndAddDynamic(serializers, cc, provider);
                    }
                    serializers = _dynamicSerializers;
                }
                if (typeSer == null) {
                    serializer.serialize(elem, jgen, provider);
                } else {
                    serializer.serializeWithType(elem, jgen, provider, typeSer);
                }
            }
            ++i;
        } while (it.hasNext());
    } catch (Exception e) {
        // [JACKSON-55] Need to add reference information
        wrapAndThrow(provider, e, value, i);
    }
}

/**
 * Method called to access property that this bean stands for, from
 * within given bean, and to serialize it as a JSON Object field
 * using appropriate serializer.
 */
public void serializeAsField(Object bean, JsonGenerator jgen, SerializerProvider prov)
    throws Exception
{
    Object value = get(bean);
    // Null handling is bit different, check that first
    if (value == null) {
        if (_nullSerializer != null) {
            jgen.writeFieldName(_name);
            _nullSerializer.serialize(null, jgen, prov);
        }
        return;
    }
    // then find serializer to use
    JsonSerializer<Object> ser = _serializer;
    if (ser == null) {
        Class<?> cls = value.getClass();
        PropertySerializerMap map = _dynamicSerializers;
        ser = map.serializerFor(cls);
        if (ser == null) {
            ser = _findAndAddDynamic(map, cls, prov);
        }
    }
    // and then see if we must suppress certain values (default, empty)
    if (_suppressableValue != null) {
        if (MARKER_FOR_EMPTY == _suppressableValue) {
            if (ser.isEmpty(value)) {
                return;
            }
        } else if (_suppressableValue.equals(value)) {
            return;
        }
    }
    // For non-nulls: simple check for direct cycles
    if (value == bean) {
        _handleSelfReference(bean, ser);
    }
    jgen.writeFieldName(_name);
    if (_typeSerializer == null) {
        ser.serialize(value, jgen, prov);
    } else {
        ser.serializeWithType(value, jgen, prov, _typeSerializer);
    }
}

/**
 * Alternative to {@link #serializeAsField} that is used when a POJO
 * is serialized as JSON Array; the difference is that no field names
 * are written.
 * 
 * @since 2.1
 */
public void serializeAsColumn(Object bean, JsonGenerator jgen, SerializerProvider prov)
    throws Exception
{
    Object value = get(bean);
    if (value == null) { // nulls need specialized handling
        if (_nullSerializer != null) {
            _nullSerializer.serialize(null, jgen, prov);
        } else { // can NOT suppress entries in tabular output
            jgen.writeNull();
        }
    }
    // otherwise find serializer to use
    JsonSerializer<Object> ser = _serializer;
    if (ser == null) {
        Class<?> cls = value.getClass();
        PropertySerializerMap map = _dynamicSerializers;
        ser = map.serializerFor(cls);
        if (ser == null) {
            ser = _findAndAddDynamic(map, cls, prov);
        }
    }
    // and then see if we must suppress certain values (default, empty)
    if (_suppressableValue != null) {
        if (MARKER_FOR_EMPTY == _suppressableValue) {
            if (ser.isEmpty(value)) { // can NOT suppress entries in tabular output
                serializeAsPlaceholder(bean, jgen, prov);
                return;
            }
        } else if (_suppressableValue.equals(value)) { // can NOT suppress entries in tabular output
            serializeAsPlaceholder(bean, jgen, prov);
            return;
        }
    }
    // For non-nulls: simple check for direct cycles
    if (value == bean) {
        _handleSelfReference(bean, ser);
    }
    if (_typeSerializer == null) {
        ser.serialize(value, jgen, prov);
    } else {
        ser.serializeWithType(value, jgen, prov, _typeSerializer);
    }
}