public ObjBase makeValue(ObjectId id, DBObject rawData, Class<? extends ObjBase> c){ if (Modifier.isAbstract(c.getModifiers()) || Modifier.isInterface(c.getModifiers())) { //extract declared schema from result, use that class Object schemaId = rawData.get(ReservedFieldNames.SCHEMA); try { c = (Class<ObjBase>) ClassUtil.findClass(schemaId.toString()); } catch (ClassNotFoundException ex) { log.warn("Could not find fallback schema {}", schemaId); return null; } } ObjBase value = makeStub(id, c, rawData); // update stub with the rest of the data, if (value != null && !(value instanceof Swappable)) try { unmarshaller.unmarshall(Bson.createDocument(rawData), value, this); } catch (MarshallingException me){ log.warn(me.getMessage(), me); } return value; }
@Override public JavaType typeFromId(String id) { try{ return super.typeFromId(id); } catch (IllegalArgumentException iae){ try { //try the widening type construction instead Class<?> cls = ClassUtil.findClass(id); if (cls.isAssignableFrom(_baseType.getRawClass()) || _baseType.getRawClass().equals(JSONFilter.class)) return _baseType; //TODO: make this message not suck else throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): "); } catch (ClassNotFoundException cnfe){ throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): no such class found"); } catch (Exception e){ //could neither narrow or widen that type combination throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): "+e.getMessage(), e); } } }
protected BeanPropertyWriter _constructWriter(SerializerProvider paramSerializerProvider, BeanPropertyDefinition paramBeanPropertyDefinition, TypeBindings paramTypeBindings, PropertyBuilder paramPropertyBuilder, boolean paramBoolean, AnnotatedMember paramAnnotatedMember) { String str = paramBeanPropertyDefinition.getName(); if (paramSerializerProvider.canOverrideAccessModifiers()) paramAnnotatedMember.fixAccess(); JavaType localJavaType = paramAnnotatedMember.getType(paramTypeBindings); BeanProperty.Std localStd = new BeanProperty.Std(str, localJavaType, paramBeanPropertyDefinition.getWrapperName(), paramPropertyBuilder.getClassAnnotations(), paramAnnotatedMember, paramBeanPropertyDefinition.isRequired()); JsonSerializer localJsonSerializer1 = findSerializerFromAnnotation(paramSerializerProvider, paramAnnotatedMember); JsonSerializer localJsonSerializer2 = localJsonSerializer1; if ((localJsonSerializer1 instanceof ResolvableSerializer)) ((ResolvableSerializer)localJsonSerializer2).resolve(paramSerializerProvider); if ((localJsonSerializer2 instanceof ContextualSerializer)) localJsonSerializer2 = ((ContextualSerializer)localJsonSerializer2).createContextual(paramSerializerProvider, localStd); boolean bool = ClassUtil.isCollectionMapOrArray(localJavaType.getRawClass()); TypeSerializer localTypeSerializer1 = null; if (bool) localTypeSerializer1 = findPropertyContentTypeSerializer(localJavaType, paramSerializerProvider.getConfig(), paramAnnotatedMember); TypeSerializer localTypeSerializer2 = findPropertyTypeSerializer(localJavaType, paramSerializerProvider.getConfig(), paramAnnotatedMember); return paramPropertyBuilder.buildWriter(paramBeanPropertyDefinition, localJavaType, localJsonSerializer2, localTypeSerializer2, localTypeSerializer1, paramAnnotatedMember, paramBoolean); }
private PropertyNamingStrategy _findNamingStrategy() { Object localObject1; if (this._annotationIntrospector == null) localObject1 = null; else localObject1 = this._annotationIntrospector.findNamingStrategy(this._classDef); Object localObject2 = localObject1; if (localObject1 == null) return this._config.getPropertyNamingStrategy(); if ((localObject2 instanceof PropertyNamingStrategy)) return (PropertyNamingStrategy)localObject2; if (!(localObject2 instanceof Class)) throw new IllegalStateException("AnnotationIntrospector returned PropertyNamingStrategy definition of type " + localObject2.getClass().getName() + "; expected type PropertyNamingStrategy or Class<PropertyNamingStrategy> instead"); Class localClass = (Class)localObject2; if (!PropertyNamingStrategy.class.isAssignableFrom(localClass)) throw new IllegalStateException("AnnotationIntrospector returned Class " + localClass.getName() + "; expected Class<PropertyNamingStrategy>"); HandlerInstantiator localHandlerInstantiator = this._config.getHandlerInstantiator(); if (localHandlerInstantiator != null) { PropertyNamingStrategy localPropertyNamingStrategy = localHandlerInstantiator.namingStrategyInstance(this._config, this._classDef, localClass); if (localPropertyNamingStrategy != null) return localPropertyNamingStrategy; } return (PropertyNamingStrategy)ClassUtil.createInstance(localClass, this._config.canOverrideAccessModifiers()); }
protected final void _addMethodMixIns(Class<?> paramClass1, AnnotatedMethodMap paramAnnotatedMethodMap1, Class<?> paramClass2, AnnotatedMethodMap paramAnnotatedMethodMap2) { ArrayList localArrayList = new ArrayList(); localArrayList.add(paramClass2); ClassUtil.findSuperTypes(paramClass2, paramClass1, localArrayList); Iterator localIterator = localArrayList.iterator(); while (localIterator.hasNext()) for (Method localMethod : ((Class)localIterator.next()).getDeclaredMethods()) if (_isIncludableMemberMethod(localMethod)) { AnnotatedMethod localAnnotatedMethod = paramAnnotatedMethodMap1.find(localMethod); if (localAnnotatedMethod != null) _addMixUnders(localMethod, localAnnotatedMethod); else paramAnnotatedMethodMap2.add(_constructMethod(localMethod)); } }
public ValueInstantiator _valueInstantiatorInstance(DeserializationConfig paramDeserializationConfig, Annotated paramAnnotated, Object paramObject) { if (paramObject == null) return null; if ((paramObject instanceof ValueInstantiator)) return (ValueInstantiator)paramObject; if (!(paramObject instanceof Class)) throw new IllegalStateException("AnnotationIntrospector returned key deserializer definition of type " + paramObject.getClass().getName() + "; expected type KeyDeserializer or Class<KeyDeserializer> instead"); Class localClass = (Class)paramObject; if (localClass == NoClass.class) return null; if (!ValueInstantiator.class.isAssignableFrom(localClass)) throw new IllegalStateException("AnnotationIntrospector returned Class " + localClass.getName() + "; expected Class<ValueInstantiator>"); HandlerInstantiator localHandlerInstantiator = paramDeserializationConfig.getHandlerInstantiator(); if (localHandlerInstantiator != null) { ValueInstantiator localValueInstantiator = localHandlerInstantiator.valueInstantiatorInstance(paramDeserializationConfig, paramAnnotated, localClass); if (localValueInstantiator != null) return localValueInstantiator; } return (ValueInstantiator)ClassUtil.createInstance(localClass, paramDeserializationConfig.canOverrideAccessModifiers()); }
public Class<?> deserialize(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext) { JsonToken localJsonToken = paramJsonParser.getCurrentToken(); if (localJsonToken == JsonToken.VALUE_STRING) { String str = paramJsonParser.getText().trim(); try { Class localClass = paramDeserializationContext.findClass(str); return localClass; } catch (Exception localException) { throw paramDeserializationContext.instantiationException(this._valueClass, ClassUtil.getRootCause(localException)); } } throw paramDeserializationContext.mappingException(this._valueClass, localJsonToken); }
public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig paramDeserializationConfig, Class<?> paramClass, AnnotatedMethod paramAnnotatedMethod) { Class localClass = paramAnnotatedMethod.getRawParameterType(0); Object localObject; if (localClass == String.class) localObject = null; else if ((localClass == Integer.TYPE) || (localClass == Integer.class)) localObject = Integer.class; else if ((localClass == Long.TYPE) || (localClass == Long.class)) localObject = Long.class; else throw new IllegalArgumentException("Parameter #0 type for factory method (" + paramAnnotatedMethod + ") not suitable, must be java.lang.String or int/Integer/long/Long"); if (paramDeserializationConfig.canOverrideAccessModifiers()) ClassUtil.checkAndFixAccess(paramAnnotatedMethod.getMember()); return new FactoryBasedDeserializer(paramClass, paramAnnotatedMethod, (Class)localObject); }
public Object deserialize(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext) { Object localObject1; if (this._inputType == null) localObject1 = paramJsonParser.getText(); else if (this._inputType == Integer.class) localObject1 = Integer.valueOf(paramJsonParser.getValueAsInt()); else if (this._inputType == Long.class) localObject1 = Long.valueOf(paramJsonParser.getValueAsLong()); else throw paramDeserializationContext.mappingException(this._enumClass); try { Object localObject2 = this._factory.invoke(this._enumClass, new Object[] { localObject1 }); return localObject2; } catch (Exception localException) { ClassUtil.unwrapAndThrowAsIAE(localException); } return null; }
public static KeyDeserializer findStringBasedKeyDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType) { BeanDescription localBeanDescription = paramDeserializationConfig.introspect(paramJavaType); Constructor localConstructor = localBeanDescription.findSingleArgConstructor(new Class[] { String.class }); if (localConstructor != null) { if (paramDeserializationConfig.canOverrideAccessModifiers()) ClassUtil.checkAndFixAccess(localConstructor); return new StdKeyDeserializer.StringCtorKeyDeserializer(localConstructor); } Method localMethod = localBeanDescription.findFactoryMethod(new Class[] { String.class }); if (localMethod != null) { if (paramDeserializationConfig.canOverrideAccessModifiers()) ClassUtil.checkAndFixAccess(localMethod); return new StdKeyDeserializer.StringFactoryKeyDeserializer(localMethod); } return null; }
public final Object _parse(String paramString, DeserializationContext paramDeserializationContext) { if (this._factory != null) try { Object localObject = this._factory.call1(paramString); return localObject; } catch (Exception localException) { ClassUtil.unwrapAndThrowAsIAE(localException); } Enum localEnum = this._resolver.findEnum(paramString); if ((localEnum == null) && (!paramDeserializationContext.getConfig().isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL))) throw paramDeserializationContext.weirdKeyException(this._keyClass, paramString, "not one of values for Enum class"); return localEnum; }
protected SettableBeanProperty _resolveInnerClassValuedProperty(DeserializationContext paramDeserializationContext, SettableBeanProperty paramSettableBeanProperty) { JsonDeserializer localJsonDeserializer = paramSettableBeanProperty.getValueDeserializer(); if (((localJsonDeserializer instanceof BeanDeserializerBase)) && (!((BeanDeserializerBase)localJsonDeserializer).getValueInstantiator().canCreateUsingDefault())) { Class localClass1 = paramSettableBeanProperty.getType().getRawClass(); Class localClass2 = ClassUtil.getOuterClass(localClass1); if ((localClass2 != null) && (localClass2 == this._beanType.getRawClass())) for (Constructor localConstructor : localClass1.getConstructors()) { Class[] arrayOfClass = localConstructor.getParameterTypes(); if ((arrayOfClass.length == 1) && (arrayOfClass[0] == localClass2)) { if (paramDeserializationContext.getConfig().canOverrideAccessModifiers()) ClassUtil.checkAndFixAccess(localConstructor); return new InnerClassProperty(paramSettableBeanProperty, localConstructor); } } } return paramSettableBeanProperty; }
@Override public JavaType typeFromId(String id) { /* 30-Jan-2010, tatu: Most ids are basic class names; so let's first * check if any generics info is added; and only then ask factory * to do translation when necessary */ if (id.indexOf('<') > 0) { JavaType t = typeFactory.constructFromCanonical(id); // note: may want to try combining with specialization (esp for EnumMap)? return t; } try { Class<?> cls = ClassUtil.findClass(id); return typeFactory.constructSpecializedType(baseType, cls); } catch (ClassNotFoundException ignored) { throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): no such class found"); } catch (Exception e) { throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): "+e.getMessage(), e); } }
@Override public ObjectIdGenerator<?> objectIdGeneratorInstance(Annotated annotated, ObjectIdInfo objectIdInfo) throws JsonMappingException { Class<?> implClass = objectIdInfo.getGeneratorType(); HandlerInstantiator hi = _config.getHandlerInstantiator(); ObjectIdGenerator<?> gen; if (hi != null) { gen = hi.objectIdGeneratorInstance(_config, annotated, implClass); } else { gen = (ObjectIdGenerator<?>) ClassUtil.createInstance(implClass, _config.canOverrideAccessModifiers()); } return gen.forScope(objectIdInfo.getScope()); }
/** * Method called to see if one of primary per-class annotations * (or related, like implementing of {@link JsonSerializable}) * determines the serializer to use. *<p> * Currently handles things like: *<ul> * <li>If type implements {@link JsonSerializable}, use that * </li> * <li>If type has {@link com.fasterxml.jackson.annotation.JsonValue} annotation (or equivalent), build serializer * based on that property * </li> *</ul> * * @since 2.0 */ protected final JsonSerializer<?> findSerializerByAnnotations(SerializerProvider prov, JavaType type, BeanDescription beanDesc) throws JsonMappingException { Class<?> raw = type.getRawClass(); // First: JsonSerializable? if (JsonSerializable.class.isAssignableFrom(raw)) { return SerializableSerializer.instance; } // Second: @JsonValue for any type AnnotatedMethod valueMethod = beanDesc.findJsonValueMethod(); if (valueMethod != null) { Method m = valueMethod.getAnnotated(); if (prov.canOverrideAccessModifiers()) { ClassUtil.checkAndFixAccess(m); } JsonSerializer<Object> ser = findSerializerFromAnnotation(prov, valueMethod); return new JsonValueSerializer(m, ser); } // No well-known annotations... return null; }
protected void _addClassMixIns(AnnotationMap annotations, Class<?> toMask, Class<?> mixin) { if (mixin == null) { return; } // Ok, first: annotations from mix-in class itself: _addAnnotationsIfNotPresent(annotations, mixin.getDeclaredAnnotations()); /* And then from its supertypes, if any. But note that we will * only consider super-types up until reaching the masked * class (if found); this because often mix-in class * is a sub-class (for convenience reasons). And if so, we * absolutely must NOT include super types of masked class, * as that would inverse precedence of annotations. */ for (Class<?> parent : ClassUtil.findSuperTypes(mixin, toMask)) { _addAnnotationsIfNotPresent(annotations, parent.getDeclaredAnnotations()); } }
/** * Method called to add field mix-ins from given mix-in class (and its fields) * into already collected actual fields (from introspected classes and their * super-classes) */ protected void _addFieldMixIns(Class<?> targetClass, Class<?> mixInCls, Map<String,AnnotatedField> fields) { List<Class<?>> parents = new ArrayList<Class<?>>(); parents.add(mixInCls); ClassUtil.findSuperTypes(mixInCls, targetClass, parents); for (Class<?> mixin : parents) { for (Field mixinField : mixin.getDeclaredFields()) { // there are some dummy things (static, synthetic); better ignore if (!_isIncludableField(mixinField)) { continue; } String name = mixinField.getName(); // anything to mask? (if not, quietly ignore) AnnotatedField maskedField = fields.get(name); if (maskedField != null) { _addOrOverrideAnnotations(maskedField, mixinField.getDeclaredAnnotations()); } } } }
protected EnumResolver<?> constructEnumResolver(Class<?> enumClass, DeserializationConfig config, AnnotatedMethod jsonValueMethod) { if (jsonValueMethod != null) { Method accessor = jsonValueMethod.getAnnotated(); if (config.canOverrideAccessModifiers()) { ClassUtil.checkAndFixAccess(accessor); } return EnumResolver.constructUnsafeUsingMethod(enumClass, accessor); } // [JACKSON-212]: may need to use Enum.toString() if (config.isEnabled(DeserializationFeature.READ_ENUMS_USING_TO_STRING)) { return EnumResolver.constructUnsafeUsingToString(enumClass); } return EnumResolver.constructUnsafe(enumClass, config.getAnnotationIntrospector()); }
@Override public Class<?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { JsonToken curr = jp.getCurrentToken(); // Currently will only accept if given simple class name if (curr == JsonToken.VALUE_STRING) { String className = jp.getText().trim(); try { return ctxt.findClass(className); } catch (Exception e) { throw ctxt.instantiationException(_valueClass, ClassUtil.getRootCause(e)); } } throw ctxt.mappingException(_valueClass, curr); }
/** * Factory method used when Enum instances are to be deserialized * using a creator (static factory method) * * @return Deserializer based on given factory method, if type was suitable; * null if type can not be used */ public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig config, Class<?> enumClass, AnnotatedMethod factory) { // note: caller has verified there's just one arg; but we must verify its type Class<?> paramClass = factory.getRawParameterType(0); if (paramClass == String.class) { paramClass = null; } else if (paramClass == Integer.TYPE || paramClass == Integer.class) { paramClass = Integer.class; } else if (paramClass == Long.TYPE || paramClass == Long.class) { paramClass = Long.class; } else { throw new IllegalArgumentException("Parameter #0 type for factory method ("+factory +") not suitable, must be java.lang.String or int/Integer/long/Long"); } if (config.canOverrideAccessModifiers()) { ClassUtil.checkAndFixAccess(factory.getMember()); } return new FactoryBasedDeserializer(enumClass, factory, paramClass); }
@Override public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { // couple of accepted types... Object value; if (_inputType == null) { value = jp.getText(); } else if (_inputType == Integer.class) { value = Integer.valueOf(jp.getValueAsInt()); } else if (_inputType == Long.class) { value = Long.valueOf(jp.getValueAsLong()); } else { throw ctxt.mappingException(_enumClass); } try { return _factory.invoke(_enumClass, value); } catch (Exception e) { ClassUtil.unwrapAndThrowAsIAE(e); } return null; }
@Override public void deserializeAndSet(JsonParser jp, DeserializationContext ctxt, Object bean) throws IOException, JsonProcessingException { JsonToken t = jp.getCurrentToken(); Object value; if (t == JsonToken.VALUE_NULL) { value = (_nullProvider == null) ? null : _nullProvider.nullValue(ctxt); } else if (_valueTypeDeserializer != null) { value = _valueDeserializer.deserializeWithType(jp, ctxt, _valueTypeDeserializer); } else { // the usual case try { value = _creator.newInstance(bean); } catch (Exception e) { ClassUtil.unwrapAndThrowAsIAE(e, "Failed to instantiate class "+_creator.getDeclaringClass().getName()+", problem: "+e.getMessage()); value = null; } _valueDeserializer.deserialize(jp, ctxt, value); } set(bean, value); }
/** * Helper method used to skip processing for types that we know * can not be (i.e. are never consider to be) beans: * things like primitives, Arrays, Enums, and proxy types. *<p> * Note that usually we shouldn't really be getting these sort of * types anyway; but better safe than sorry. */ protected boolean isPotentialBeanType(Class<?> type) { String typeStr = ClassUtil.canBeABeanType(type); if (typeStr != null) { throw new IllegalArgumentException("Can not deserialize Class "+type.getName()+" (of type "+typeStr+") as a Bean"); } if (ClassUtil.isProxyType(type)) { throw new IllegalArgumentException("Can not deserialize Proxy class "+type.getName()+" as a Bean"); } /* also: can't deserialize some local classes: static are ok; in-method not; * and with [JACKSON-594], other non-static inner classes are ok */ typeStr = ClassUtil.isLocalType(type, true); if (typeStr != null) { throw new IllegalArgumentException("Can not deserialize Class "+type.getName()+" (of type "+typeStr+") as a Bean"); } return true; }
protected void _reportIncompatibleRootType(Object value, JavaType rootType) throws IOException, JsonProcessingException { /* 07-Jan-2010, tatu: As per [JACKSON-456] better handle distinction between wrapper types, * primitives */ if (rootType.isPrimitive()) { Class<?> wrapperType = ClassUtil.wrapperType(rootType.getRawClass()); // If it's just difference between wrapper, primitive, let it slide if (wrapperType.isAssignableFrom(value.getClass())) { return; } } throw new JsonMappingException("Incompatible types: declared root type ("+rootType+") vs " +value.getClass().getName()); }
@Override protected Class<?> _deserialize(final String value, final DeserializationContext ctxt) throws IOException { try { return ctxt.findClass(SimpleClassNameIdResolver.getClassName(value)); } catch (final Exception e) { throw ctxt.instantiationException(_valueClass, ClassUtil.getRootCause(e)); } }
@SuppressWarnings("unchecked") private Optional<ClassMappingInternal<Object>> getClassMappingFromSuperTypes(Class<?> type, ClassesMapping serOrDeserClassesMapping, ClassesMapping mergedClassesMapping) { List<Class<?>> superTypes = ClassUtil.findSuperTypes(type, Object.class); Collections.reverse(superTypes); return Stream.concat(Stream.of(Object.class), superTypes.stream()) .map(superType -> (Class<Object>) superType) .map(superType -> Optional.ofNullable( mergedClassesMapping.getOpt(superType) .orElseGet(() -> mergeAndPutInMergedClassesMapping(mergedClassesMapping, superType, serOrDeserClassesMapping.getOpt(superType), classesMappingByOperation.get(ANY).getOpt(superType)))) ) .reduce(Optional.empty(), Mergeable::merge); }
public TypeIdResolver typeIdResolverInstance(Annotated paramAnnotated, Class<? extends TypeIdResolver> paramClass) { HandlerInstantiator localHandlerInstantiator = getHandlerInstantiator(); if (localHandlerInstantiator != null) { TypeIdResolver localTypeIdResolver = localHandlerInstantiator.typeIdResolverInstance(this, paramAnnotated, paramClass); if (localTypeIdResolver != null) return localTypeIdResolver; } return (TypeIdResolver)ClassUtil.createInstance(paramClass, canOverrideAccessModifiers()); }
public TypeResolverBuilder<?> typeResolverBuilderInstance(Annotated paramAnnotated, Class<? extends TypeResolverBuilder<?>> paramClass) { HandlerInstantiator localHandlerInstantiator = getHandlerInstantiator(); if (localHandlerInstantiator != null) { TypeResolverBuilder localTypeResolverBuilder = localHandlerInstantiator.typeResolverBuilderInstance(this, paramAnnotated, paramClass); if (localTypeResolverBuilder != null) return localTypeResolverBuilder; } return (TypeResolverBuilder)ClassUtil.createInstance(paramClass, canOverrideAccessModifiers()); }
protected final String _idFrom(Object paramObject, Class<?> paramClass) { if ((Enum.class.isAssignableFrom(paramClass)) && (!paramClass.isEnum())) paramClass = paramClass.getSuperclass(); String str1 = paramClass.getName(); String str2 = str1; if (str1.startsWith("java.util")) { if ((paramObject instanceof EnumSet)) { Class localClass2 = ClassUtil.findEnumType((EnumSet)paramObject); return TypeFactory.defaultInstance().constructCollectionType(EnumSet.class, localClass2).toCanonical(); } if ((paramObject instanceof EnumMap)) { Class localClass1 = ClassUtil.findEnumType((EnumMap)paramObject); return TypeFactory.defaultInstance().constructMapType(EnumMap.class, localClass1, Object.class).toCanonical(); } String str3 = str2.substring(9); if (((str3.startsWith(".Arrays$")) || (str3.startsWith(".Collections$"))) && (str2.indexOf("List") >= 0)) str2 = "java.util.ArrayList"; return str2; } if ((str2.indexOf('$') >= 0) && (ClassUtil.getOuterClass(paramClass) != null) && (ClassUtil.getOuterClass(this._baseType.getRawClass()) == null)) str2 = this._baseType.getRawClass().getName(); return str2; }
public JsonSerializer<Object> serializerInstance(Annotated paramAnnotated, Object paramObject) { if (paramObject == null) return null; Object localObject; if ((paramObject instanceof JsonSerializer)) { localObject = (JsonSerializer)paramObject; } else { if (!(paramObject instanceof Class)) throw new IllegalStateException("AnnotationIntrospector returned serializer definition of type " + paramObject.getClass().getName() + "; expected type JsonSerializer or Class<JsonSerializer> instead"); Class localClass = (Class)paramObject; if ((localClass == JsonSerializer.None.class) || (localClass == NoClass.class)) return null; if (!JsonSerializer.class.isAssignableFrom(localClass)) throw new IllegalStateException("AnnotationIntrospector returned Class " + localClass.getName() + "; expected Class<JsonSerializer>"); HandlerInstantiator localHandlerInstantiator = this._config.getHandlerInstantiator(); JsonSerializer localJsonSerializer; if (localHandlerInstantiator == null) localJsonSerializer = null; else localJsonSerializer = localHandlerInstantiator.serializerInstance(this._config, paramAnnotated, localClass); localObject = localJsonSerializer; if (localJsonSerializer == null) localObject = (JsonSerializer)ClassUtil.createInstance(localClass, this._config.canOverrideAccessModifiers()); } return _handleResolvable((JsonSerializer)localObject); }
protected final JsonSerializer<?> findSerializerByAnnotations(SerializerProvider paramSerializerProvider, JavaType paramJavaType, BeanDescription paramBeanDescription) { if (JsonSerializable.class.isAssignableFrom(paramJavaType.getRawClass())) return SerializableSerializer.instance; AnnotatedMethod localAnnotatedMethod = paramBeanDescription.findJsonValueMethod(); if (localAnnotatedMethod != null) { Method localMethod = localAnnotatedMethod.getAnnotated(); if (paramSerializerProvider.canOverrideAccessModifiers()) ClassUtil.checkAndFixAccess(localMethod); return new JsonValueSerializer(localMethod, findSerializerFromAnnotation(paramSerializerProvider, localAnnotatedMethod)); } return null; }
protected final void _addClassMixIns(AnnotationMap paramAnnotationMap, Class<?> paramClass1, Class<?> paramClass2) { if (paramClass2 == null) return; _addAnnotationsIfNotPresent(paramAnnotationMap, paramClass2.getDeclaredAnnotations()); Iterator localIterator = ClassUtil.findSuperTypes(paramClass2, paramClass1).iterator(); while (localIterator.hasNext()) _addAnnotationsIfNotPresent(paramAnnotationMap, ((Class)localIterator.next()).getDeclaredAnnotations()); }
protected final void _addFieldMixIns(Class<?> paramClass1, Class<?> paramClass2, Map<String, AnnotatedField> paramMap) { ArrayList localArrayList = new ArrayList(); localArrayList.add(paramClass2); ClassUtil.findSuperTypes(paramClass2, paramClass1, localArrayList); Iterator localIterator = localArrayList.iterator(); while (localIterator.hasNext()) for (Field localField : ((Class)localIterator.next()).getDeclaredFields()) if (_isIncludableField(localField)) { AnnotatedField localAnnotatedField = (AnnotatedField)paramMap.get(localField.getName()); if (localAnnotatedField != null) _addOrOverrideAnnotations(localAnnotatedField, localField.getDeclaredAnnotations()); } }
private KeyDeserializer _createEnumKeyDeserializer(DeserializationContext paramDeserializationContext, JavaType paramJavaType) { DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig(); BeanDescription localBeanDescription = localDeserializationConfig.introspect(paramJavaType); JsonDeserializer localJsonDeserializer = findDeserializerFromAnnotation(paramDeserializationContext, localBeanDescription.getClassInfo()); if (localJsonDeserializer != null) return StdKeyDeserializers.constructDelegatingKeyDeserializer(localDeserializationConfig, paramJavaType, localJsonDeserializer); Class localClass = paramJavaType.getRawClass(); if (_findCustomEnumDeserializer(localClass, localDeserializationConfig, localBeanDescription) != null) return StdKeyDeserializers.constructDelegatingKeyDeserializer(localDeserializationConfig, paramJavaType, localJsonDeserializer); EnumResolver localEnumResolver = constructEnumResolver(localClass, localDeserializationConfig, localBeanDescription.findJsonValueMethod()); Iterator localIterator = localBeanDescription.getFactoryMethods().iterator(); while (localIterator.hasNext()) { AnnotatedMethod localAnnotatedMethod = (AnnotatedMethod)localIterator.next(); if (localDeserializationConfig.getAnnotationIntrospector().hasCreatorAnnotation(localAnnotatedMethod)) { if ((localAnnotatedMethod.getParameterCount() == 1) && (localAnnotatedMethod.getRawReturnType().isAssignableFrom(localClass))) { if (localAnnotatedMethod.getGenericParameterType(0) != String.class) throw new IllegalArgumentException("Parameter #0 type for factory method (" + localAnnotatedMethod + ") not suitable, must be java.lang.String"); if (localDeserializationConfig.canOverrideAccessModifiers()) ClassUtil.checkAndFixAccess(localAnnotatedMethod.getMember()); return StdKeyDeserializers.constructEnumKeyDeserializer(localEnumResolver, localAnnotatedMethod); } throw new IllegalArgumentException("Unsuitable method (" + localAnnotatedMethod + ") decorated with @JsonCreator (for Enum type " + localClass.getName() + ")"); } } return StdKeyDeserializers.constructEnumKeyDeserializer(localEnumResolver); }
protected EnumResolver<?> constructEnumResolver(Class<?> paramClass, DeserializationConfig paramDeserializationConfig, AnnotatedMethod paramAnnotatedMethod) { if (paramAnnotatedMethod != null) { Method localMethod = paramAnnotatedMethod.getAnnotated(); if (paramDeserializationConfig.canOverrideAccessModifiers()) ClassUtil.checkAndFixAccess(localMethod); return EnumResolver.constructUnsafeUsingMethod(paramClass, localMethod); } if (paramDeserializationConfig.isEnabled(DeserializationFeature.READ_ENUMS_USING_TO_STRING)) return EnumResolver.constructUnsafeUsingToString(paramClass); return EnumResolver.constructUnsafe(paramClass, paramDeserializationConfig.getAnnotationIntrospector()); }
public KeyDeserializer findKeyDeserializer(JavaType paramJavaType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription) { Class localClass1 = paramJavaType.getRawClass(); Class localClass2 = localClass1; if ((localClass1 == String.class) || (localClass2 == Object.class)) return StdKeyDeserializer.StringKD.forType(localClass2); if (localClass2 == UUID.class) return new StdKeyDeserializer.UuidKD(); if (localClass2.isPrimitive()) localClass2 = ClassUtil.wrapperType(localClass2); if (localClass2 == Integer.class) return new StdKeyDeserializer.IntKD(); if (localClass2 == Long.class) return new StdKeyDeserializer.LongKD(); if (localClass2 == Date.class) return new StdKeyDeserializer.DateKD(); if (localClass2 == Calendar.class) return new StdKeyDeserializer.CalendarKD(); if (localClass2 == Boolean.class) return new StdKeyDeserializer.BoolKD(); if (localClass2 == Byte.class) return new StdKeyDeserializer.ByteKD(); if (localClass2 == Character.class) return new StdKeyDeserializer.CharKD(); if (localClass2 == Short.class) return new StdKeyDeserializer.ShortKD(); if (localClass2 == Float.class) return new StdKeyDeserializer.FloatKD(); if (localClass2 == Double.class) return new StdKeyDeserializer.DoubleKD(); if (localClass2 == Locale.class) return new StdKeyDeserializer.LocaleKD(); return null; }
public final void deserializeAndSet(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext, Object paramObject) { Object localObject; if (paramJsonParser.getCurrentToken() == JsonToken.VALUE_NULL) { if (this._nullProvider == null) localObject = null; else localObject = this._nullProvider.nullValue(paramDeserializationContext); } else if (this._valueTypeDeserializer != null) { localObject = this._valueDeserializer.deserializeWithType(paramJsonParser, paramDeserializationContext, this._valueTypeDeserializer); } else { try { localObject = this._creator.newInstance(new Object[] { paramObject }); } catch (Exception localException) { ClassUtil.unwrapAndThrowAsIAE(localException, "Failed to instantiate class " + this._creator.getDeclaringClass().getName() + ", problem: " + localException.getMessage()); localObject = null; } this._valueDeserializer.deserialize(paramJsonParser, paramDeserializationContext, localObject); } set(paramObject, localObject); }
public static PropertyBasedCreator construct(DeserializationContext paramDeserializationContext, ValueInstantiator paramValueInstantiator, SettableBeanProperty[] paramArrayOfSettableBeanProperty) { int i = paramArrayOfSettableBeanProperty.length; SettableBeanProperty[] arrayOfSettableBeanProperty = new SettableBeanProperty[i]; Object[] arrayOfObject = null; for (int j = 0; j < i; j++) { SettableBeanProperty localSettableBeanProperty1 = paramArrayOfSettableBeanProperty[j]; SettableBeanProperty localSettableBeanProperty2 = localSettableBeanProperty1; if (!localSettableBeanProperty1.hasValueDeserializer()) localSettableBeanProperty2 = localSettableBeanProperty2.withValueDeserializer(paramDeserializationContext.findContextualValueDeserializer(localSettableBeanProperty2.getType(), localSettableBeanProperty2)); arrayOfSettableBeanProperty[j] = localSettableBeanProperty2; JsonDeserializer localJsonDeserializer = localSettableBeanProperty2.getValueDeserializer(); Object localObject1; if (localJsonDeserializer == null) localObject1 = null; else localObject1 = localJsonDeserializer.getNullValue(); Object localObject2 = localObject1; if ((localObject1 == null) && (localSettableBeanProperty2.getType().isPrimitive())) localObject2 = ClassUtil.defaultValue(localSettableBeanProperty2.getType().getRawClass()); if (localObject2 != null) { if (arrayOfObject == null) arrayOfObject = new Object[i]; arrayOfObject[j] = localObject2; } } return new PropertyBasedCreator(paramValueInstantiator, arrayOfSettableBeanProperty, arrayOfObject); }
protected JsonDeserializer<Object> buildBuilderBasedDeserializer(DeserializationContext paramDeserializationContext, JavaType paramJavaType, BeanDescription paramBeanDescription) { ValueInstantiator localValueInstantiator = findValueInstantiator(paramDeserializationContext, paramBeanDescription); DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig(); BeanDeserializerBuilder localBeanDeserializerBuilder1 = constructBeanDeserializerBuilder(paramDeserializationContext, paramBeanDescription); BeanDeserializerBuilder localBeanDeserializerBuilder2 = localBeanDeserializerBuilder1; localBeanDeserializerBuilder1.setValueInstantiator(localValueInstantiator); addBeanProps(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2); addObjectIdReader(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2); addReferenceProperties(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2); addInjectables(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2); JsonPOJOBuilder.Value localValue = paramBeanDescription.findPOJOBuilderConfig(); String str; if (localValue == null) str = "build"; else str = localValue.buildMethodName; AnnotatedMethod localAnnotatedMethod = paramBeanDescription.findMethod(str, null); if ((localAnnotatedMethod != null) && (localDeserializationConfig.canOverrideAccessModifiers())) ClassUtil.checkAndFixAccess(localAnnotatedMethod.getMember()); localBeanDeserializerBuilder2.setPOJOBuilder(localAnnotatedMethod, localValue); if (this._factoryConfig.hasDeserializerModifiers()) { Iterator localIterator2 = this._factoryConfig.deserializerModifiers().iterator(); while (localIterator2.hasNext()) localBeanDeserializerBuilder2 = ((BeanDeserializerModifier)localIterator2.next()).updateBuilder(localDeserializationConfig, paramBeanDescription, localBeanDeserializerBuilder2); } JsonDeserializer localJsonDeserializer = localBeanDeserializerBuilder2.buildBuilderBased(paramJavaType, str); if (this._factoryConfig.hasDeserializerModifiers()) { Iterator localIterator1 = this._factoryConfig.deserializerModifiers().iterator(); while (localIterator1.hasNext()) localJsonDeserializer = ((BeanDeserializerModifier)localIterator1.next()).modifyDeserializer(localDeserializationConfig, paramBeanDescription, localJsonDeserializer); } return localJsonDeserializer; }