private void _addSerializer(Class<?> cls, JsonSerializer<?> ser) { ClassKey key = new ClassKey(cls); // Interface or class type? if (cls.isInterface()) { if (_interfaceMappings == null) { _interfaceMappings = new HashMap<ClassKey,JsonSerializer<?>>(); } _interfaceMappings.put(key, ser); } else { // nope, class: if (_classMappings == null) { _classMappings = new HashMap<ClassKey,JsonSerializer<?>>(); } _classMappings.put(key, ser); } }
/** * Method for adding a mapping from super type to specific subtype. * Arguments will be checked by method, to ensure that <code>superType</code> * is abstract (since resolver is never called for concrete classes); * as well as to ensure that there is supertype/subtype relationship * (to ensure there won't be cycles during resolution). * * @param superType Abstract type to resolve * @param subType Sub-class of superType, to map superTo to * * @return This resolver, to allow chaining of initializations */ public <T> SimpleAbstractTypeResolver addMapping(Class<T> superType, Class<? extends T> subType) { // Sanity checks, just in case someone tries to force typing... if (superType == subType) { throw new IllegalArgumentException("Can not add mapping from class to itself"); } if (!superType.isAssignableFrom(subType)) { throw new IllegalArgumentException("Can not add mapping from class "+superType.getName() +" to "+subType.getName()+", as latter is not a subtype of former"); } if (!Modifier.isAbstract(superType.getModifiers())) { throw new IllegalArgumentException("Can not add mapping from class "+superType.getName() +" since it is not abstract"); } _mappings.put(new ClassKey(superType), subType); return this; }
@Test public void testPageModule() throws Exception { PageModuleProvider pmp = new PageModuleProvider(); Module module = pmp.getModule(); assertTrue(module instanceof SimpleModule); Field field = module.getClass().getDeclaredField("_serializers"); field.setAccessible(true); SimpleSerializers simpleSerializers = (SimpleSerializers) field.get(module); field = simpleSerializers.getClass().getDeclaredField("_interfaceMappings"); field.setAccessible(true); HashMap<ClassKey, JsonSerializer<?>> classMappings = (HashMap) field.get(simpleSerializers); assertTrue(classMappings.containsKey(new ClassKey(Page.class))); }
public MapperConfigBase(BaseSettings paramBaseSettings, SubtypeResolver paramSubtypeResolver, Map<ClassKey, Class<?>> paramMap) { super(paramBaseSettings, DEFAULT_MAPPER_FEATURES); this._mixInAnnotations = paramMap; this._subtypeResolver = paramSubtypeResolver; this._rootName = null; this._view = null; }
public MapperConfigBase(MapperConfigBase<CFG, T> paramMapperConfigBase, Map<ClassKey, Class<?>> paramMap) { super(paramMapperConfigBase); this._mixInAnnotations = paramMap; this._subtypeResolver = paramMapperConfigBase._subtypeResolver; this._rootName = paramMapperConfigBase._rootName; this._view = paramMapperConfigBase._view; }
private void _addSerializer(Class<?> paramClass, JsonSerializer<?> paramJsonSerializer) { ClassKey localClassKey = new ClassKey(paramClass); if (paramClass.isInterface()) { if (this._interfaceMappings == null) this._interfaceMappings = new HashMap(); this._interfaceMappings.put(localClassKey, paramJsonSerializer); return; } if (this._classMappings == null) this._classMappings = new HashMap(); this._classMappings.put(localClassKey, paramJsonSerializer); }
protected JsonSerializer<?> _findInterfaceMapping(Class<?> paramClass, ClassKey paramClassKey) { for (Class localClass : paramClass.getInterfaces()) { paramClassKey.reset(localClass); JsonSerializer localJsonSerializer1 = (JsonSerializer)this._interfaceMappings.get(paramClassKey); if (localJsonSerializer1 != null) return localJsonSerializer1; JsonSerializer localJsonSerializer2 = _findInterfaceMapping(localClass, paramClassKey); if (localJsonSerializer2 != null) return localJsonSerializer2; } return null; }
public SimpleKeyDeserializers addDeserializer(Class<?> paramClass, KeyDeserializer paramKeyDeserializer) { if (this._classMappings == null) this._classMappings = new HashMap(); this._classMappings.put(new ClassKey(paramClass), paramKeyDeserializer); return this; }
public ValueInstantiator findValueInstantiator(DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, ValueInstantiator paramValueInstantiator) { ValueInstantiator localValueInstantiator = (ValueInstantiator)this._classMappings.get(new ClassKey(paramBeanDescription.getBeanClass())); if (localValueInstantiator == null) return paramValueInstantiator; return localValueInstantiator; }
public <T> void addDeserializer(Class<T> paramClass, JsonDeserializer<? extends T> paramJsonDeserializer) { ClassKey localClassKey = new ClassKey(paramClass); if (this._classMappings == null) this._classMappings = new HashMap(); this._classMappings.put(localClassKey, paramJsonDeserializer); }
public <T> SimpleAbstractTypeResolver addMapping(Class<T> paramClass, Class<? extends T> paramClass1) { if (paramClass == paramClass1) throw new IllegalArgumentException("Can not add mapping from class to itself"); if (!paramClass.isAssignableFrom(paramClass1)) throw new IllegalArgumentException("Can not add mapping from class " + paramClass.getName() + " to " + paramClass1.getName() + ", as latter is not a subtype of former"); if (!Modifier.isAbstract(paramClass.getModifiers())) throw new IllegalArgumentException("Can not add mapping from class " + paramClass.getName() + " since it is not abstract"); this._mappings.put(new ClassKey(paramClass), paramClass1); return this; }
public JavaType findTypeMapping(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType) { Class localClass1 = paramJavaType.getRawClass(); Class localClass2 = (Class)this._mappings.get(new ClassKey(localClass1)); if (localClass2 == null) return null; return paramJavaType.narrowBy(localClass2); }
protected SerializationConfig(SerializationConfig paramSerializationConfig, Map<ClassKey, Class<?>> paramMap) { super(paramSerializationConfig, paramMap); this._serFeatures = paramSerializationConfig._serFeatures; this._serializationInclusion = paramSerializationConfig._serializationInclusion; this._filterProvider = paramSerializationConfig._filterProvider; }
protected DeserializationConfig(DeserializationConfig paramDeserializationConfig, Map<ClassKey, Class<?>> paramMap) { super(paramDeserializationConfig, paramMap); this._deserFeatures = paramDeserializationConfig._deserFeatures; this._problemHandlers = paramDeserializationConfig._problemHandlers; this._nodeFactory = paramDeserializationConfig._nodeFactory; }
public DeserializationConfig(BaseSettings paramBaseSettings, SubtypeResolver paramSubtypeResolver, Map<ClassKey, Class<?>> paramMap) { super(paramBaseSettings, paramSubtypeResolver, paramMap); this._deserFeatures = collectFeatureDefaults(DeserializationFeature.class); this._nodeFactory = JsonNodeFactory.instance; this._problemHandlers = null; }
public SerializedString findRootName(Class<?> paramClass, MapperConfig<?> paramMapperConfig) { try { ClassKey localClassKey = new ClassKey(paramClass); if (this._rootNames == null) { this._rootNames = new LRUMap(20, 200); } else { SerializedString localSerializedString1 = (SerializedString)this._rootNames.get(localClassKey); if (localSerializedString1 != null) return localSerializedString1; } BeanDescription localBeanDescription = paramMapperConfig.introspectClassAnnotations(paramClass); PropertyName localPropertyName = paramMapperConfig.getAnnotationIntrospector().findRootName(localBeanDescription.getClassInfo()); String str; if ((localPropertyName == null) || (!localPropertyName.hasSimpleName())) str = paramClass.getSimpleName(); else str = localPropertyName.getSimpleName(); SerializedString localSerializedString2 = new SerializedString(str); this._rootNames.put(localClassKey, localSerializedString2); return localSerializedString2; } finally { } }
/** * Constructor used when creating a new instance (compared to * that of creating fluent copies) */ protected MapperConfigBase(BaseSettings base, SubtypeResolver str, Map<ClassKey,Class<?>> mixins) { super(base, DEFAULT_MAPPER_FEATURES); _mixInAnnotations = mixins; _subtypeResolver = str; _rootName = null; _view = null; }
/** * @since 2.1 */ protected MapperConfigBase(MapperConfigBase<CFG,T> src, Map<ClassKey,Class<?>> mixins) { super(src); _mixInAnnotations = mixins; _subtypeResolver = src._subtypeResolver; _rootName = src._rootName; _view = src._view; }
protected JsonSerializer<?> _findInterfaceMapping(Class<?> cls, ClassKey key) { for (Class<?> iface : cls.getInterfaces()) { key.reset(iface); JsonSerializer<?> ser = _interfaceMappings.get(key); if (ser != null) { return ser; } ser = _findInterfaceMapping(iface, key); if (ser != null) { return ser; } } return null; }
public SimpleKeyDeserializers addDeserializer(Class<?> forClass, KeyDeserializer deser) { if (_classMappings == null) { _classMappings = new HashMap<ClassKey,KeyDeserializer>(); } _classMappings.put(new ClassKey(forClass), deser); return this; }
public KeyDeserializer findKeyDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc) { if (_classMappings == null) { return null; } return _classMappings.get(new ClassKey(type.getRawClass())); }
@Override public ValueInstantiator findValueInstantiator(DeserializationConfig config, BeanDescription beanDesc, ValueInstantiator defaultInstantiator) { ValueInstantiator inst = _classMappings.get(new ClassKey(beanDesc.getBeanClass())); return (inst == null) ? defaultInstantiator : inst; }
@Override public JavaType findTypeMapping(DeserializationConfig config, JavaType type) { // this is the main mapping base, so let's Class<?> src = type.getRawClass(); Class<?> dst = _mappings.get(new ClassKey(src)); if (dst == null) { return null; } return type.narrowBy(dst); }
/** * Constructor used by ObjectMapper to create default configuration object instance. */ public SerializationConfig(BaseSettings base, SubtypeResolver str, Map<ClassKey,Class<?>> mixins) { super(base, str, mixins); _serFeatures = collectFeatureDefaults(SerializationFeature.class); _filterProvider = null; }
/** * @since 2.1 */ protected SerializationConfig(SerializationConfig src, Map<ClassKey,Class<?>> mixins) { super(src, mixins); _serFeatures = src._serFeatures; _serializationInclusion = src._serializationInclusion; _filterProvider = src._filterProvider; }
/** * Method called by {@link BeanDeserializerFactory} to see if there might be a standard * deserializer registered for given type. */ @SuppressWarnings("unchecked") protected JsonDeserializer<Object> findStdDeserializer(DeserializationConfig config, JavaType type) throws JsonMappingException { Class<?> cls = type.getRawClass(); // note: we do NOT check for custom deserializers here; that's for sub-class to do JsonDeserializer<Object> deser = _simpleDeserializers.get(new ClassKey(cls)); if (deser != null) { return deser; } // [JACKSON-283]: AtomicReference is a rather special type... if (AtomicReference.class.isAssignableFrom(cls)) { // Must find parameterization TypeFactory tf = config.getTypeFactory(); JavaType[] params = tf.findTypeParameters(type, AtomicReference.class); JavaType referencedType; if (params == null || params.length < 1) { // untyped (raw) referencedType = TypeFactory.unknownType(); } else { referencedType = params[0]; } JsonDeserializer<?> d2 = new JdkDeserializers.AtomicReferenceDeserializer(referencedType); return (JsonDeserializer<Object>)d2; } // [JACKSON-386]: External/optional type handlers are handled somewhat differently JsonDeserializer<?> d = optionalHandlers.findDeserializer(type, config); if (d != null) { return (JsonDeserializer<Object>)d; } return null; }
/** * Helper method called to (try to) locate deserializer for given sub-type of * type that this deserializer handles. */ protected JsonDeserializer<Object> _findSubclassDeserializer(DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens) throws IOException, JsonProcessingException { JsonDeserializer<Object> subDeser; // First: maybe we have already created sub-type deserializer? synchronized (this) { subDeser = (_subDeserializers == null) ? null : _subDeserializers.get(new ClassKey(bean.getClass())); } if (subDeser != null) { return subDeser; } // If not, maybe we can locate one. First, need provider JavaType type = ctxt.constructType(bean.getClass()); /* 30-Jan-2012, tatu: Ideally we would be passing referring * property; which in theory we could keep track of via * ResolvableDeserializer (if we absolutely must...). * But for now, let's not bother. */ // subDeser = ctxt.findValueDeserializer(type, _property); subDeser = ctxt.findRootValueDeserializer(type); // Also, need to cache it if (subDeser != null) { synchronized (this) { if (_subDeserializers == null) { _subDeserializers = new HashMap<ClassKey,JsonDeserializer<Object>>();; } _subDeserializers.put(new ClassKey(bean.getClass()), subDeser); } } return subDeser; }
/** * Constructor used by ObjectMapper to create default configuration object instance. */ public DeserializationConfig(BaseSettings base, SubtypeResolver str, Map<ClassKey,Class<?>> mixins) { super(base, str, mixins); _deserFeatures = collectFeatureDefaults(DeserializationFeature.class); _nodeFactory = JsonNodeFactory.instance; _problemHandlers = null; }
/** * @since 2.1 */ protected DeserializationConfig(DeserializationConfig src, Map<ClassKey,Class<?>> mixins) { super(src, mixins); _deserFeatures = src._deserFeatures; _problemHandlers = src._problemHandlers; _nodeFactory = src._nodeFactory; }
public final Class<?> findMixInClassFor(Class<?> paramClass) { if (this._mixInAnnotations == null) return null; return (Class)this._mixInAnnotations.get(new ClassKey(paramClass)); }
public JsonSerializer<?> findSerializer(SerializationConfig paramSerializationConfig, JavaType paramJavaType, BeanDescription paramBeanDescription) { Object localObject1 = paramJavaType.getRawClass(); ClassKey localClassKey = new ClassKey((Class)localObject1); if (((Class)localObject1).isInterface()) { if (this._interfaceMappings != null) { JsonSerializer localJsonSerializer5 = (JsonSerializer)this._interfaceMappings.get(localClassKey); if (localJsonSerializer5 != null) return localJsonSerializer5; } } else if (this._classMappings != null) { JsonSerializer localJsonSerializer3 = (JsonSerializer)this._classMappings.get(localClassKey); if (localJsonSerializer3 != null) return localJsonSerializer3; for (Object localObject2 = localObject1; localObject2 != null; localObject2 = ((Class)localObject2).getSuperclass()) { localClassKey.reset((Class)localObject2); JsonSerializer localJsonSerializer4 = (JsonSerializer)this._classMappings.get(localClassKey); if (localJsonSerializer4 != null) return localJsonSerializer4; } } if (this._interfaceMappings != null) { JsonSerializer localJsonSerializer1 = _findInterfaceMapping((Class)localObject1, localClassKey); if (localJsonSerializer1 != null) return localJsonSerializer1; if (!((Class)localObject1).isInterface()) { JsonSerializer localJsonSerializer2; do { Class localClass = ((Class)localObject1).getSuperclass(); localObject1 = localClass; if (localClass == null) break; localJsonSerializer2 = _findInterfaceMapping((Class)localObject1, localClassKey); } while (localJsonSerializer2 == null); return localJsonSerializer2; } } return null; }
public KeyDeserializer findKeyDeserializer(JavaType paramJavaType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription) { if (this._classMappings == null) return null; return (KeyDeserializer)this._classMappings.get(new ClassKey(paramJavaType.getRawClass())); }
public SimpleValueInstantiators addValueInstantiator(Class<?> paramClass, ValueInstantiator paramValueInstantiator) { this._classMappings.put(new ClassKey(paramClass), paramValueInstantiator); return this; }
public JsonDeserializer<?> findArrayDeserializer(ArrayType paramArrayType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer) { if (this._classMappings == null) return null; return (JsonDeserializer)this._classMappings.get(new ClassKey(paramArrayType.getRawClass())); }
public JsonDeserializer<?> findBeanDeserializer(JavaType paramJavaType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription) { if (this._classMappings == null) return null; return (JsonDeserializer)this._classMappings.get(new ClassKey(paramJavaType.getRawClass())); }
public JsonDeserializer<?> findCollectionDeserializer(CollectionType paramCollectionType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer) { if (this._classMappings == null) return null; return (JsonDeserializer)this._classMappings.get(new ClassKey(paramCollectionType.getRawClass())); }
public JsonDeserializer<?> findCollectionLikeDeserializer(CollectionLikeType paramCollectionLikeType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer) { if (this._classMappings == null) return null; return (JsonDeserializer)this._classMappings.get(new ClassKey(paramCollectionLikeType.getRawClass())); }
public JsonDeserializer<?> findEnumDeserializer(Class<?> paramClass, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription) { if (this._classMappings == null) return null; return (JsonDeserializer)this._classMappings.get(new ClassKey(paramClass)); }
public JsonDeserializer<?> findMapDeserializer(MapType paramMapType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer) { if (this._classMappings == null) return null; return (JsonDeserializer)this._classMappings.get(new ClassKey(paramMapType.getRawClass())); }
public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType paramMapLikeType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer) { if (this._classMappings == null) return null; return (JsonDeserializer)this._classMappings.get(new ClassKey(paramMapLikeType.getRawClass())); }