/** * Need to get callback to resolve value serializer, if static typing * is used (either being forced, or because value type is final) */ @Override public void resolve(SerializerProvider provider) throws JsonMappingException { if (_staticTyping && _elementType != null && _elementSerializer == null) { _elementSerializer = provider.findValueSerializer(_elementType, _property); } }
/** * Need to get callback to resolve value serializer, if static typing * is used (either being forced, or because value type is final) */ @Override public void resolve(SerializerProvider provider) throws JsonMappingException { if (_staticTyping && _elementSerializer == null) { _elementSerializer = provider.findValueSerializer(_elementType, _property); } }
@Override public void resolve(SerializerProvider provider) throws JsonMappingException { if (_staticTyping && _valueSerializer == null) { _valueSerializer = provider.findValueSerializer(_valueType, _property); } }
/** * Deprecated version of accessor method that was used before version 1.7. * Implemented as final to ensure that existing code does not accidentally * try to redefine it (given that it is not called by core mapper code) * * @deprecated As of version 1.7, use version that exposes property object * instead of just its type (needed for contextual serializers) */ @Deprecated public final JsonSerializer<Object> findValueSerializer(Class<?> runtimeType) throws JsonMappingException { return findValueSerializer(runtimeType, null); }
/** * Deprecated version of accessor method that was used before version 1.7. * Implemented as final to ensure that existing code does not accidentally * try to redefine it (given that it is not called by core mapper code) * * @deprecated As of version 1.7, use version that exposes property object * instead of just its type (needed for contextual serializers) */ @Deprecated public final JsonSerializer<Object> findValueSerializer(JavaType serializationType) throws JsonMappingException { return findValueSerializer(serializationType, null); }
/** * Need to get callback to resolve value serializer, which may * be overridden by custom serializer */ @Override public void resolve(SerializerProvider provider) throws JsonMappingException { JsonSerializer<Object> ser = provider.findValueSerializer(String.class, _property); // Retain if not the standard implementation if (ser != null && ser.getClass().getAnnotation(JacksonStdImpl.class) == null) { _elementSerializer = ser; } }
@SuppressWarnings("unchecked") @Override public void resolve(SerializerProvider provider) throws JsonMappingException { if (_serializer == null) { JsonSerializer<?> ser = provider.findValueSerializer(String.class, _property); if (!isDefaultSerializer(ser)) { _serializer = (JsonSerializer<String>) ser; } } }
@SuppressWarnings("unchecked") @Override public void resolve(SerializerProvider provider) throws JsonMappingException { if (_serializer == null) { JsonSerializer<?> ser = provider.findValueSerializer(String.class, _property); if (!isDefaultSerializer(ser)) { _serializer = (JsonSerializer<String>) ser; } } }
@Override public void serializeContents(EnumSet<? extends Enum<?>> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { JsonSerializer<Object> enumSer = _elementSerializer; /* Need to dynamically find instance serializer; unfortunately * that seems to be the only way to figure out type (no accessors * to the enum class that set knows) */ for (Enum<?> en : value) { if (enumSer == null) { /* 12-Jan-2010, tatu: Since enums can not be polymorphic, let's * not bother with typed serializer variant here */ enumSer = provider.findValueSerializer(en.getDeclaringClass(), _property); } enumSer.serialize(en, jgen, provider); } } }
/** * Need to get callback to resolve value serializer, if static typing * is used (either being forced, or because value type is final) */ @Override public void resolve(SerializerProvider provider) throws JsonMappingException { if (_valueTypeIsStatic && _valueSerializer == null) { _valueSerializer = provider.findValueSerializer(_valueType, _property); } /* 10-Dec-2010, tatu: Let's also fetch key serializer; and always assume we'll * do that just by using static type information */ /* 25-Feb-2011, tatu: May need to reconsider this static checking (since it * differs from value handling)... but for now, it's ok to ensure contextual * aspects are handled; this is done by provider. */ if (_keySerializer == null) { _keySerializer = provider.findKeySerializer(_keyType, _property); } }
/** * Method called if initial lookup fails; will both find serializer * and construct new map instance if warranted, and return both * @throws JsonMappingException */ public final SerializerAndMapResult findAndAddSerializer(Class<?> type, SerializerProvider provider, BeanProperty property) throws JsonMappingException { JsonSerializer<Object> serializer = provider.findValueSerializer(type, property); return new SerializerAndMapResult(serializer, newWith(type, serializer)); }
@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; } }
currSerializer = prevSerializer; } else { currSerializer = provider.findValueSerializer(cc, _property); prevSerializer = currSerializer; prevClass = cc;
public final SerializerAndMapResult findAndAddSerializer(JavaType type, SerializerProvider provider, BeanProperty property) throws JsonMappingException { JsonSerializer<Object> serializer = provider.findValueSerializer(type, property); return new SerializerAndMapResult(serializer, newWith(type.getRawClass(), serializer)); }
currSerializer = prevSerializer; } else { currSerializer = provider.findValueSerializer(cc, _property); prevSerializer = currSerializer; prevClass = cc;
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()); } } } }
JsonSerializer<Object> ser = provider.findValueSerializer(contentType, _property); if (ser instanceof SchemaAware) { schemaNode = ((SchemaAware) ser).getSchema(provider, null);
@SuppressWarnings("unchecked") @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { ObjectNode o = createSchemaNode("object", true); if (typeHint instanceof ParameterizedType) { Type[] typeArgs = ((ParameterizedType) typeHint).getActualTypeArguments(); if (typeArgs.length == 2) { JavaType enumType = provider.constructType(typeArgs[0]); JavaType valueType = provider.constructType(typeArgs[1]); ObjectNode propsNode = JsonNodeFactory.instance.objectNode(); Class<Enum<?>> enumClass = (Class<Enum<?>>) enumType.getRawClass(); for (Enum<?> enumValue : enumClass.getEnumConstants()) { JsonSerializer<Object> ser = provider.findValueSerializer(valueType.getRawClass(), _property); JsonNode schemaNode = (ser instanceof SchemaAware) ? ((SchemaAware) ser).getSchema(provider, null) : JsonSchema.getDefaultSchemaNode(); propsNode.put(provider.getConfig().getAnnotationIntrospector().findEnumValue((Enum<?>)enumValue), schemaNode); } o.put("properties", propsNode); } } return o; } }
@Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { ObjectNode o = createSchemaNode("array", true); if (typeHint != null) { JavaType javaType = provider.constructType(typeHint); if (javaType.isArrayType()) { Class<?> componentType = ((ArrayType) javaType).getContentType().getRawClass(); // 15-Oct-2010, tatu: We can't serialize plain Object.class; but what should it produce here? Untyped? if (componentType == Object.class) { o.put("items", JsonSchema.getDefaultSchemaNode()); } else { JsonSerializer<Object> ser = provider.findValueSerializer(componentType, _property); JsonNode schemaNode = (ser instanceof SchemaAware) ? ((SchemaAware) ser).getSchema(provider, null) : JsonSchema.getDefaultSchemaNode(); o.put("items", schemaNode); } } } return o; }
@Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { ObjectNode o = createSchemaNode("object", true); //todo: should the classname go in the title? //o.put("title", _className); ObjectNode propertiesNode = o.objectNode(); for (int i = 0; i < _props.length; i++) { BeanPropertyWriter prop = _props[i]; JavaType propType = prop.getSerializationType(); // 03-Dec-2010, tatu: SchemaAware REALLY should use JavaType, but alas it doesn't... Type hint = (propType == null) ? prop.getGenericPropertyType() : propType.getRawClass(); // Maybe it already has annotated/statically configured serializer? JsonSerializer<Object> ser = prop.getSerializer(); if (ser == null) { // nope Class<?> serType = prop.getRawSerializationType(); if (serType == null) { serType = prop.getPropertyType(); } ser = provider.findValueSerializer(serType, prop); } JsonNode schemaNode = (ser instanceof SchemaAware) ? ((SchemaAware) ser).getSchema(provider, hint) : JsonSchema.getDefaultSchemaNode(); propertiesNode.put(prop.getName(), schemaNode); } o.put("properties", propertiesNode); return o; }