Refine search
jgen.writeStartObject(); jgen.writeFieldName(_rootNames.findRootName(value.getClass(), _config)); ser.serialize(value, jgen, this); if (wrap) { jgen.writeEndObject(); msg = "[no message for "+e.getClass().getName()+"]"; throw new JsonMappingException(msg, e);
if (!ser.isUnwrappingSerializer()) { jgen.writeFieldName(_name); ser.serialize(value, jgen, prov); } else { ser.serializeWithType(value, jgen, prov, _typeSerializer);
/** * Method for adding given serializer for type that {@link JsonSerializer#handledType} * specifies (which MUST return a non-null class; and can NOT be {@link Object}, as a * sanity check). * For serializers that do not declare handled type, use the variant that takes * two arguments. * * @param ser */ public void addSerializer(JsonSerializer<?> ser) { // Interface to match? Class<?> cls = ser.handledType(); if (cls == null || cls == Object.class) { throw new IllegalArgumentException("JsonSerializer of type "+ser.getClass().getName() +" does not define valid handledType() -- must either register with method that takes type argument " +" or make serializer extend 'org.codehaus.jackson.map.ser.std.SerializerBase'"); } _addSerializer(cls, ser); }
@Override public BeanPropertyWriter withSerializer(JsonSerializer<Object> ser) { if (getClass() != UnwrappingBeanPropertyWriter.class) { throw new IllegalStateException("UnwrappingBeanPropertyWriter sub-class does not override 'withSerializer()'; needs to!"); } // better try to create unwrapping instance if (!ser.isUnwrappingSerializer()) { ser = ser.unwrappingSerializer(); } return new UnwrappingBeanPropertyWriter(this, ser); }
@Override protected JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map, Class<?> type, SerializerProvider provider) throws JsonMappingException { JsonSerializer<Object> serializer; if (_nonTrivialBaseType != null) { JavaType subtype = provider.constructSpecializedType(_nonTrivialBaseType, type); serializer = provider.findValueSerializer(subtype, this); } else { serializer = provider.findValueSerializer(type, this); } if (!serializer.isUnwrappingSerializer()) { serializer = serializer.unwrappingSerializer(); } _dynamicSerializers = _dynamicSerializers.newWith(type, serializer); return serializer; } }
elem = value[i]; if (elem == null) { provider.defaultSerializeNull(jgen); continue; ser.serialize(elem, jgen, provider); } else { ser.serializeWithType(elem, jgen, provider, typeSer); throw (Error) t; throw JsonMappingException.wrapWithPath(t, elem, i);
@Override public void serialize(TabularData data, JsonGenerator jsonGenerator, SerializerProvider provider) throws IOException { jsonGenerator.writeStartArray(); JsonSerializer<Object> mapSerializer = provider.findValueSerializer(Map.class, null); for (Map<String, Object> map : toList(data)) { if (!map.isEmpty()) { mapSerializer.serialize(map, jsonGenerator, provider); } } jsonGenerator.writeEndArray(); }
protected void serializeContentsUsing(EnumMap<? extends Enum<?>,?> value, JsonGenerator jgen, SerializerProvider provider, JsonSerializer<Object> valueSer) throws IOException, JsonGenerationException { EnumValues keyEnums = _keyEnums; for (Map.Entry<? extends Enum<?>,?> entry : value.entrySet()) { Enum<?> key = entry.getKey(); if (keyEnums == null) { // clumsy, but has to do for now: SerializerBase<?> ser = (SerializerBase<?>) provider.findValueSerializer(key.getDeclaringClass(), _property); keyEnums = ((EnumSerializer) ser).getEnumValues(); } jgen.writeFieldName(keyEnums.serializedValueFor(key)); Object valueElem = entry.getValue(); if (valueElem == null) { provider.defaultSerializeNull(jgen); } else { try { valueSer.serialize(valueElem, jgen, provider); } catch (Exception e) { wrapAndThrow(provider, e, value, entry.getKey().name()); } } } }
/** * Convenience method that will serialize given field with specified * value. Value may be null. Serializer is done using the usual * null) using standard serializer locating functionality. */ public final void defaultSerializeField(String fieldName, Object value, JsonGenerator jgen) throws IOException, JsonProcessingException { jgen.writeFieldName(fieldName); if (value == null) { /* Note: can't easily check for suppression at this point * any more; caller must check it. */ getNullValueSerializer().serialize(null, jgen, this); } else { Class<?> cls = value.getClass(); findTypedValueSerializer(cls, true, null).serialize(value, jgen, this); } }
@Override @SuppressWarnings("deprecation") public void serialize(JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { // First, wrapping: if (_prefix != null) jgen.writeRaw(_prefix); if (_value == null) { provider.defaultSerializeNull(jgen); } else if (_serializationType != null) { provider.findTypedValueSerializer(_serializationType, true, null).serialize(_value, jgen, provider); } else { Class<?> cls = _value.getClass(); provider.findTypedValueSerializer(cls, true, null).serialize(_value, jgen, provider); } if (_suffix != null) jgen.writeRaw(_suffix); }
jgen.writeFieldName(_name); prov.defaultSerializeNull(jgen); jgen.writeFieldName(_name); if (_typeSerializer == null) { ser.serialize(value, jgen, prov); } else { ser.serializeWithType(value, jgen, prov, _typeSerializer);
/** * Convenience method that will serialize given field with specified * value. Value may be null. Serializer is done using the usual * null) using standard serializer locating functionality. */ public final void defaultSerializeField(String fieldName, Object value, JsonGenerator jgen) throws IOException, JsonProcessingException { jgen.writeFieldName(fieldName); if (value == null) { /* Note: can't easily check for suppression at this point * any more; caller must check it. */ getNullValueSerializer().serialize(null, jgen, this); } else { findValueSerializer(value.getClass()).serialize(value, jgen, this); } }
final HashSet<String> ignored = _ignoredEntries; final TypeSerializer typeSer = _valueTypeSerializer; final boolean skipNulls = !provider.isEnabled(SerializationConfig.Feature.WRITE_NULL_MAP_VALUES); Object keyElem = entry.getKey(); if (keyElem == null) { provider.getNullKeySerializer().serialize(null, jgen, provider); } else { keySerializer.serialize(keyElem, jgen, provider); provider.defaultSerializeNull(jgen); } else { try { if (typeSer == null) { ser.serialize(valueElem, jgen, provider); } else { ser.serializeWithType(valueElem, jgen, provider, typeSer);
Object elem = value.next(); if (elem == null) { provider.defaultSerializeNull(jgen); } else { currSerializer = prevSerializer; } else { currSerializer = provider.findValueSerializer(cc, _property); prevSerializer = currSerializer; prevClass = cc; currSerializer.serialize(elem, jgen, provider); } else { currSerializer.serializeWithType(elem, jgen, provider, typeSer);
public void serializeContentsUsing(List<?> value, JsonGenerator jgen, SerializerProvider provider, JsonSerializer<Object> ser) throws IOException, JsonGenerationException { final int len = value.size(); if (len == 0) { return; } final TypeSerializer typeSer = _valueTypeSerializer; for (int i = 0; i < len; ++i) { Object elem = value.get(i); try { if (elem == null) { provider.defaultSerializeNull(jgen); } else if (typeSer == null) { ser.serialize(elem, jgen, provider); } else { ser.serializeWithType(elem, jgen, provider, typeSer); } } catch (Exception e) { // [JACKSON-55] Need to add reference information wrapAndThrow(provider, e, value, i); } } }
elem = value[i]; if (elem == null) { provider.defaultSerializeNull(jgen); continue; serializer = _findAndAddDynamic(serializers, cc, provider); serializer.serializeWithType(elem, jgen, provider, typeSer); throw (Error) t; throw JsonMappingException.wrapWithPath(t, elem, i);
elem = value[i]; if (elem == null) { provider.defaultSerializeNull(jgen); continue; provider.constructSpecializedType(_elementType, cc), provider); } else { serializer = _findAndAddDynamic(serializers, cc, provider); serializer.serialize(elem, jgen, provider); throw (Error) t; throw JsonMappingException.wrapWithPath(t, elem, i);
final boolean skipNulls = !provider.isEnabled(SerializationConfig.Feature.WRITE_NULL_MAP_VALUES); provider.getNullKeySerializer().serialize(null, jgen, provider); } else { keySerializer.serialize(keyElem, jgen, provider); provider.defaultSerializeNull(jgen); } else { Class<?> cc = valueElem.getClass(); serializer.serialize(valueElem, jgen, provider); } catch (Exception e) {
/** * Convenience method that will serialize given value (which can be * null) using standard serializer locating functionality. It can * be called for all values including field and Map values, but usually * field values are best handled calling * {@link #defaultSerializeField} instead. */ public final void defaultSerializeValue(Object value, JsonGenerator jgen) throws IOException, JsonProcessingException { if (value == null) { getNullValueSerializer().serialize(null, jgen, this); } else { Class<?> cls = value.getClass(); findTypedValueSerializer(cls, true, null).serialize(value, jgen, this); } }
ser = prov.getNullValueSerializer(); } else { ser = _serializer; if (ser == null) { ser = prov.findValueSerializer(value.getClass()); ser.serialize(value, jgen, prov); } catch (IOException ioe) { throw ioe; throw JsonMappingException.wrapWithPath(t, bean, _accessorMethod.getName() + "()");