Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* JBoss, Home of Professional Open Source
* Copyright 2012, Red Hat, Inc., and individual contributors
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jboss.weld.resolution;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import org.jboss.weld.util.Types;
/**
* Implementation of the Section 8.3.1 of the CDI specification.
*
* @author Jozef Hartinger
* @author Matus Abaffy
*/
public class DelegateInjectionPointAssignabilityRules extends BeanTypeAssignabilityRules {
private static final AssignabilityRules INSTANCE = new DelegateInjectionPointAssignabilityRules();
public static AssignabilityRules instance() {
return INSTANCE;
}
@Override
protected boolean parametersMatch(Type delegateParameter, Type beanParameter) {
// this is the same as for bean types
if (Types.isActualType(delegateParameter) && Types.isActualType(beanParameter)) {
/*
* the delegate type parameter and the bean type parameter are actual types with identical raw
* type, and, if the type is parameterized, the bean type parameter is assignable to the delegate
* type parameter according to these rules, or
*/
return matches(delegateParameter, beanParameter);
}
// this is the same as for bean types
if (delegateParameter instanceof WildcardType && Types.isActualType(beanParameter)) {
/*
* the delegate type parameter is a wildcard, the bean type parameter is an actual type and the
* actual type is assignable to the upper bound, if any, of the wildcard and assignable from the
* lower bound, if any, of the wildcard, or
*/
return parametersMatch((WildcardType) delegateParameter, beanParameter);
}
// this is different to bean type rules
if (delegateParameter instanceof WildcardType && beanParameter instanceof TypeVariable) {
/*
* the delegate type parameter is a wildcard, the bean type parameter is a type variable and the
* upper bound of the type variable is assignable to the upper bound, if any, of the wildcard and
* assignable from the lower bound, if any, of the wildcard, or
*/
return parametersMatch((WildcardType) delegateParameter, (TypeVariable) beanParameter);
}
// this is different to bean type rules
if (delegateParameter instanceof TypeVariable && beanParameter instanceof TypeVariable) {
/*
* the delegate type parameter and the bean type parameter are both type variables and the upper
* bound of the bean type parameter is assignable to the upper bound, if any, of the delegate type
* parameter, or
*/
return parametersMatch((TypeVariable) delegateParameter, (TypeVariable) beanParameter);
}
// this is different to bean type rules
if (delegateParameter instanceof TypeVariable && Types.isActualType(beanParameter)) {
/*
* the delegate type parameter is a type variable, the bean type parameter is an actual type, and
* the actual type is assignable to the upper bound, if any, of the type variable
*/
return parametersMatch((TypeVariable) delegateParameter, beanParameter);
}
/*
* this is not defined by the specification but is here to retain backward compatibility with previous
* versions of Weld
* see CDITCK-430
*/
if (Object.class.equals(delegateParameter) && beanParameter instanceof TypeVariable) {
TypeVariable beanParameterVariable = (TypeVariable) beanParameter;
return Object.class.equals(beanParameterVariable.getBounds()[0]);
}
return false;
}
@Override
protected boolean parametersMatch(WildcardType delegateParameter, TypeVariable beanParameter) {
Type[] beanParameterBounds = getUppermostTypeVariableBounds(beanParameter);
if (!lowerBoundsOfWildcardMatch(beanParameterBounds, delegateParameter)) {
return false;
}
Type[] requiredUpperBounds = delegateParameter.getUpperBounds();
// upper bound of the type variable is assignable to the upper bound of the wildcard
return boundsMatch(requiredUpperBounds, beanParameterBounds);
}
@Override
protected boolean parametersMatch(TypeVariable delegateParameter, TypeVariable beanParameter) {
return boundsMatch(getUppermostTypeVariableBounds(delegateParameter), getUppermostTypeVariableBounds(beanParameter));
}
protected boolean parametersMatch(TypeVariable delegateParameter, Type beanParameter) {
for (Type type : getUppermostTypeVariableBounds(delegateParameter)) {
if (!CovariantTypes.isAssignableFrom(type, beanParameter)) {
return false;
}
}
return true;
}
}
