Java Code Examples for org.springframework.core.ResolvableType#getGenerics()

/**
 *
 * @param rt
 * @return
 */
protected static Type getType(final ResolvableType rt) {
    if (!rt.hasGenerics()) {
        return rt.resolve();
    } else {
        return new ParameterizedType() {
            public Type[] getActualTypeArguments() {
                Type[] ret = new Type[rt.getGenerics().length];
                for (int i = 0; i < ret.length; i++) {
                    ret[i] = getType(rt.getGenerics()[i]);
                }
                return ret;
            }

            public Type getRawType() {
                return rt.resolve();
            }

            public Type getOwnerType() {
                return null;
            }
        };
    }
}
 

public static Type compose(Type originType, Type composedType) {
	ResolvableType resolvableOriginType = ResolvableType.forType(originType);
	ResolvableType resolvableComposedType = ResolvableType.forType(composedType);
	if (FunctionTypeUtils.isSupplier(originType)) {
		if (FunctionTypeUtils.isFunction(composedType)) {
			ResolvableType resolvableLastArgument = resolvableComposedType.getGenerics()[1];
			resolvableLastArgument = FunctionTypeUtils.isPublisher(resolvableOriginType.getGeneric(0).getType())
					? ResolvableType.forClassWithGenerics(resolvableOriginType.getGeneric(0).getRawClass(), resolvableLastArgument)
							: resolvableLastArgument;
					originType = ResolvableType.forClassWithGenerics(Supplier.class, resolvableLastArgument).getType();
		}
	}
	else  {
		ResolvableType outType = FunctionTypeUtils.isConsumer(composedType)
				? ResolvableType.forClass(Void.class)
						: (ObjectUtils.isEmpty(resolvableComposedType.getGenerics())
								? ResolvableType.forClass(Object.class) : resolvableComposedType.getGenerics()[1]);

		originType = ResolvableType.forClassWithGenerics(Function.class,
				ObjectUtils.isEmpty(resolvableOriginType.getGenerics()) ? resolvableOriginType : resolvableOriginType.getGenerics()[0],
						outType).getType();
	}
	return originType;
}
 

@Nullable
private ResolvableType[] getRequiredTypeInfo(Class<?> converterClass, Class<?> genericIfc) {
	ResolvableType resolvableType = ResolvableType.forClass(converterClass).as(genericIfc);
	ResolvableType[] generics = resolvableType.getGenerics();
	if (generics.length < 2) {
		return null;
	}
	Class<?> sourceType = generics[0].resolve();
	Class<?> targetType = generics[1].resolve();
	if (sourceType == null || targetType == null) {
		return null;
	}
	return generics;
}
 

@Nullable
private ResolvableType[] getRequiredTypeInfo(Class<?> converterClass, Class<?> genericIfc) {
	ResolvableType resolvableType = ResolvableType.forClass(converterClass).as(genericIfc);
	ResolvableType[] generics = resolvableType.getGenerics();
	if (generics.length < 2) {
		return null;
	}
	Class<?> sourceType = generics[0].resolve();
	Class<?> targetType = generics[1].resolve();
	if (sourceType == null || targetType == null) {
		return null;
	}
	return generics;
}
 

static Set<Object[]> getTestParameters(Set<ResolvableType> testClasses) {
    Set<Object[]> parameters = new HashSet<>();
    for (ResolvableType resolvableRawClass : testClasses) {
        Class<?> rawClass = resolvableRawClass.resolve();
        StringBuilder testName = new StringBuilder(rawClass.getSimpleName());
        for (ResolvableType resolvableGeneric : resolvableRawClass.getGenerics()) {
            Class<?> genericClass = resolvableGeneric.getRawClass();
            if (genericClass != null) testName = testName.append('—').append(genericClass.getSimpleName());
        }

        parameters.add(new Object[]{testName.toString(), rawClass});
    }
    return parameters;
}
 

