private JavaType applyModifiers(JavaType resultType, Class<?> sourceType) throws IllegalStateException { if (modifiers != null) { TypeBindings b = resultType.getBindings(); if (b == null) { b = TypeBindings.emptyBindings(); } for (TypeModifier mod : modifiers) { JavaType t = mod.modifyType(resultType, sourceType, b, mapper.getTypeFactory()); if (t == null) { throw new IllegalStateException(String.format( "TypeModifier %s (of type %s) return null for type %s", mod, mod.getClass().getName(), resultType)); } resultType = t; } } return resultType; }
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); }
protected JavaType getType(TypeBindings paramTypeBindings, TypeVariable<?>[] paramArrayOfTypeVariable) { if ((paramArrayOfTypeVariable != null) && (paramArrayOfTypeVariable.length > 0)) { paramTypeBindings = paramTypeBindings.childInstance(); int i = paramArrayOfTypeVariable.length; for (int j = 0; j < i; j++) { TypeVariable<?> localTypeVariable = paramArrayOfTypeVariable[j]; paramTypeBindings._addPlaceholder(localTypeVariable.getName()); Type localType = localTypeVariable.getBounds()[0]; JavaType localJavaType; if (localType == null) localJavaType = TypeFactory.unknownType(); else localJavaType = paramTypeBindings.resolveType(localType); paramTypeBindings.addBinding(localTypeVariable.getName(), localJavaType); } } return paramTypeBindings.resolveType(getGenericType()); }
protected JavaType getType(TypeBindings bindings, TypeVariable<?>[] typeParams) { // [JACKSON-468] Need to consider local type binding declarations too... if (typeParams != null && typeParams.length > 0) { bindings = bindings.childInstance(); for (TypeVariable<?> var : typeParams) { String name = var.getName(); // to prevent infinite loops, need to first add placeholder ("<T extends Enum<T>>" etc) bindings._addPlaceholder(name); // About only useful piece of information is the lower bound (which is at least Object.class) Type lowerBound = var.getBounds()[0]; JavaType type = (lowerBound == null) ? TypeFactory.unknownType() : bindings.resolveType(lowerBound); bindings.addBinding(var.getName(), type); } } return bindings.resolveType(getGenericType()); }
private JavaType constructJavaType(final Type type) { if (type instanceof ParameterizedType) { JavaType[] javaTypeArgs = new JavaType[((ParameterizedType) type).getActualTypeArguments().length]; for (int i = 0; i != ((ParameterizedType) type).getActualTypeArguments().length; ++i) { javaTypeArgs[i] = constructJavaType(((ParameterizedType) type).getActualTypeArguments()[i]); } return mapper.getTypeFactory().constructType(type, TypeBindings.create((Class<?>) ((ParameterizedType) type).getRawType(), javaTypeArgs)); } else { return mapper.getTypeFactory().constructType(type); } }
private JavaType resolve(final JavaType type) { Assert.notNull(type, "type can't be null"); JavaType tmp = type; while(Keeper.class.equals(tmp.getRawClass())) { TypeBindings bindings = tmp.getBindings(); Assert.isTrue(bindings.size() == 1, "Bindings must have one parameter type: " + type); tmp = bindings.getBoundType(0); } return tmp; }
@Override public JavaType modifyType(JavaType type, Type jdkType, TypeBindings context, TypeFactory typeFactory) { try { if (type.getClass().isAssignableFrom(SimpleType.class)) { Object overriddenBean = applicationContext.getBean(type.getRawClass().getName()); return SimpleType.construct(overriddenBean.getClass()); } } catch (NoSuchBeanDefinitionException e) { LOG.debug("No configured bean for " + type.getClass().getName() + " returning original type"); } return type; }
protected List<BeanPropertyWriter> findBeanProperties(SerializerProvider paramSerializerProvider, BeanDescription paramBeanDescription, BeanSerializerBuilder paramBeanSerializerBuilder) { List localList = paramBeanDescription.findProperties(); SerializationConfig localSerializationConfig = paramSerializerProvider.getConfig(); removeIgnorableTypes(localSerializationConfig, paramBeanDescription, localList); if (localSerializationConfig.isEnabled(MapperFeature.REQUIRE_SETTERS_FOR_GETTERS)) removeSetterlessGetters(localSerializationConfig, paramBeanDescription, localList); if (localList.isEmpty()) return null; boolean bool = usesStaticTyping(localSerializationConfig, paramBeanDescription, null); PropertyBuilder localPropertyBuilder = constructPropertyBuilder(localSerializationConfig, paramBeanDescription); ArrayList localArrayList = new ArrayList(localList.size()); TypeBindings localTypeBindings = paramBeanDescription.bindingsForBeanType(); Iterator localIterator = localList.iterator(); while (localIterator.hasNext()) { BeanPropertyDefinition localBeanPropertyDefinition = (BeanPropertyDefinition)localIterator.next(); AnnotatedMember localAnnotatedMember = localBeanPropertyDefinition.getAccessor(); if (localBeanPropertyDefinition.isTypeId()) { if (localAnnotatedMember != null) { if (localSerializationConfig.canOverrideAccessModifiers()) localAnnotatedMember.fixAccess(); paramBeanSerializerBuilder.setTypeId(localAnnotatedMember); } } else { AnnotationIntrospector.ReferenceProperty localReferenceProperty = localBeanPropertyDefinition.findReferenceType(); if ((localReferenceProperty == null) || (!localReferenceProperty.isBackReference())) if ((localAnnotatedMember instanceof AnnotatedMethod)) localArrayList.add(_constructWriter(paramSerializerProvider, localBeanPropertyDefinition, localTypeBindings, localPropertyBuilder, bool, (AnnotatedMethod)localAnnotatedMember)); else localArrayList.add(_constructWriter(paramSerializerProvider, localBeanPropertyDefinition, localTypeBindings, localPropertyBuilder, bool, (AnnotatedField)localAnnotatedMember)); } } return localArrayList; }
public ValueInstantiator constructValueInstantiator(DeserializationConfig config) { StdValueInstantiator inst = new StdValueInstantiator(config, _beanDesc.getType()); JavaType delegateType; if (_delegateCreator == null) { delegateType = null; } else { // need to find type... int ix = 0; if (_delegateArgs != null) { for (int i = 0, len = _delegateArgs.length; i < len; ++i) { if (_delegateArgs[i] == null) { // marker for delegate itself ix = i; break; } } } TypeBindings bindings = _beanDesc.bindingsForBeanType(); delegateType = bindings.resolveType(_delegateCreator.getGenericParameterType(ix)); } inst.configureFromObjectSettings(_defaultConstructor, _delegateCreator, delegateType, _delegateArgs, _propertyBasedCreator, _propertyBasedArgs); inst.configureFromStringCreator(_stringCreator); inst.configureFromIntCreator(_intCreator); inst.configureFromLongCreator(_longCreator); inst.configureFromDoubleCreator(_doubleCreator); inst.configureFromBooleanCreator(_booleanCreator); return inst; }
private AbstractType getTSTypeForClass(AnnotatedMember member) { TypeBindings bindings = new TypeBindings(TypeFactory.defaultInstance(), member.getDeclaringClass()); BeanProperty prop = new BeanProperty.Std(member.getName(), member.getType(bindings), NO_NAME, new AnnotationMap(), member, false); try { return getTSTypeForProperty(prop); } catch (JsonMappingException e) { throw new RuntimeException(e); } }
@Override public JavaType modifyType(JavaType type, Type jdkType, TypeBindings context, TypeFactory typeFactory) { called = true; return type; }
public TypeBindings bindingsForBeanType() { if (this._bindings == null) this._bindings = new TypeBindings(this._config.getTypeFactory(), this._type); return this._bindings; }
public final JavaType getType(TypeBindings paramTypeBindings) { return getType(paramTypeBindings, this._method.getTypeParameters()); }
public final JavaType resolveParameterType(int paramInt, TypeBindings paramTypeBindings) { return paramTypeBindings.resolveType(getGenericParameterType(paramInt)); }
public JavaType getType(TypeBindings paramTypeBindings) { return paramTypeBindings.resolveType(getGenericType()); }
public final JavaType getType(TypeBindings paramTypeBindings) { return getType(paramTypeBindings, this._constructor.getTypeParameters()); }
/** * As per [JACKSON-468], we need to also allow declaration of local * type bindings; mostly it will allow defining bounds. */ @Override public JavaType getType(TypeBindings bindings) { return getType(bindings, _method.getTypeParameters()); }
/** * As per [JACKSON-468], we need to also allow declaration of local * type bindings; mostly it will allow defining bounds. */ @Override public JavaType getType(TypeBindings bindings) { return getType(bindings, _constructor.getTypeParameters()); }
/** * Helper method that will construct {@link JavaType} for given * raw class. * This is a simple short-cut for: *<pre> * getTypeFactory().constructType(cls); *</pre> */ public final JavaType constructType(Class<?> cls) { return getTypeFactory().constructType(cls, (TypeBindings) null); }
/** * Helper method that will construct {@link JavaType} for given * type reference * This is a simple short-cut for: *<pre> * getTypeFactory().constructType(valueTypeRef); *</pre> */ public final JavaType constructType(TypeReference<?> valueTypeRef) { return getTypeFactory().constructType(valueTypeRef.getType(), (TypeBindings) null); }
/** * Method called to fully resolve type of one of parameters, given * specified type variable bindings. */ public final JavaType resolveParameterType(int index, TypeBindings bindings) { return bindings.resolveType(getGenericParameterType(index)); }
/** * Full generic type of the annotated element; definition * of what exactly this means depends on sub-class. */ public JavaType getType(TypeBindings context) { return context.resolveType(getGenericType()); }
/** * Accessor for type bindings that may be needed to fully resolve * types of member object, such as return and argument types of * methods and constructors, and types of fields. */ public abstract TypeBindings bindingsForBeanType();
public abstract TypeBindings bindingsForBeanType();