@Override public void serialize( Schema value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { // handle ref schema serialization skipping all other props if (StringUtils.isBlank(value.get$ref())) { defaultSerializer.serialize(value, jgen, provider); } else { jgen.writeStartObject(); jgen.writeStringField("$ref", value.get$ref()); jgen.writeEndObject(); } } }
Class<?> cls = value.getClass(); PropertySerializerMap map = _dynamicSerializers; ser = map.serializerFor(cls); if (ser == null) { ser = _findAndAddDynamic(map, cls, prov); if (ser.isEmpty(prov, value)) { return; if (!ser.isUnwrappingSerializer()) { gen.writeFieldName(_name); ser.serialize(value, gen, prov); } else { ser.serializeWithType(value, gen, prov, _typeSerializer);
/** * Helper method that encapsulates logic of retrieving and caching required * serializer. */ private final JsonSerializer<Object> _findCachedSerializer(SerializerProvider provider, Class<?> rawType) throws JsonMappingException { JsonSerializer<Object> ser = _dynamicSerializers.serializerFor(rawType); if (ser == null) { // NOTE: call this instead of `map._findAndAddDynamic(...)` (which in turn calls // `findAndAddSecondarySerializer`) since we may need to apply unwrapper // too, before caching. But calls made are the same if (_referredType.hasGenericTypes()) { // [databind#1673] Must ensure we will resolve all available type information // so as not to miss generic declaration of, say, `List<GenericPojo>`... JavaType fullType = provider.constructSpecializedType(_referredType, rawType); ser = provider.findValueSerializer(fullType, _property); } else { ser = provider.findValueSerializer(rawType, _property); } if (_unwrapper != null) { ser = ser.unwrappingSerializer(_unwrapper); } _dynamicSerializers = _dynamicSerializers.newWith(rawType, ser); } return ser; }
@Override public void serializeAsElement(Object map, JsonGenerator gen, SerializerProvider provider) throws Exception { if (_typeSerializer == null) { _valueSerializer.serialize(_value, gen, provider); } else { _valueSerializer.serializeWithType(_value, gen, provider, _typeSerializer); } }
protected void _writeNullKeyedEntry(JsonGenerator gen, SerializerProvider provider, Object value) throws IOException JsonSerializer<Object> keySerializer = provider.findNullKeySerializer(_keyType, _property); JsonSerializer<Object> valueSer; if (value == null) { return; valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; if (valueSer == null) { valueSer = _findSerializer(provider, value); if (valueSer.isEmpty(provider, value)) { return; keySerializer.serialize(null, gen, provider); valueSer.serialize(value, gen, provider); } catch (Exception e) { wrapAndThrow(provider, e, value, "");
@Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { JsonSerializer<?> ser = _valueSerializer; if (ser == null) { ser = _findSerializer(visitor.getProvider(), _referredType, _property); if (_unwrapper != null) { ser = ser.unwrappingSerializer(_unwrapper); } } ser.acceptJsonFormatVisitor(visitor, _referredType); }
private final void _serialize(JsonGenerator gen, Object value, JsonSerializer<Object> ser, PropertyName rootName) throws IOException { try { gen.writeStartObject(); gen.writeFieldName(rootName.simpleAsEncoded(_config)); ser.serialize(value, gen, this); gen.writeEndObject(); } catch (Exception e) { throw _wrapAsIOE(gen, e); } }
if ((rootType != null) && !rootType.getRawClass().isAssignableFrom(value.getClass())) { _reportIncompatibleRootType(value, rootType); if ((rootType != null) && rootType.isContainerType()) { valueSer = findValueSerializer(rootType, null); } else { wrap = _config.isEnabled(SerializationFeature.WRAP_ROOT_VALUE); if (wrap) { gen.writeStartObject(); PropertyName pname = _config.findRootName(value.getClass()); gen.writeFieldName(pname.simpleAsEncoded(_config)); } else { wrap = true; gen.writeStartObject(); gen.writeFieldName(rootName.getSimpleName()); valueSer.serializeWithType(value, gen, this, typeSer); if (wrap) { gen.writeEndObject();
protected final void _serializeWithObjectId(Object bean, JsonGenerator gen, SerializerProvider provider, boolean startEndObject) throws IOException { final ObjectIdWriter w = _objectIdWriter; WritableObjectId objectId = provider.findObjectId(bean, w.generator); // If possible, write as id already if (objectId.writeAsId(gen, provider, w)) { return; } // If not, need to inject the id: Object id = objectId.generateId(bean); if (w.alwaysAsId) { w.serializer.serialize(id, gen, provider); return; } if (startEndObject) { gen.writeStartObject(bean); } objectId.writeAsField(gen, provider, w); if (_propertyFilterId != null) { serializeFieldsFiltered(bean, gen, provider); } else { serializeFields(bean, gen, provider); } if (startEndObject) { gen.writeEndObject(); } }
@Override public void serialize(TargetAware value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { if (!unwrapping) { jgen.writeStartObject(); } provider.// findValueSerializer(ProjectionResource.class, null).// unwrappingSerializer(null).// serialize(toResource(value), jgen, provider); if (!unwrapping) { jgen.writeEndObject(); } }
@Override public void serialize(Resource value, JsonGenerator jgen, SerializerProvider provider) throws IOException { final SerializationConfig config = provider.getConfig(); JavaType javaType = config.constructType(value.getClass()); JsonSerializer<Object> serializer = BeanSerializerFactory.instance.createSerializer(provider, javaType); jgen.writeStartObject(); serializer.unwrappingSerializer(NameTransformer.NOP) .serialize(value, jgen, provider); jgen.writeEndObject(); }
provider.findNullKeySerializer(_type.getKeyType(), _property) .serialize(null, gen, provider); } else { _keySerializer.serialize(key, gen, provider); gen.writeStartArray(); for (Object vv : entry.getValue()) { if (vv == null) { provider.defaultSerializeNull(gen); continue; if (valueSer == null) { Class<?> cc = vv.getClass(); valueSer = serializers.serializerFor(cc); if (valueSer == null) { valueSer = _findAndAddDynamic(serializers, cc, provider); valueSer.serialize(vv, gen, provider); } else { valueSer.serializeWithType(vv, gen, provider, _valueTypeSerializer); gen.writeEndArray();
private void _writeContents(Range<?> value, JsonGenerator g, SerializerProvider provider) throws IOException { if (value.hasLowerBound()) { if (_endpointSerializer != null) { g.writeFieldName("lowerEndpoint"); _endpointSerializer.serialize(value.lowerEndpoint(), g, provider); } else { provider.defaultSerializeField("lowerEndpoint", value.lowerEndpoint(), g); } // 20-Mar-2016, tatu: Should not use default handling since it leads to // [datatypes-collections#12] with default typing g.writeStringField("lowerBoundType", value.lowerBoundType().name()); } if (value.hasUpperBound()) { if (_endpointSerializer != null) { g.writeFieldName("upperEndpoint"); _endpointSerializer.serialize(value.upperEndpoint(), g, provider); } else { provider.defaultSerializeField("upperEndpoint", value.upperEndpoint(), g); } // same as above; should always be just String so g.writeStringField("upperBoundType", value.upperBoundType().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 gen) throws IOException { gen.writeFieldName(fieldName); if (value == null) { /* Note: can't easily check for suppression at this point * any more; caller must check it. */ if (_stdNullValueSerializer) { // minor perf optimization gen.writeNull(); } else { _nullValueSerializer.serialize(null, gen, this); } } else { Class<?> cls = value.getClass(); findTypedValueSerializer(cls, true, null).serialize(value, gen, this); } }
/** * Method called to output Object Id as specified. */ public void writeAsField(JsonGenerator gen, SerializerProvider provider, ObjectIdWriter w) throws IOException { idWritten = true; // 03-Aug-2013, tatu: Prefer Native Object Ids if available if (gen.canWriteObjectId()) { // Need to assume String(ified) ids, for now... could add 'long' variant? gen.writeObjectId(String.valueOf(id)); return; } SerializableString name = w.propertyName; if (name != null) { gen.writeFieldName(name); w.serializer.serialize(id, gen, provider); } } }
void write(Object val, int containedTypeIndex, JsonGenerator gen, SerializerProvider provider) throws IOException { if (val != null) { if (type.containedTypeCount() > containedTypeIndex) { JsonSerializer<Object> ser; JavaType containedType = type.containedType(containedTypeIndex); if (containedType != null && containedType.hasGenericTypes()) { JavaType st = provider.constructSpecializedType(containedType, val.getClass()); ser = provider.findTypedValueSerializer(st, true, null); } else { ser = provider.findTypedValueSerializer(val.getClass(), true, null); } ser.serialize(val, gen, provider); } else { gen.writeObject(val); } } else { gen.writeNull(); } }
protected void _serializeDynamicContents(Iterator<?> value, JsonGenerator g, SerializerProvider provider) throws IOException { final TypeSerializer typeSer = _valueTypeSerializer; PropertySerializerMap serializers = _dynamicSerializers; do { Object elem = value.next(); if (elem == null) { provider.defaultSerializeNull(g); continue; } Class<?> cc = elem.getClass(); JsonSerializer<Object> serializer = serializers.serializerFor(cc); if (serializer == null) { 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, g, provider); } else { serializer.serializeWithType(elem, g, provider, typeSer); } } while (value.hasNext()); } }
if (value == null) { // nulls need specialized handling if (_nullSerializer != null) { _nullSerializer.serialize(null, gen, prov); } else { // can NOT suppress entries in tabular output gen.writeNull(); Class<?> cls = value.getClass(); PropertySerializerMap map = _dynamicSerializers; ser = map.serializerFor(cls); if (ser == null) { ser = _findAndAddDynamic(map, cls, prov); if (ser.isEmpty(prov, value)) { // can NOT suppress entries in ser.serialize(value, gen, prov); } else { ser.serializeWithType(value, gen, prov, _typeSerializer);
/** * 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 gen) throws IOException { if (value == null) { if (_stdNullValueSerializer) { // minor perf optimization gen.writeNull(); } else { _nullValueSerializer.serialize(null, gen, this); } } else { Class<?> cls = value.getClass(); findTypedValueSerializer(cls, true, null).serialize(value, gen, this); } }