private ResolvableType[] getRequiredTypeInfo(Class<?> converterClass, Class<?> genericIfc) {
	ResolvableType resolvableType = ResolvableType.forClass(converterClass).as(genericIfc);
	ResolvableType[] generics = resolvableType.getGenerics();
	if (generics.length < 2) {
		return null;
	}
	Class<?> sourceType = generics[0].resolve();
	Class<?> targetType = generics[1].resolve();
	if (sourceType == null || targetType == null) {
		return null;
	}
	return generics;
}
 

static Set<Object[]> getTestParameters(Set<ResolvableType> testClasses) {
    Set<Object[]> parameters = new HashSet<>();
    for (ResolvableType resolvableRawClass : testClasses) {
        Class<?> rawClass = resolvableRawClass.resolve();
        StringBuilder testName = new StringBuilder(rawClass.getSimpleName());
        for (ResolvableType resolvableGeneric : resolvableRawClass.getGenerics()) {
            Class<?> genericClass = resolvableGeneric.getRawClass();
            if (genericClass != null) testName = testName.append('—').append(genericClass.getSimpleName());
        }

        parameters.add(new Object[]{testName.toString(), rawClass});
    }
    return parameters;
}
 

private ResolvableType[] getRequiredTypeInfo(Object converter, Class<?> genericIfc) {
	ResolvableType resolvableType = ResolvableType.forClass(converter.getClass()).as(genericIfc);
	ResolvableType[] generics = resolvableType.getGenerics();
	if (generics.length < 2) {
		return null;
	}
	Class<?> sourceType = generics[0].resolve();
	Class<?> targetType = generics[1].resolve();
	if (sourceType == null || targetType == null) {
		return null;
	}
	return generics;
}
 

@Override
public boolean match(Class<C> callbackType, C callbackInstance, A argument, Object[] additionalArguments) {
	ResolvableType type = ResolvableType.forClass(callbackType, callbackInstance.getClass());
	if (type.getGenerics().length == 1 && type.resolveGeneric() != null) {
		return type.resolveGeneric().isInstance(argument);
	}

	return true;
}
 

/**
 * For a specific class that implements or extends a parameterized type, return the
 * parameter of that interface at a given position. For example, for this class:
 *
 * <pre> {@code
 * class MessageChannelBinder implements Binder<MessageChannel, ?, ?>
 * } </pre>
 *
 * <pre> {@code
 * getParameterType(MessageChannelBinder.class, Binder.class, 0);
 * } </pre>
 *
 * will return {@code Binder}
 * @param evaluatedClass the evaluated class
 * @param interfaceClass the parametrized interface
 * @param position the position
 * @return the parameter type if any
 * @throws IllegalStateException if the evaluated class does not implement the
 * interface or
 */
public static Class<?> getParameterType(Class<?> evaluatedClass,
		Class<?> interfaceClass, int position) {
	Class<?> bindableType = null;
	Assert.isTrue(interfaceClass.isInterface(),
			"'interfaceClass' must be an interface");
	if (!interfaceClass.isAssignableFrom(evaluatedClass)) {
		throw new IllegalStateException(
				evaluatedClass + " does not implement " + interfaceClass);
	}
	ResolvableType currentType = ResolvableType.forType(evaluatedClass);
	while (!Object.class.equals(currentType.getRawClass()) && bindableType == null) {
		ResolvableType[] interfaces = currentType.getInterfaces();
		ResolvableType resolvableType = null;
		for (ResolvableType interfaceType : interfaces) {
			if (interfaceClass.equals(interfaceType.getRawClass())) {
				resolvableType = interfaceType;
				break;
			}
		}
		if (resolvableType == null) {
			currentType = currentType.getSuperType();
		}
		else {
			ResolvableType[] generics = resolvableType.getGenerics();
			ResolvableType generic = generics[position];
			Class<?> resolvedParameter = generic.resolve();
			if (resolvedParameter != null) {
				bindableType = resolvedParameter;
			}
			else {
				bindableType = Object.class;
			}
		}
	}
	if (bindableType == null) {
		throw new IllegalStateException(
				"Cannot find parameter of " + evaluatedClass.getName() + " for "
						+ interfaceClass + " at position " + position);
	}
	return bindableType;
}