Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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;
 
 
Implementation of the Section 8.3.1 of the CDI specification.

Author(s):
Jozef Hartinger
Matus Abaffy
 
 
     private static final AssignabilityRules INSTANCE = new DelegateInjectionPointAssignabilityRules();
 
     public static AssignabilityRules instance() {
         return ;
     }
 
     @Override
     protected boolean parametersMatch(Type delegateParameterType 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(delegateParameterbeanParameter);
         }
         // 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((WildcardTypedelegateParameterbeanParameter);
         }
         // 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((WildcardTypedelegateParameter, (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<?>) delegateParameterbeanParameter);
         }
         /*
          * 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 delegateParameterTypeVariable<?> beanParameter) {
        Type[] beanParameterBounds = getUppermostTypeVariableBounds(beanParameter);
        if (!lowerBoundsOfWildcardMatch(beanParameterBoundsdelegateParameter)) {
            return false;
        }
        Type[] requiredUpperBounds = delegateParameter.getUpperBounds();
        // upper bound of the type variable is assignable to the upper bound of the wildcard
        return boundsMatch(requiredUpperBoundsbeanParameterBounds);
    }
    @Override
    protected boolean parametersMatch(TypeVariable<?> delegateParameterTypeVariable<?> beanParameter) {
        return boundsMatch(getUppermostTypeVariableBounds(delegateParameter), getUppermostTypeVariableBounds(beanParameter));
    }
    protected boolean parametersMatch(TypeVariable<?> delegateParameterType beanParameter) {
        for (Type type : getUppermostTypeVariableBounds(delegateParameter)) {
            if (!CovariantTypes.isAssignableFrom(typebeanParameter)) {
                return false;
            }
        }
        return true;
    }
New to GrepCode? Check out our FAQ X