private static boolean isAssignableFrom(ParameterizedType type1, Class<?> type2) { Class<?> rawType1 = Reflections.getRawType(type1); // raw types have to be assignable if (!isAssignableFrom(rawType1, type2)) { return false; } // this is a raw type with missing type arguments if (!Types.getCanonicalType(type2).equals(type2)) { return true; } return matches(type1, new HierarchyDiscovery(type2)); }
/** * Gets the boxed type of a class * * @param type The type * @return The boxed type */ public static Type boxedType(Type type) { if (type instanceof Class<?>) { return boxedClass((Class<?>) type); } else { return type; } }
@Override public boolean matches(Type observedType, Type eventType) { return matchesNoBoxing(Types.boxedType(observedType), Types.boxedType(eventType)); }
public static boolean containsTypeVariable(Type type) { type = Types.getCanonicalType(type); if (type instanceof TypeVariable<?>) { return true; } if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; for (Type t : parameterizedType.getActualTypeArguments()) { if (containsTypeVariable(t)) { return true; } } } if (type instanceof GenericArrayType) { GenericArrayType genericArrayType = (GenericArrayType) type; return containsTypeVariable(genericArrayType.getGenericComponentType()); } return false; }
if (Types.isArray(observedType) && Types.isArray(eventType)) { final Type observedComponentType = Types.getArrayComponentType(observedType); for (Type type : new HierarchyDiscovery(Types.getArrayComponentType(eventType)).getTypeClosure()) { if (matchesNoBoxing(observedComponentType, type)) { return true; return matches((TypeVariable<?>) observedType, eventType); return observedType.equals(Reflections.getRawType(eventType)); return matches((ParameterizedType) observedType, (ParameterizedType) eventType);
protected Type getEventType(Class<?> runtimeType) { Type resolvedType = runtimeType; if (Types.containsTypeVariable(resolvedType)) { /* * If the container is unable to resolve the parameterized type of the event object, it uses the specified type to infer the parameterized type of the event types. */ resolvedType = injectionPointTypeHierarchy.resolveType(resolvedType); } if (Types.containsTypeVariable(resolvedType)) { /* * Examining the hierarchy of the specified type did not help. This may still be one of the cases when combining the * event type and the specified type reveals the actual values for type variables. Let's try that. */ Type canonicalEventType = Types.getCanonicalType(runtimeType); TypeResolver objectTypeResolver = new EventObjectTypeResolverBuilder(injectionPointTypeHierarchy.getResolver() .getResolvedTypeVariables(), new HierarchyDiscovery(canonicalEventType).getResolver() .getResolvedTypeVariables()).build(); resolvedType = objectTypeResolver.resolveType(canonicalEventType); } return resolvedType; }
@Override public RuntimeException apply(Type eventType) { Type resolvedType = Types.getCanonicalType(eventType); /* * If the runtime type of the event object contains a type variable, the container must throw an IllegalArgumentException. */ if (Types.containsTypeVariable(resolvedType)) { return UtilLogger.LOG.typeParameterNotAllowedInEventType(eventType); } /* * If the runtime type of the event object is assignable to the type of a container lifecycle event, IllegalArgumentException is thrown. */ Class<?> resolvedClass = Reflections.getRawType(eventType); for (Class<?> containerEventType : Observers.CONTAINER_LIFECYCLE_EVENT_CANONICAL_SUPERTYPES) { if (containerEventType.isAssignableFrom(resolvedClass)) { return UtilLogger.LOG.eventTypeNotAllowed(eventType); } } return NO_EXCEPTION_MARKER; } }
Type typeParameter = type.getActualTypeArguments()[0]; if (typeParameter instanceof Class<?>) { this.observers.put(observer, new ExactTypePredicate(Reflections.getRawType(typeParameter))); } else if (typeParameter instanceof ParameterizedType) { this.observers.put(observer, CompositePredicate.assignable(Types.getRawTypes(wildCard.getUpperBounds()))); } else if (typeParameter instanceof TypeVariable<?>) { this.observers.put(observer, CompositePredicate.assignable(Types.getRawTypes(variable.getBounds())));
public boolean matchesNoBoxing(Type requiredType, Type beanType) { /* * Special handling for array event types as eventType closure does not contain the type closure of array component type * this is here for backwards compatibility - see ObserverMethodWithParametertizedTypeTest.testObserverMethodCanObserveArrayWildcard() */ if (Types.isArray(requiredType) && Types.isArray(beanType)) { return matchesNoBoxing(Types.getArrayComponentType(requiredType), Types.getArrayComponentType(beanType)); } if (requiredType instanceof Class<?>) { if (beanType instanceof Class<?>) { return matches((Class<?>) requiredType, (Class<?>) beanType); } if (beanType instanceof ParameterizedType) { return matches((Class<?>) requiredType, (ParameterizedType) beanType); } } else if (requiredType instanceof ParameterizedType) { if (beanType instanceof Class<?>) { return matches((Class<?>) beanType, (ParameterizedType) requiredType); } if (beanType instanceof ParameterizedType) { return matches((ParameterizedType) requiredType, (ParameterizedType) beanType); } } return false; }
if (Types.isActualType(observedParameter) && Types.isActualType(eventParameter)) { return matches(observedParameter, eventParameter); return CovariantTypes.isAssignableFrom(observedParameter, eventParameter); return parametersMatch((WildcardType) observedParameter, eventParameter); return parametersMatch((TypeVariable<?>) observedParameter, eventParameter);
public static String getTypeId(Type type) { if (type instanceof Class<?>) { return Reflections.<Class<?>> cast(type).getName(); } if (type instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) type; StringBuilder builder = new StringBuilder(getTypeId(pt.getRawType())); builder.append("<"); for (int i = 0; i < pt.getActualTypeArguments().length; i++) { if (i > 0) { builder.append(","); } builder.append(getTypeId(pt.getActualTypeArguments()[i])); } builder.append(">"); return builder.toString(); } if (type instanceof GenericArrayType) { GenericArrayType arrayType = (GenericArrayType) type; StringBuilder builder = new StringBuilder(getTypeId(arrayType.getGenericComponentType())); builder.append("[]"); return builder.toString(); } throw new IllegalArgumentException("Cannot create type id for " + type.toString()); }
protected boolean parametersMatch(Type requiredParameter, Type beanParameter) { if (Types.isActualType(requiredParameter) && Types.isActualType(beanParameter)) { return matches(requiredParameter, beanParameter); if (requiredParameter instanceof WildcardType && Types.isActualType(beanParameter)) { return parametersMatch((WildcardType) requiredParameter, beanParameter); return parametersMatch((WildcardType) requiredParameter, (TypeVariable<?>) beanParameter); if (Types.isActualType(requiredParameter) && beanParameter instanceof TypeVariable<?>) {
@Override public boolean matches(Type requiredType, Type beanType) { return matchesNoBoxing(Types.boxedType(requiredType), Types.boxedType(beanType)); }
private boolean matches(InvokableAnnotatedMethod<?> decoratedMethod, Method candidate) { if (candidate.getParameterTypes().length != decoratedMethod.getParameters().size()) { return false; } if (!candidate.getName().equals(decoratedMethod.getJavaMember().getName())) { return false; } for (int i = 0; i < candidate.getParameterTypes().length; i++) { Type decoratedMethodParamType = decoratedMethod.getJavaMember().getGenericParameterTypes()[i]; Type candidateParamType = candidate.getGenericParameterTypes()[i]; if (Types.containsTypeVariable(decoratedMethodParamType) || Types.containsTypeVariable(candidateParamType)) { if (!decoratedMethod.getJavaMember().getParameterTypes()[i].isAssignableFrom(candidate.getParameterTypes()[i])) { return false; } } else { if (!CovariantTypes.isAssignableFrom(decoratedMethodParamType, candidateParamType)) { return false; } } } return true; }
private void validateEnabledAlternativeStereotypes(BeanManagerImpl beanManager, BeanDeployment deployment) { BeansXml beansXml = deployment.getBeanDeploymentArchive().getBeansXml(); if (beansXml != null && !beansXml.getEnabledAlternativeStereotypes().isEmpty()) { // prepare lookup structure Map<String, Class<? extends Annotation>> loadedStereotypes = buildClassNameMap(beanManager.getEnabled().getAlternativeStereotypes()); for (Metadata<String> definition : beansXml.getEnabledAlternativeStereotypes()) { Class<? extends Annotation> stereotype = loadedStereotypes.get(definition.getValue()); if (!beanManager.isStereotype(stereotype)) { throw ValidatorLogger.LOG.alternativeStereotypeNotStereotype(definition); } if (!isAlternativeStereotype(beanManager, stereotype)) { throw ValidatorLogger.LOG.alternativeStereotypeNotAnnotated(definition); } } } }
for (Class<?> type : Types.getRawTypes(manager.createAnnotatedType(proxiedBeanType).getTypeClosure())) { Bundle bundle = FrameworkUtil.getBundle(type); if (bundle != null) {
/** * * @param type * @return */ public static Type getCanonicalType(Type type) { if (type instanceof Class<?>) { Class<?> clazz = (Class<?>) type; return getCanonicalType(clazz); } return type; }
private static String getTypeId(Type type) { if (type == null || type instanceof Class<?>) { return null; } return Types.getTypeId(type); }
if (Types.isArray(observedType) && Types.isArray(eventType)) { final Type observedComponentType = Types.getArrayComponentType(observedType); for (Type type : new HierarchyDiscovery(Types.getArrayComponentType(eventType)).getTypeClosure()) { if (matchesNoBoxing(observedComponentType, type)) { return true; return matches((TypeVariable<?>) observedType, eventType); return observedType.equals(Reflections.getRawType(eventType)); return matches((ParameterizedType) observedType, (ParameterizedType) eventType);
protected Type getEventType(Class<?> runtimeType) { Type resolvedType = runtimeType; if (Types.containsTypeVariable(resolvedType)) { /* * If the container is unable to resolve the parameterized type of the event object, it uses the specified type to infer the parameterized type of the event types. */ resolvedType = injectionPointTypeHierarchy.resolveType(resolvedType); } if (Types.containsTypeVariable(resolvedType)) { /* * Examining the hierarchy of the specified type did not help. This may still be one of the cases when combining the * event type and the specified type reveals the actual values for type variables. Let's try that. */ Type canonicalEventType = Types.getCanonicalType(runtimeType); TypeResolver objectTypeResolver = new EventObjectTypeResolverBuilder(injectionPointTypeHierarchy.getResolver() .getResolvedTypeVariables(), new HierarchyDiscovery(canonicalEventType).getResolver() .getResolvedTypeVariables()).build(); resolvedType = objectTypeResolver.resolveType(canonicalEventType); } return resolvedType; }