Java 类com.fasterxml.jackson.databind.type.TypeBindings 实例源码

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();