/** * @since 2.3 * * @deprecated Since 2.8 use the other overload */ @Deprecated // since 2.8 public static MapSerializer construct(String[] ignoredList, JavaType mapType, boolean staticValueType, TypeSerializer vts, JsonSerializer<Object> keySerializer, JsonSerializer<Object> valueSerializer, Object filterId) { Set<String> ignoredEntries = ArrayBuilders.arrayToSet(ignoredList); return construct(ignoredEntries, mapType, staticValueType, vts, keySerializer, valueSerializer, filterId); }
keyType = valueType = UNSPECIFIED_TYPE; } else { keyType = mapType.getKeyType(); valueType = mapType.getContentType(); staticValueType = (valueType != null && valueType.isFinal()); } else { MapSerializer ser = new MapSerializer(ignoredEntries, keyType, valueType, staticValueType, vts, keySerializer, valueSerializer); if (filterId != null) { ser = ser.withFilterId(filterId);
@Override public void serialize(Map<?,?> value, JsonGenerator gen, SerializerProvider provider) throws IOException { gen.writeStartObject(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); } } gen.writeEndObject(); }
@Override public MapSerializer _withValueTypeSerializer(TypeSerializer vts) { if (_valueTypeSerializer == vts) { return this; } _ensureOverride("_withValueTypeSerializer"); return new MapSerializer(this, vts, _suppressableValue, _suppressNulls); }
final AnnotationIntrospector intr = provider.getAnnotationIntrospector(); final AnnotatedMember propertyAcc = (property == null) ? null : property.getMember(); Object suppressableValue = _suppressableValue; Object serDef = intr.findKeySerializer(propertyAcc); if (serDef != null) { keySer = provider.serializerInstance(propertyAcc, serDef); ser = provider.serializerInstance(propertyAcc, serDef); ser = findConvertingContentSerializer(provider, property, ser); if (ser == null) { if ((_valueTypeIsStatic && _valueType.getRawClass() != Object.class) || hasContentTypeAnnotation(provider, property)) { ser = provider.findValueSerializer(_valueType, property); sortKeys = (b != null) && b.booleanValue(); MapSerializer mser = withResolved(property, keySer, ser, ignored, sortKeys); if (suppressableValue != _suppressableValue) { mser = mser.withContentInclusion(suppressableValue); Object filterId = intr.findFilterId(m); if (filterId != null) { mser = mser.withFilterId(filterId);
if (_neitherNull(propertyAcc, intr)) { Object serDef = intr.findKeySerializer(propertyAcc); if (serDef != null) { keySer = provider.serializerInstance(propertyAcc, serDef); ser = findContextualConvertingSerializer(provider, property, ser); if (ser == null) { if (_neitherNull(propertyAcc, intr)) { JsonIgnoreProperties.Value ignorals = intr.findPropertyIgnorals(propertyAcc); if (ignorals != null){ Set<String> newIgnored = ignorals.findIgnoredForSerialization(); if (_nonEmpty(newIgnored)) { ignored = (ignored == null) ? new HashSet<String>() : new HashSet<String>(ignored); for (String str : newIgnored) { ignored.add(str); JsonFormat.Value format = findFormatOverrides(provider, property, Map.class); if (format != null) { Boolean B = format.getFeature(JsonFormat.Feature.WRITE_SORTED_MAP_ENTRIES); MapSerializer mser = withResolved(property, keySer, ser, ignored, sortKeys); Object filterId = intr.findFilterId(m); if (filterId != null) { mser = mser.withFilterId(filterId); mser = mser.withContentInclusion(valueToSuppress, suppressNulls);
if (m != null) { Object serDef; final AnnotationIntrospector intr = provider.getAnnotationIntrospector(); serDef = intr.findKeySerializer(m); if (serDef != null) { keySer = provider.serializerInstance(m, serDef); ser = provider.serializerInstance(m, serDef); if (_valueTypeIsStatic || hasContentTypeAnnotation(provider, property)) { ser = provider.findValueSerializer(_valueType, property); String[] moreToIgnore = intr.findPropertiesToIgnore(property.getMember()); if (moreToIgnore != null) { ignored = (ignored == null) ? new HashSet<String>() : new HashSet<String>(ignored); for (String str : moreToIgnore) { ignored.add(str); return withResolved(property, keySer, ser, ignored);
if (ser == null) { if (_valueTypeIsStatic) { ser = provider.findValueSerializer(_valueType, property); keySer = provider.findKeySerializer(_keyType, property); } else if (keySer instanceof ContextualSerializer) { keySer = ((ContextualSerializer) keySer).createContextual(provider, property); AnnotationIntrospector intr = provider.getAnnotationIntrospector(); if (intr != null && property != null) { String[] moreToIgnore = intr.findPropertiesToIgnore(property.getMember()); if (moreToIgnore != null) { ignored = (ignored == null) ? new HashSet<String>() : new HashSet<String>(ignored); for (String str : moreToIgnore) { ignored.add(str); return withResolved(property, keySer, ser, ignored);
ser = provider.serializerInstance(propertyAcc, serDef); JsonInclude.Value inclV = findIncludeOverrides(provider, property, Map.class); JsonInclude.Include incl = inclV.getContentInclusion(); if ((incl != null) && (incl != JsonInclude.Include.USE_DEFAULTS)) { ser = findConvertingContentSerializer(provider, property, ser); if (ser == null) { if (_valueTypeIsStatic && !_valueType.isJavaLangObject()) { ser = provider.findValueSerializer(_valueType, property); sortKeys = (b != null) && b.booleanValue(); JsonFormat.Value format = findFormatOverrides(provider, property, Map.class); if (format != null) { Boolean B = format.getFeature(JsonFormat.Feature.WRITE_SORTED_MAP_ENTRIES); MapSerializer mser = withResolved(property, keySer, ser, ignored, sortKeys); if (suppressableValue != _suppressableValue) { mser = mser.withContentInclusion(suppressableValue); Object filterId = intr.findFilterId(m); if (filterId != null) { mser = mser.withFilterId(filterId);
protected void _writeNullKeyedEntry(JsonGenerator gen, SerializerProvider provider, Object suppressableValue, Object value) throws IOException return; valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; if (valueSer == null) { Class<?> cc = value.getClass(); valueSer = _dynamicValueSerializers.serializerFor(cc); if (valueSer == null) { if (_valueType.hasGenericTypes()) { valueSer = _findAndAddDynamic(_dynamicValueSerializers, provider.constructSpecializedType(_valueType, cc), provider); } else { valueSer = _findAndAddDynamic(_dynamicValueSerializers, cc, provider); && valueSer.isEmpty(provider, value)) { return; keySerializer.serialize(null, gen, provider); valueSer.serialize(value, gen, provider); } catch (Exception e) { String keyDesc = ""; wrapAndThrow(provider, e, value, keyDesc);
provider.findNullKeySerializer(_keyType, _property).serialize(null, gen, provider); } else { keySerializer.serialize(keyElem, gen, provider); provider.defaultSerializeNull(gen); } else { try { if (typeSer == null) { ser.serialize(valueElem, gen, provider); } else { ser.serializeWithType(valueElem, gen, provider, typeSer); wrapAndThrow(provider, e, value, String.valueOf(keyElem));
serializeTypedFields(value, gen, provider, null); return; provider.findNullKeySerializer(_keyType, _property).serialize(null, gen, provider); } else { if (ignored != null && ignored.contains(keyElem)) continue; keySerializer.serialize(keyElem, gen, provider); provider.defaultSerializeNull(gen); } 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); serializer.serialize(valueElem, gen, provider); } catch (Exception e) { wrapAndThrow(provider, e, value, keyDesc);
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, "");
if (keyType.isEnumType()) { // non-enum if we got it as type erased class (from instance) @SuppressWarnings("unchecked") Class<Enum<?>> enumClass = (Class<Enum<?>>) keyType.getRawClass(); enums = EnumValues.construct(enumClass, config.getAnnotationIntrospector()); elementTypeSerializer, elementValueSerializer); return MapSerializer.construct(config.getAnnotationIntrospector().findPropertiesToIgnore(beanDesc.getClassInfo()), type, staticTyping, elementTypeSerializer, keySerializer, elementValueSerializer);
serializeTypedFields(value, gen, provider, null); return; provider.findNullKeySerializer(_keyType, _property).serialize(null, gen, provider); } else { continue; keySerializer.serialize(keyElem, gen, provider); provider.defaultSerializeNull(gen); continue; serializer = _findSerializer(provider, valueElem); serializer.serialize(valueElem, gen, provider); wrapAndThrow(provider, e, value, String.valueOf(keyElem));
@Override public JsonSerializer<?> findMapSerializer(SerializationConfig config, MapType type, BeanDescription beanDesc, JsonSerializer<Object> keySerializer, TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) { // without this logic, Jackson will not be able to handle maps containing // hibernate proxies if (AbstractEntity.class.isAssignableFrom(type.getContentType().getRawClass())) { Object filterId = config.getAnnotationIntrospector().findFilterId((Annotated)beanDesc.getClassInfo()); return MapSerializer.construct( config.getAnnotationIntrospector().findPropertyIgnorals(beanDesc.getClassInfo()).getIgnored(), type, false, elementTypeSerializer, keySerializer, elementValueSerializer, filterId); } else { return null; } }
public void getAndSerialize(Object bean, JsonGenerator gen, SerializerProvider provider) throws Exception { Object value = _accessor.getValue(bean); if (value == null) { return; } if (!(value instanceof Map<?,?>)) { provider.reportBadDefinition(_property.getType(), String.format( "Value returned by 'any-getter' %s() not java.util.Map but %s", _accessor.getName(), value.getClass().getName())); } // 23-Feb-2015, tatu: Nasty, but has to do (for now) if (_mapSerializer != null) { _mapSerializer.serializeFields((Map<?,?>) value, gen, provider); return; } _serializer.serialize(value, gen, provider); }
public void getAndSerialize(Object bean, JsonGenerator gen, SerializerProvider provider) throws Exception { Object value = _accessor.getValue(bean); if (value == null) { return; } if (!(value instanceof Map<?,?>)) { throw new JsonMappingException("Value returned by 'any-getter' (" +_accessor.getName()+"()) not java.util.Map but "+value.getClass().getName()); } // 23-Feb-2015, tatu: Nasty, but has to do (for now) if (_mapSerializer != null) { _mapSerializer.serializeFields((Map<?,?>) value, gen, provider); return; } _serializer.serialize(value, gen, provider); }
public static MapSerializer construct(String[] ignoredList, JavaType mapType, boolean staticValueType, TypeSerializer vts, JsonSerializer<Object> keySerializer, JsonSerializer<Object> valueSerializer) { HashSet<String> ignoredEntries = toSet(ignoredList); JavaType keyType, valueType; if (mapType == null) { keyType = valueType = UNSPECIFIED_TYPE; } else { keyType = mapType.getKeyType(); valueType = mapType.getContentType(); } // If value type is final, it's same as forcing static value typing: if (!staticValueType) { staticValueType = (valueType != null && valueType.isFinal()); } return new MapSerializer(ignoredEntries, keyType, valueType, staticValueType, vts, keySerializer, valueSerializer); }
return prov.getUnknownTypeSerializer(Object.class); final SerializationConfig config = prov.getConfig(); BeanSerializerBuilder builder = constructBeanSerializerBuilder(beanDesc); builder.setConfig(config); prov.getAnnotationIntrospector().findAndAddVirtualProperties(config, beanDesc.getClassInfo(), props); JavaType valueType = type.getContentType(); TypeSerializer typeSer = createTypeSerializer(config, valueType); if (anySer == null) { anySer = MapSerializer.construct(/* ignored props*/ (Set<String>) null,