@Override
public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property)
throws JsonMappingException {
TypeSerializer vts = _valueTypeSerializer;
if (vts != null) {
vts = vts.forProperty(property);
}
JsonSerializer<?> ser = findContentSerializer(provider, property);
if (ser == null) {
ser = _valueSerializer;
if (ser == null) {
// A few conditions needed to be able to fetch serializer here:
if (_useStatic(provider, property, _referredType)) {
ser = _findSerializer(provider, _referredType, property);
}
} else {
ser = provider.handlePrimaryContextualization(ser, property);
}
}
// Also: may want to have more refined exclusion based on referenced value
JsonInclude.Include contentIncl = _contentInclusion;
if (property != null) {
JsonInclude.Value incl = property.findPropertyInclusion(provider.getConfig(), Optional.class);
JsonInclude.Include newIncl = incl.getContentInclusion();
if ((newIncl != contentIncl) && (newIncl != JsonInclude.Include.USE_DEFAULTS)) {
contentIncl = newIncl;
}
}
return withResolved(property, vts, ser, _unwrapper, contentIncl);
}
/**
* Method called to locate regular serializer, matching type serializer, and if both found, wrap
* them in a serializer that calls both in correct sequence. This method is currently only used
* for root-level serializer handling to allow for simpler caching. A call can always be replaced
* by equivalent calls to access serializer and type serializer separately.
*
* @param valueType Declared type of value being serialized (which may not be actual runtime
* type); used for finding both value serializer and type serializer to use for adding
* polymorphic type (if any)
* @param cache Whether resulting value serializer should be cached or not; this is just a hint
* @param property When creating secondary serializers, property for which serializer is needed:
* annotations of the property (or bean that contains it) may be checked to create contextual
* serializers.
*/
public JsonSerializer<Object> findTypedValueSerializer(
JavaType valueType, boolean cache, BeanProperty property) throws JsonMappingException {
// Two-phase lookups; local non-shared cache, then shared:
JsonSerializer<Object> ser = _knownSerializers.typedValueSerializer(valueType);
if (ser != null) {
return ser;
}
// If not, maybe shared map already has it?
ser = _serializerCache.typedValueSerializer(valueType);
if (ser != null) {
return ser;
}
// Well, let's just compose from pieces:
ser = findValueSerializer(valueType, property);
TypeSerializer typeSer = _serializerFactory.createTypeSerializer(_config, valueType);
if (typeSer != null) {
typeSer = typeSer.forProperty(property);
ser = new TypeWrappedSerializer(typeSer, ser);
}
if (cache) {
_serializerCache.addTypedSerializer(valueType, ser);
}
return ser;
}
@Override
public void serializeWithType(
byte[] value, JsonGenerator g, SerializerProvider provider, TypeSerializer typeSer)
throws IOException {
typeSer.writeTypePrefixForScalar(value, g);
g.writeBinary(provider.getConfig().getBase64Variant(), value, 0, value.length);
typeSer.writeTypeSuffixForScalar(value, g);
}
@Override
public void serializeWithType(
final Interval value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)
throws IOException, JsonProcessingException {
typeSer.writeTypePrefixForScalar(value, jgen, Interval.class);
serialize(value, jgen, provider);
typeSer.writeTypeSuffixForScalar(value, jgen);
}
@Override
public void serializeWithType(
T value, JsonGenerator generator, SerializerProvider provider, TypeSerializer serializer)
throws IOException {
serializer.writeTypePrefixForScalar(value, generator);
this.serialize(value, generator, provider);
serializer.writeTypeSuffixForScalar(value, generator);
}
public final void serializeWithType(
TokenBuffer paramTokenBuffer,
JsonGenerator paramJsonGenerator,
SerializerProvider paramSerializerProvider,
TypeSerializer paramTypeSerializer) {
paramTypeSerializer.writeTypePrefixForScalar(paramTokenBuffer, paramJsonGenerator);
serialize(paramTokenBuffer, paramJsonGenerator, paramSerializerProvider);
paramTypeSerializer.writeTypeSuffixForScalar(paramTokenBuffer, paramJsonGenerator);
}
public void serializeWithType(
TimeZone timezone,
JsonGenerator jsongenerator,
SerializerProvider serializerprovider,
TypeSerializer typeserializer)
throws IOException, JsonGenerationException {
typeserializer.writeTypePrefixForScalar(timezone, jsongenerator, java / util / TimeZone);
serialize(timezone, jsongenerator, serializerprovider);
typeserializer.writeTypeSuffixForScalar(timezone, jsongenerator);
}
public final void serializeWithType(
TokenBuffer tokenbuffer,
JsonGenerator jsongenerator,
SerializerProvider serializerprovider,
TypeSerializer typeserializer)
throws IOException, JsonGenerationException {
typeserializer.writeTypePrefixForScalar(tokenbuffer, jsongenerator);
serialize(tokenbuffer, jsongenerator, serializerprovider);
typeserializer.writeTypeSuffixForScalar(tokenbuffer, jsongenerator);
}
@Override
public void serializeWithType(
final HyperLogLogPlus value,
final JsonGenerator gen,
final SerializerProvider serializers,
final TypeSerializer typeSer)
throws IOException {
typeSer.writeTypePrefixForObject(value, gen);
_serialise(value, gen);
typeSer.writeTypeSuffixForObject(value, gen);
}
@Override
public void serializeWithType(
List<String> value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)
throws IOException, JsonGenerationException {
typeSer.writeTypePrefixForArray(value, jgen);
if (_serializer == null) {
serializeContents(value, jgen, provider);
} else {
serializeUsingCustom(value, jgen, provider);
}
typeSer.writeTypeSuffixForArray(value, jgen);
}
public void serializeWithType(
EnumMap<? extends Enum<?>, ?> paramEnumMap,
JsonGenerator paramJsonGenerator,
SerializerProvider paramSerializerProvider,
TypeSerializer paramTypeSerializer)
throws IOException, JsonGenerationException {
paramTypeSerializer.writeTypePrefixForObject(paramEnumMap, paramJsonGenerator);
if (!paramEnumMap.isEmpty()) {
serializeContents(paramEnumMap, paramJsonGenerator, paramSerializerProvider);
}
paramTypeSerializer.writeTypeSuffixForObject(paramEnumMap, paramJsonGenerator);
}
@Override
public void serializeWithType(
Optional<?> opt, JsonGenerator gen, SerializerProvider provider, TypeSerializer typeSer)
throws IOException {
if (!opt.isPresent()) {
if (_unwrapper == null) {
provider.defaultSerializeNull(gen);
}
return;
}
// Otherwise apply type-prefix/suffix, then std serialize:
typeSer.writeTypePrefixForScalar(opt, gen, Optional.class);
serialize(opt, gen, provider);
typeSer.writeTypeSuffixForScalar(opt, gen);
}
@Override
public void serializeWithType(
Map<?, ?> value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)
throws IOException, JsonGenerationException {
typeSer.writeTypePrefixForObject(value, jgen);
if (!value.isEmpty()) {
if (provider.isEnabled(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)) {
value = _orderEntries(value);
}
if (_valueSerializer != null) {
serializeFieldsUsing(value, jgen, provider, _valueSerializer);
} else {
serializeFields(value, jgen, provider);
}
}
typeSer.writeTypeSuffixForObject(value, jgen);
}
@Override
public void serializeWithType(
Map<?, ?> value, JsonGenerator gen, SerializerProvider provider, TypeSerializer typeSer)
throws IOException {
typeSer.writeTypePrefixForObject(value, gen);
// [databind#631]: Assign current value, to be accessible by custom serializers
gen.setCurrentValue(value);
if (!value.isEmpty()) {
if (_sortKeys || provider.isEnabled(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)) {
value = _orderEntries(value, gen, provider);
}
PropertyFilter pf;
if ((_filterId != null) && (pf = findPropertyFilter(provider, _filterId, value)) != null) {
serializeFilteredFields(value, gen, provider, pf, _suppressableValue);
} else if ((_suppressableValue != null) || _suppressNulls) {
serializeOptionalFields(value, gen, provider, _suppressableValue);
} else if (_valueSerializer != null) {
serializeFieldsUsing(value, gen, provider, _valueSerializer);
} else {
serializeFields(value, gen, provider);
}
}
typeSer.writeTypeSuffixForObject(value, gen);
}
@Override
protected void _serializeObjectId(
Object bean,
JsonGenerator jgen,
SerializerProvider provider,
TypeSerializer typeSer,
WritableObjectId objectId)
throws IOException, JsonProcessingException, JsonGenerationException {
/* Ok: let's serialize type id as attribute, but if (and only if!)
* we are using AS_PROPERTY
*/
if (typeSer.getTypeInclusion() == JsonTypeInfo.As.PROPERTY) {
ToXmlGenerator xgen = (ToXmlGenerator) jgen;
xgen.setNextIsAttribute(true);
super._serializeObjectId(bean, jgen, provider, typeSer, objectId);
if (_attributeCount == 0) { // if no attributes, need to reset
xgen.setNextIsAttribute(false);
}
} else {
super._serializeObjectId(bean, jgen, provider, typeSer, objectId);
}
}
@Override
public void serializeWithType(
Object bean, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)
throws IOException, JsonGenerationException {
if (_objectIdWriter != null) {
_serializeWithObjectId(bean, jgen, provider, typeSer);
return;
}
/* Ok: let's serialize type id as attribute, but if (and only if!)
* we are using AS_PROPERTY
*/
if (typeSer.getTypeInclusion() == JsonTypeInfo.As.PROPERTY) {
ToXmlGenerator xgen = (ToXmlGenerator) jgen;
xgen.setNextIsAttribute(true);
super.serializeWithType(bean, jgen, provider, typeSer);
if (_attributeCount == 0) { // if no attributes, need to reset
xgen.setNextIsAttribute(false);
}
} else {
super.serializeWithType(bean, jgen, provider, typeSer);
}
}
