com.fasterxml.jackson.databind.type.TypeBindings Java Examples

/**
 * Gets entity type.
 *
 * @param type the type 
 * @return the entity type
 */
private Class<?> getEntityType(AnnotatedType type) {
	Class<?> containerEntityType = ((CollectionType) (type.getType())).getContentType().getRawClass();
	if (containerEntityType.isAssignableFrom(EntityModel.class)) {
		TypeBindings typeBindings = ((CollectionType) type.getType()).getContentType().getBindings() ;
		if (!CollectionUtils.isEmpty(typeBindings.getTypeParameters()))
			return typeBindings.getBoundType(0).getRawClass();
	}
	return containerEntityType;
}
 

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

/**
 * Constructor will not do any initializations, to allow for
 * configuring instances differently depending on use cases
 *
 * @param type Fully resolved type; may be `null`, but ONLY if no member fields or
 *    methods are to be accessed
 * @param rawType Type-erased class; pass if no `type` needed or available
 */
AnnotatedClass(JavaType type, Class<?> rawType, List<JavaType> superTypes,
        Class<?> primaryMixIn, Annotations classAnnotations, TypeBindings bindings, 
        AnnotationIntrospector aintr, MixInResolver mir, TypeFactory tf)
{
    _type = type;
    _class = rawType;
    _superTypes = superTypes;
    _primaryMixIn = primaryMixIn;
    _classAnnotations = classAnnotations;
    _bindings = bindings;
    _annotationIntrospector = aintr;
    _mixInResolver = mir;
    _typeFactory = tf;
}
 

/**
 * Constructor (only) used for creating primordial simple types (during bootstrapping)
 * and array type placeholders where no fields or methods are needed.
 *
 * @since 2.9
 */
AnnotatedClass(Class<?> rawType) {
    _type = null;
    _class = rawType;
    _superTypes = Collections.emptyList();
    _primaryMixIn = null;
    _classAnnotations = AnnotationCollector.emptyAnnotations();
    _bindings = TypeBindings.emptyBindings();
    _annotationIntrospector = null;
    _mixInResolver = null;
    _typeFactory = null;
}
 

AnnotatedClassResolver(MapperConfig<?> config, Class<?> cls, MixInResolver r) {
    _config = config;
    _type = null;
    _class = cls;
    _mixInResolver = r;
    _bindings = TypeBindings.emptyBindings();
    if (config == null) {
        _intr = null;
        _primaryMixin = null;
    } else {
        _intr = config.isAnnotationProcessingEnabled()
                ? config.getAnnotationIntrospector() : null;
        _primaryMixin = _config.findMixInClassFor(_class);
    }
}
 

MapDeserializer<T, I, K, V> createDeserializer(JavaType type) {
    List<JavaType> typeParameters = null;
    TypeBindings bindings = type.getBindings();
    if (bindings != null) {
        typeParameters = bindings.getTypeParameters();
    }
    JavaType keyType;
    JavaType valueType;
    if (typeParameters != null && !typeParameters.isEmpty()) {
        if (refKey && refValue) {
            if (typeParameters.size() != 2) {
                throw new IllegalStateException(
                        "type parameters: " + typeParameters + ", expected exactly two");
            }
        } else if (refKey || refValue) {
            if (typeParameters.size() != 1) {
                throw new IllegalStateException(
                        "type parameters: " + typeParameters + ", expected exactly one");
            }
        }
        keyType = refKey ? typeParameters.get(0) : null;
        valueType = refValue ? typeParameters.get(typeParameters.size() - 1) : null;
    } else {
        // `type` is a raw type
        keyType = TypeFactory.unknownType();
        valueType = TypeFactory.unknownType();
    }
    return MapDeserializer.create(keyType, valueType, typeHandlerPair, finish);
}
 

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 bindings, TypeFactory typeFactory) {

    if (type.isReferenceType() || type.isContainerType()) {
        return type;
    }
    final Class<?> raw = type.getRawClass();
    if (raw == Option.class)
        return ReferenceType.upgradeFrom(type, type.containedTypeOrUnknown(0));

    if (raw == Eval.class)
        return ReferenceType.upgradeFrom(type, type.containedTypeOrUnknown(0));
    if (raw == Trampoline.class)
        return ReferenceType.upgradeFrom(type, type.containedTypeOrUnknown(0));
    if (raw == Either.class)
        return ReferenceType.upgradeFrom(type, type.containedTypeOrUnknown(0));

    if (raw == Value.class)
        return ReferenceType.upgradeFrom(type, type.containedTypeOrUnknown(0));

    for(Class c : collectionLikeTypes){
        if (c.isAssignableFrom(raw)) {
            //   return CollectionType.upgradeFrom(type, type.containedTypeOrUnknown(0));
            return CollectionLikeType.upgradeFrom(type, type.containedTypeOrUnknown(0));
        }
    }



    return type;
}
 

@Override
@Deprecated // since 2.7
public TypeBindings bindingsForBeanType() {
    return _type.getBindings();
}
 

/**
 * @deprecated Since 2.7 Use {@link #getType()} instead. To be removed from 2.9
 */
@Deprecated
public final JavaType getType(TypeBindings bogus) {
    return getType();
}
 

public Basic(TypeFactory tf, TypeBindings b) {
    _typeFactory = tf;
    _bindings = b;
}
 

/**
 * Mutant factory method that will try to create and return a sub-type instance
 * for known parameterized types; for other types will return `null` to indicate
 * that no just refinement makes necessary sense, without trying to detect
 * special status through implemented interfaces.
 *
 * @since 2.7
 */
public abstract JavaType refine(Class<?> rawType, TypeBindings bindings,
        JavaType superClass, JavaType[] superInterfaces);
 

/**
 * @since 2.7
 */
public abstract TypeBindings getBindings();
 

/**
 * 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.
 *
 * @deprecated Since 2.7, should not need to access bindings directly
 */
@Deprecated
public abstract TypeBindings bindingsForBeanType();