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