public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { JsonSerializer<?> ser = null; if (property != null) { AnnotatedMember m = property.getMember(); if (m != null) { Object serDef = provider.getAnnotationIntrospector().findContentSerializer(m); if (serDef != null) { ser = provider.serializerInstance(m, serDef); } } } if (ser == null) { ser = this._elementSerializer; } ser = findConvertingContentSerializer(provider, property, ser); if (ser == null) { ser = provider.findValueSerializer(String.class, property); } else { ser = provider.handleSecondaryContextualization(ser, property); } if (isDefaultSerializer(ser)) { ser = null; } return ser == this._elementSerializer ? this : new StringArraySerializer(this, property, ser); }
public JsonNode getSchema(SerializerProvider paramSerializerProvider, Type paramType) throws JsonMappingException { ObjectNode localObjectNode = createSchemaNode("array", true); if (paramType != null) { paramType = paramSerializerProvider.constructType(paramType); if (paramType.isArrayType()) { paramType = ((ArrayType) paramType).getContentType().getRawClass(); if (paramType != Object.class) { break label54; } localObjectNode.set("items", JsonSchema.getDefaultSchemaNode()); } } return localObjectNode; label54: paramType = paramSerializerProvider.findValueSerializer(paramType, this._property); if ((paramType instanceof SchemaAware)) {} for (paramSerializerProvider = ((SchemaAware) paramType).getSchema(paramSerializerProvider, null); ; paramSerializerProvider = JsonSchema.getDefaultSchemaNode()) { localObjectNode.set("items", paramSerializerProvider); return localObjectNode; } }
/** * Method called to serialize fields, when the value type is statically known, so that value * serializer is passed and does not need to be fetched from provider. */ public void serializeFieldsUsing( Map<?, ?> value, JsonGenerator gen, SerializerProvider provider, JsonSerializer<Object> ser) throws IOException { final JsonSerializer<Object> keySerializer = _keySerializer; final Set<String> ignored = _ignoredEntries; final TypeSerializer typeSer = _valueTypeSerializer; for (Map.Entry<?, ?> entry : value.entrySet()) { Object keyElem = entry.getKey(); if (ignored != null && ignored.contains(keyElem)) continue; if (keyElem == null) { provider.findNullKeySerializer(_keyType, _property).serialize(null, gen, provider); } else { keySerializer.serialize(keyElem, gen, provider); } final Object valueElem = entry.getValue(); if (valueElem == null) { provider.defaultSerializeNull(gen); } else { try { if (typeSer == null) { ser.serialize(valueElem, gen, provider); } else { ser.serializeWithType(valueElem, gen, provider, typeSer); } } catch (Exception e) { wrapAndThrow(provider, e, value, String.valueOf(keyElem)); } } } }
protected void _writeNullKeyedEntry(JsonGenerator gen, SerializerProvider provider, Object value) throws IOException { JsonSerializer<Object> keySerializer = provider.findNullKeySerializer(_keyType, _property); JsonSerializer<Object> valueSer; if (value == null) { if (_suppressNulls) { return; } valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; if (valueSer == null) { valueSer = _findSerializer(provider, value); } if (_suppressableValue == MARKER_FOR_EMPTY) { if (valueSer.isEmpty(provider, value)) { return; } } else if ((_suppressableValue != null) && (_suppressableValue.equals(value))) { return; } } try { keySerializer.serialize(null, gen, provider); valueSer.serialize(value, gen, provider); } catch (Exception e) { wrapAndThrow(provider, e, value, ""); } }
protected boolean _useStatic( SerializerProvider provider, BeanProperty property, JavaType referredType) { // First: no serializer for `Object.class`, must be dynamic if (referredType.isJavaLangObject()) { return false; } // but if type is final, might as well fetch if (referredType.isFinal()) { // or should we allow annotation override? (only if requested...) return true; } // also: if indicated by typing, should be considered static if (referredType.useStaticType()) { return true; } // if neither, maybe explicit annotation? AnnotationIntrospector intr = provider.getAnnotationIntrospector(); if ((intr != null) && (property != null)) { Annotated ann = property.getMember(); if (ann != null) { JsonSerialize.Typing t = intr.findSerializationTyping(property.getMember()); if (t == JsonSerialize.Typing.STATIC) { return true; } if (t == JsonSerialize.Typing.DYNAMIC) { return false; } } } // and finally, may be forced by global static typing (unlikely...) return provider.isEnabled(MapperFeature.USE_STATIC_TYPING); }
@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); }
/** * Helper method used when we have a JSON Filter to use for potentially filtering out Map entries. * * @since 2.5 */ public void serializeFilteredFields( Map<?, ?> value, JsonGenerator gen, SerializerProvider provider, PropertyFilter filter, Object suppressableValue) // since 2.5 throws IOException { final Set<String> ignored = _ignoredEntries; final MapProperty prop = new MapProperty(_valueTypeSerializer, _property); final boolean checkEmpty = (MARKER_FOR_EMPTY == suppressableValue); for (Map.Entry<?, ?> entry : value.entrySet()) { // First, serialize key; unless ignorable by key final Object keyElem = entry.getKey(); if (ignored != null && ignored.contains(keyElem)) continue; JsonSerializer<Object> keySerializer; if (keyElem == null) { keySerializer = provider.findNullKeySerializer(_keyType, _property); } else { keySerializer = _keySerializer; } // or by value; nulls often suppressed final Object valueElem = entry.getValue(); JsonSerializer<Object> valueSer; // And then value if (valueElem == null) { if (_suppressNulls) { continue; } valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; if (valueSer == null) { valueSer = _findSerializer(provider, valueElem); } // also may need to skip non-empty values: if (checkEmpty) { if (valueSer.isEmpty(provider, valueElem)) { continue; } } else if (suppressableValue != null) { if (suppressableValue.equals(valueElem)) { continue; } } } // and with that, ask filter to handle it prop.reset(keyElem, keySerializer, valueSer); try { filter.serializeAsField(valueElem, gen, provider, prop); } catch (Exception e) { wrapAndThrow(provider, e, value, String.valueOf(keyElem)); } } }
/** Serialization method called when exclusion filtering needs to be applied. */ public void serializeOptionalFields( Map<?, ?> value, JsonGenerator gen, SerializerProvider provider, Object suppressableValue) throws IOException { // If value type needs polymorphic type handling, some more work needed: if (_valueTypeSerializer != null) { serializeTypedFields(value, gen, provider, suppressableValue); return; } final Set<String> ignored = _ignoredEntries; final boolean checkEmpty = (MARKER_FOR_EMPTY == suppressableValue); for (Map.Entry<?, ?> entry : value.entrySet()) { // First find key serializer final Object keyElem = entry.getKey(); JsonSerializer<Object> keySerializer; if (keyElem == null) { keySerializer = provider.findNullKeySerializer(_keyType, _property); } else { if (ignored != null && ignored.contains(keyElem)) continue; keySerializer = _keySerializer; } // Then value serializer final Object valueElem = entry.getValue(); JsonSerializer<Object> valueSer; if (valueElem == null) { if (_suppressNulls) { // all suppressions include null-suppression continue; } valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; if (valueSer == null) { valueSer = _findSerializer(provider, valueElem); } // also may need to skip non-empty values: if (checkEmpty) { if (valueSer.isEmpty(provider, valueElem)) { continue; } } else if (suppressableValue != null) { if (suppressableValue.equals(valueElem)) { continue; } } } // and then serialize, if all went well try { keySerializer.serialize(keyElem, gen, provider); valueSer.serialize(valueElem, gen, provider); } catch (Exception e) { wrapAndThrow(provider, e, value, String.valueOf(keyElem)); } } }
/** 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); } } } }
/** @since 2.5 */ public void serializeTypedFields( Map<?, ?> value, JsonGenerator gen, SerializerProvider provider, Object suppressableValue) // since 2.5 throws IOException { final Set<String> ignored = _ignoredEntries; final boolean checkEmpty = (MARKER_FOR_EMPTY == suppressableValue); for (Map.Entry<?, ?> entry : value.entrySet()) { Object keyElem = entry.getKey(); JsonSerializer<Object> keySerializer; if (keyElem == null) { keySerializer = provider.findNullKeySerializer(_keyType, _property); } else { // One twist: is entry ignorable? If so, skip if (ignored != null && ignored.contains(keyElem)) continue; keySerializer = _keySerializer; } final Object valueElem = entry.getValue(); // And then value JsonSerializer<Object> valueSer; if (valueElem == null) { if (_suppressNulls) { // all suppression include null suppression continue; } valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; if (valueSer == null) { valueSer = _findSerializer(provider, valueElem); } // also may need to skip non-empty values: if (checkEmpty) { if (valueSer.isEmpty(provider, valueElem)) { continue; } } else if (suppressableValue != null) { if (suppressableValue.equals(valueElem)) { continue; } } } keySerializer.serialize(keyElem, gen, provider); try { valueSer.serializeWithType(valueElem, gen, provider, _valueTypeSerializer); } catch (Exception e) { wrapAndThrow(provider, e, value, String.valueOf(keyElem)); } } }
// !!! TODO: added late in 2.7 in `jackson-databind`: remove from 2.8 protected JsonSerializer<?> findContentSerializer( SerializerProvider serializers, BeanProperty property) throws JsonMappingException { if (property != null) { AnnotatedMember m = property.getMember(); final AnnotationIntrospector intr = serializers.getAnnotationIntrospector(); if (m != null) { Object serDef = intr.findContentSerializer(m); if (serDef != null) { return serializers.serializerInstance(m, serDef); } } } return null; }
@Override public JsonArrayFormatVisitor expectArrayFormat(JavaType type) throws JsonMappingException { serializerProvider .findValueSerializer(type.getContentType()) .acceptJsonFormatVisitor(createSubtraverser(baseName), type.getContentType()); return new JsonArrayFormatVisitor.Base(serializerProvider); }
/** * Main serialization method needs to be overridden to allow XML-specific extra handling, such as * indication of whether to write attributes or elements. */ @Override protected void serializeFields(Object bean, JsonGenerator jgen0, SerializerProvider provider) throws IOException, JsonGenerationException { // 19-Aug-2013, tatu: During 'convertValue()', need to skip if (!(jgen0 instanceof ToXmlGenerator)) { super.serializeFields(bean, jgen0, provider); return; } final ToXmlGenerator xgen = (ToXmlGenerator) jgen0; final BeanPropertyWriter[] props; if (_filteredProps != null && provider.getActiveView() != null) { props = _filteredProps; } else { props = _props; } final int attrCount = _attributeCount; if (attrCount > 0) { xgen.setNextIsAttribute(true); } final int textIndex = _textPropertyIndex; final QName[] xmlNames = _xmlNames; int i = 0; try { for (final int len = props.length; i < len; ++i) { if (i == attrCount) { xgen.setNextIsAttribute(false); } // also: if this is property to write as text ("unwrap"), need to: if (i == textIndex) { xgen.setNextIsUnwrapped(true); } xgen.setNextName(xmlNames[i]); BeanPropertyWriter prop = props[i]; if (prop != null) { // can have nulls in filtered list prop.serializeAsField(bean, xgen, provider); } // Reset to avoid next value being written as unwrapped, // for example when property is suppressed if (i == textIndex) { xgen.setNextIsUnwrapped(false); } } if (_anyGetterWriter != null) { _anyGetterWriter.getAndSerialize(bean, xgen, provider); } } catch (Exception e) { String name = (i == props.length) ? "[anySetter]" : props[i].getName(); wrapAndThrow(provider, e, bean, name); } catch (StackOverflowError e) { // Bit tricky, can't do more calls as stack is full; so: JsonMappingException mapE = new JsonMappingException("Infinite recursion (StackOverflowError)"); String name = (i == props.length) ? "[anySetter]" : props[i].getName(); mapE.prependPath(new JsonMappingException.Reference(bean, name)); throw mapE; } }
public JsonSerializer<?> createContextual( SerializerProvider paramSerializerProvider, BeanProperty paramBeanProperty) throws JsonMappingException { Object localObject2 = null; Object localObject1 = localObject2; if (paramBeanProperty != null) { AnnotatedMember localAnnotatedMember = paramBeanProperty.getMember(); localObject1 = localObject2; if (localAnnotatedMember != null) { Object localObject3 = paramSerializerProvider .getAnnotationIntrospector() .findContentSerializer(localAnnotatedMember); localObject1 = localObject2; if (localObject3 != null) { localObject1 = paramSerializerProvider.serializerInstance(localAnnotatedMember, localObject3); } } } localObject2 = localObject1; if (localObject1 == null) { localObject2 = this._valueSerializer; } localObject1 = findConvertingContentSerializer( paramSerializerProvider, paramBeanProperty, (JsonSerializer) localObject2); if (localObject1 == null) { if (!this._staticTyping) { break label111; } paramSerializerProvider = withValueSerializer( paramBeanProperty, paramSerializerProvider.findValueSerializer(this._valueType, paramBeanProperty)); } label111: do { return paramSerializerProvider; localObject1 = paramSerializerProvider.handleSecondaryContextualization( (JsonSerializer) localObject1, paramBeanProperty); paramSerializerProvider = this; } while (localObject1 == this._valueSerializer); return withValueSerializer(paramBeanProperty, (JsonSerializer) localObject1); }
@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); }
protected void serializeTypedFields( Map<?, ?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { final JsonSerializer<Object> keySerializer = _keySerializer; JsonSerializer<Object> prevValueSerializer = null; Class<?> prevValueClass = null; final HashSet<String> ignored = _ignoredEntries; final boolean skipNulls = !provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES); 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] also may need to 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> currSerializer; if (cc == prevValueClass) { currSerializer = prevValueSerializer; } else { currSerializer = provider.findValueSerializer(cc, _property); prevValueSerializer = currSerializer; prevValueClass = cc; } try { currSerializer.serializeWithType(valueElem, jgen, provider, _valueTypeSerializer); } catch (Exception e) { // [JACKSON-55] Need to add reference information String keyDesc = "" + keyElem; wrapAndThrow(provider, e, value, keyDesc); } } } }
public void serializeTypedContents( Object[] paramArrayOfObject, JsonGenerator paramJsonGenerator, SerializerProvider paramSerializerProvider) throws IOException { int k = paramArrayOfObject.length; TypeSerializer localTypeSerializer = this._valueTypeSerializer; int j = 0; int i = 0; Object localObject1 = null; for (; ; ) { try { PropertySerializerMap localPropertySerializerMap = this._dynamicSerializers; if (i < k) { Object localObject2 = paramArrayOfObject[i]; if (localObject2 == null) { localObject1 = localObject2; j = i; paramSerializerProvider.defaultSerializeNull(paramJsonGenerator); } else { localObject1 = localObject2; j = i; Class localClass = localObject2.getClass(); localObject1 = localObject2; j = i; JsonSerializer localJsonSerializer2 = localPropertySerializerMap.serializerFor(localClass); JsonSerializer localJsonSerializer1 = localJsonSerializer2; if (localJsonSerializer2 == null) { localObject1 = localObject2; j = i; localJsonSerializer1 = _findAndAddDynamic( localPropertySerializerMap, localClass, paramSerializerProvider); } localObject1 = localObject2; j = i; localJsonSerializer1.serializeWithType( localObject2, paramJsonGenerator, paramSerializerProvider, localTypeSerializer); } } } catch (IOException paramArrayOfObject) { throw paramArrayOfObject; } catch (Exception paramArrayOfObject) { if (((paramArrayOfObject instanceof InvocationTargetException)) && (paramArrayOfObject.getCause() != null)) { paramArrayOfObject = paramArrayOfObject.getCause(); continue; } if ((paramArrayOfObject instanceof Error)) { throw ((Error) paramArrayOfObject); } throw JsonMappingException.wrapWithPath(paramArrayOfObject, localObject1, j); } return; i += 1; } }
@Override public void serialize( ObjectId objectId, BsonGenerator bsonGenerator, SerializerProvider serializerProvider) throws IOException { if (objectId == null) { serializerProvider.defaultSerializeNull(bsonGenerator); } else { bsonGenerator.writeObjectId(objectId); } }
@Override public void serialize(Symbol value, JsonGenerator gen, SerializerProvider serializerProvider) throws IOException { if (value == null) { serializerProvider.defaultSerializeNull(gen); } else if (gen instanceof BsonGenerator) { BsonGenerator bgen = (BsonGenerator) gen; bgen.writeSymbol(value); } else { gen.writeString(value.getSymbol()); } }
private void serializeContentsSlow( String[] value, JsonGenerator jgen, SerializerProvider provider, JsonSerializer<Object> ser) throws IOException, JsonGenerationException { int len = value.length; for (int i = 0; i < len; i++) { if (value[i] == null) { provider.defaultSerializeNull(jgen); } else { ser.serialize(value[i], jgen, provider); } } }
/** * General-purpose serialization for contents, where we do not necessarily know the value * serialization, but we do know that no value suppression is needed (which simplifies processing * a bit) */ public void serializeFields(Map<?, ?> value, JsonGenerator gen, SerializerProvider provider) throws IOException { // If value type needs polymorphic type handling, some more work needed: if (_valueTypeSerializer != null) { serializeTypedFields(value, gen, provider, null); return; } final JsonSerializer<Object> keySerializer = _keySerializer; final Set<String> ignored = _ignoredEntries; Object keyElem = null; try { for (Map.Entry<?, ?> entry : value.entrySet()) { Object valueElem = entry.getValue(); // First, serialize key keyElem = entry.getKey(); if (keyElem == null) { provider.findNullKeySerializer(_keyType, _property).serialize(null, gen, provider); } else { // One twist: is entry ignorable? If so, skip if ((ignored != null) && ignored.contains(keyElem)) { continue; } keySerializer.serialize(keyElem, gen, provider); } // And then value if (valueElem == null) { provider.defaultSerializeNull(gen); continue; } JsonSerializer<Object> serializer = _valueSerializer; if (serializer == null) { serializer = _findSerializer(provider, valueElem); } serializer.serialize(valueElem, gen, provider); } } catch (Exception e) { // Add reference information wrapAndThrow(provider, e, value, String.valueOf(keyElem)); } }
private final JsonSerializer<Object> _findSerializer(SerializerProvider provider, Object value) throws JsonMappingException { final Class<?> cc = value.getClass(); JsonSerializer<Object> valueSer = _dynamicValueSerializers.serializerFor(cc); if (valueSer != null) { return valueSer; } if (_valueType.hasGenericTypes()) { return _findAndAddDynamic( _dynamicValueSerializers, provider.constructSpecializedType(_valueType, cc), provider); } return _findAndAddDynamic(_dynamicValueSerializers, cc, provider); }
// need to override as we must get unwrapping instance... @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); } NameTransformer t = _nameTransformer; if (serializer.isUnwrappingSerializer()) { t = NameTransformer.chainedTransformer( t, ((UnwrappingBeanSerializer) serializer)._nameTransformer); } serializer = serializer.unwrappingSerializer(t); _dynamicSerializers = _dynamicSerializers.newWith(type, serializer); return serializer; }
@Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { /* 29-Sep-2012, tatu: Actually, we need to do much more contextual * checking here since we finally know for sure the property, * and it may have overrides */ JsonSerializer<?> ser = null; // First: if we have a property, may have property-annotation overrides if (property != null) { AnnotatedMember m = property.getMember(); if (m != null) { Object serDef = provider.getAnnotationIntrospector().findContentSerializer(m); if (serDef != null) { ser = provider.serializerInstance(m, serDef); } } } if (ser == null) { ser = _serializer; } // #124: May have a content converter ser = findConvertingContentSerializer(provider, property, ser); if (ser == null) { ser = provider.findValueSerializer(String.class, property); } else if (ser instanceof ContextualSerializer) { ser = ((ContextualSerializer) ser).createContextual(provider, property); } // Optimization: default serializer just writes String, so we can avoid a call: if (isDefaultSerializer(ser)) { ser = null; } // note: will never have TypeSerializer, because Strings are "natural" type if (ser == _serializer) { return this; } return new IndexedStringListSerializer(ser); }
// @Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { /* 29-Sep-2012, tatu: Actually, we need to do much more contextual * checking here since we finally know for sure the property, * and it may have overrides */ JsonSerializer<?> ser = null; JsonSerializer<?> keySer = null; // First: if we have a property, may have property-annotation overrides if (property != null) { AnnotatedMember m = property.getMember(); if (m != null) { Object serDef; final AnnotationIntrospector intr = provider.getAnnotationIntrospector(); serDef = intr.findKeySerializer(m); if (serDef != null) { keySer = provider.serializerInstance(m, serDef); } serDef = intr.findContentSerializer(m); if (serDef != null) { ser = provider.serializerInstance(m, serDef); } } } if (ser == null) { ser = _valueSerializer; } if (ser == null) { // 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated, // we can consider it a static case as well. if (_valueTypeIsStatic || hasContentTypeAnnotation(provider, property)) { ser = provider.findValueSerializer(_valueType, property); } } else if (ser instanceof ContextualSerializer) { ser = ((ContextualSerializer) ser).createContextual(provider, property); } if (keySer == null) { keySer = _keySerializer; } if (keySer == null) { keySer = provider.findKeySerializer(_keyType, property); } else if (keySer instanceof ContextualSerializer) { keySer = ((ContextualSerializer) keySer).createContextual(provider, property); } HashSet<String> ignored = this._ignoredEntries; 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); }
@Override public void serialize(DateMidnight dt, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { if (provider.isEnabled(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)) { // same as with other date-only values jgen.writeStartArray(); jgen.writeNumber(dt.year().get()); jgen.writeNumber(dt.monthOfYear().get()); jgen.writeNumber(dt.dayOfMonth().get()); jgen.writeEndArray(); } else { jgen.writeString(format.print(dt)); } }
/** * Method called to serialize fields, when the value type is statically known, so that value * serializer is passed and does not need to be fetched from provider. */ protected void serializeFieldsUsing( Map<?, ?> value, JsonGenerator jgen, SerializerProvider provider, JsonSerializer<Object> ser) throws IOException, JsonGenerationException { final JsonSerializer<Object> keySerializer = _keySerializer; final HashSet<String> ignored = _ignoredEntries; final TypeSerializer typeSer = _valueTypeSerializer; final boolean skipNulls = !provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES); for (Map.Entry<?, ?> entry : value.entrySet()) { Object valueElem = entry.getValue(); Object keyElem = entry.getKey(); if (keyElem == null) { provider.findNullKeySerializer(_keyType, _property).serialize(null, jgen, provider); } else { // [JACKSON-314] also may need to skip entries with null values if (skipNulls && valueElem == null) continue; if (ignored != null && ignored.contains(keyElem)) continue; keySerializer.serialize(keyElem, jgen, provider); } if (valueElem == null) { provider.defaultSerializeNull(jgen); } else { try { if (typeSer == null) { ser.serialize(valueElem, jgen, provider); } else { ser.serializeWithType(valueElem, jgen, provider, typeSer); } } catch (Exception e) { // [JACKSON-55] Need to add reference information String keyDesc = "" + keyElem; wrapAndThrow(provider, e, value, keyDesc); } } } }
public JsonNode getSchema(SerializerProvider paramSerializerProvider, Type paramType) throws JsonMappingException { ObjectNode localObjectNode1 = createSchemaNode("object", true); if ((paramType instanceof ParameterizedType)) { Object localObject = ((ParameterizedType) paramType).getActualTypeArguments(); if (localObject.length == 2) { paramType = paramSerializerProvider.constructType(localObject[0]); localObject = paramSerializerProvider.constructType(localObject[1]); ObjectNode localObjectNode2 = JsonNodeFactory.instance.objectNode(); Enum[] arrayOfEnum = (Enum[]) paramType.getRawClass().getEnumConstants(); int j = arrayOfEnum.length; int i = 0; if (i < j) { Enum localEnum = arrayOfEnum[i]; paramType = paramSerializerProvider.findValueSerializer( ((JavaType) localObject).getRawClass(), this._property); if ((paramType instanceof SchemaAware)) {} for (paramType = ((SchemaAware) paramType).getSchema(paramSerializerProvider, null); ; paramType = JsonSchema.getDefaultSchemaNode()) { localObjectNode2.set( paramSerializerProvider .getConfig() .getAnnotationIntrospector() .findEnumValue(localEnum), paramType); i += 1; break; } } localObjectNode1.set("properties", localObjectNode2); } } return localObjectNode1; }
@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 serialize(Map<?, ?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeStartObject(); 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); } } jgen.writeEndObject(); }