Refine search
public TypeSafeDisposerResolver(Iterable<DisposalMethod<?, ?>> disposers, WeldConfiguration configuration) { super(disposers, configuration); this.rules = BeanTypeAssignabilityRules.instance(); }
protected boolean parametersMatch(WildcardType requiredParameter, TypeVariable<?> beanParameter) { Type[] beanParameterBounds = getUppermostTypeVariableBounds(beanParameter); if (!lowerBoundsOfWildcardMatch(beanParameterBounds, requiredParameter)) { return false; } Type[] requiredUpperBounds = requiredParameter.getUpperBounds(); // upper bound of the type variable is assignable to OR assignable from the upper bound of the wildcard return (boundsMatch(requiredUpperBounds, beanParameterBounds) || boundsMatch(beanParameterBounds, requiredUpperBounds)); }
@Override public boolean matches(Type requiredType, Type beanType) { return matchesNoBoxing(Types.boxedType(requiredType), Types.boxedType(beanType)); }
protected boolean parametersMatch(WildcardType requiredParameter, Type beanParameter) { return (lowerBoundsOfWildcardMatch(beanParameter, requiredParameter) && upperBoundsOfWildcardMatch(requiredParameter, beanParameter)); }
protected boolean parametersMatch(TypeVariable<?> requiredParameter, TypeVariable<?> beanParameter) { return boundsMatch(getUppermostTypeVariableBounds(beanParameter), getUppermostTypeVariableBounds(requiredParameter)); } }
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; }
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<?>) { return parametersMatch(requiredParameter, (TypeVariable<?>) beanParameter); return parametersMatch((TypeVariable<?>) requiredParameter, (TypeVariable<?>) beanParameter);
protected boolean parametersMatch(Type requiredParameter, TypeVariable<?> beanParameter) { for (Type bound : getUppermostTypeVariableBounds(beanParameter)) { if (!CovariantTypes.isAssignableFrom(bound, requiredParameter)) { return false; } } return true; }
/** * A parameterized bean type is considered assignable to a parameterized required type if they have * identical raw type and for each parameter: */ private boolean matches(ParameterizedType requiredType, ParameterizedType beanType) { if (!requiredType.getRawType().equals(beanType.getRawType())) { return false; } if (requiredType.getActualTypeArguments().length != beanType.getActualTypeArguments().length) { throw new IllegalArgumentException("Invalid argument combination " + requiredType + "; " + beanType); } for (int i = 0; i < requiredType.getActualTypeArguments().length; i++) { if (!parametersMatch(requiredType.getActualTypeArguments()[i], beanType.getActualTypeArguments()[i])) { return false; } } return true; }
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; }
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<?>) { return parametersMatch(requiredParameter, (TypeVariable<?>) beanParameter); return parametersMatch((TypeVariable<?>) requiredParameter, (TypeVariable<?>) beanParameter);
protected boolean parametersMatch(WildcardType requiredParameter, Type beanParameter) { return (lowerBoundsOfWildcardMatch(beanParameter, requiredParameter) && upperBoundsOfWildcardMatch(requiredParameter, beanParameter)); }
protected boolean parametersMatch(TypeVariable<?> requiredParameter, TypeVariable<?> beanParameter) { return boundsMatch(getUppermostTypeVariableBounds(beanParameter), getUppermostTypeVariableBounds(requiredParameter)); } }
protected boolean parametersMatch(Type requiredParameter, TypeVariable<?> beanParameter) { for (Type bound : getUppermostTypeVariableBounds(beanParameter)) { if (!CovariantTypes.isAssignableFrom(bound, requiredParameter)) { return false; } } return true; }
/** * A parameterized bean type is considered assignable to a parameterized required type if they have * identical raw type and for each parameter: */ private boolean matches(ParameterizedType requiredType, ParameterizedType beanType) { if (!requiredType.getRawType().equals(beanType.getRawType())) { return false; } if (requiredType.getActualTypeArguments().length != beanType.getActualTypeArguments().length) { throw new IllegalArgumentException("Invalid argument combination " + requiredType + "; " + beanType); } for (int i = 0; i < requiredType.getActualTypeArguments().length; i++) { if (!parametersMatch(requiredType.getActualTypeArguments()[i], beanType.getActualTypeArguments()[i])) { return false; } } return true; }
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; }
protected boolean parametersMatch(WildcardType requiredParameter, TypeVariable<?> beanParameter) { Type[] beanParameterBounds = getUppermostTypeVariableBounds(beanParameter); if (!lowerBoundsOfWildcardMatch(beanParameterBounds, requiredParameter)) { return false; } Type[] requiredUpperBounds = requiredParameter.getUpperBounds(); // upper bound of the type variable is assignable to OR assignable from the upper bound of the wildcard return (boundsMatch(requiredUpperBounds, beanParameterBounds) || boundsMatch(beanParameterBounds, requiredUpperBounds)); }
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<?>) { return parametersMatch(requiredParameter, (TypeVariable<?>) beanParameter); return parametersMatch((TypeVariable<?>) requiredParameter, (TypeVariable<?>) beanParameter);
public TypeSafeDisposerResolver(Iterable<DisposalMethod<?, ?>> disposers, WeldConfiguration configuration) { super(disposers, configuration); this.rules = BeanTypeAssignabilityRules.instance(); }
@Override public boolean matches(Type requiredType, Type beanType) { return matchesNoBoxing(Types.boxedType(requiredType), Types.boxedType(beanType)); }