Refine search
@Override protected boolean matches(Resolvable resolvable, T bean) { AssignabilityRules rules = null; if (resolvable.isDelegate()) { rules = DelegateInjectionPointAssignabilityRules.instance(); } else { rules = BeanTypeAssignabilityRules.instance(); } return rules.matches(resolvable.getTypes(), bean.getTypes()) && Beans.containsAllQualifiers(resolvable.getQualifiers(), QualifierInstance.of(bean, store)); }
@Override protected boolean matches(Resolvable resolvable, DisposalMethod<?, ?> disposer) { return resolvable.getDeclaringBean().equals(disposer.getDeclaringBean()) && rules.matches(disposer.getGenericType(), resolvable.getTypes()) && Beans.containsAllQualifiers(disposer.getRequiredQualifiers(), resolvable.getQualifiers()); }
boolean matches(Type requiredType, Set<Annotation> qualifiers) { return BeanTypeAssignabilityRules.instance().matches(requiredType, resultType) && this.qualifiers.containsAll(qualifiers); }
@Override protected boolean matches(Resolvable resolvable, DisposalMethod<?, ?> disposer) { return resolvable.getDeclaringBean().equals(disposer.getDeclaringBean()) && rules.matches(disposer.getGenericType(), resolvable.getTypes()) && Beans.containsAllQualifiers(disposer.getRequiredQualifiers(), resolvable.getQualifiers()); }
@Override public Object getReference(Bean<?> bean, Type requestedType, CreationalContext<?> creationalContext) { Preconditions.checkArgumentNotNull(bean, "bean"); Preconditions.checkArgumentNotNull(requestedType, "requestedType"); Preconditions.checkArgumentNotNull(creationalContext, CREATIONAL_CONTEXT); if (!BeanTypeAssignabilityRules.instance().matches(requestedType, bean.getTypes())) { throw BeanManagerLogger.LOG.specifiedTypeNotBeanType(requestedType, bean); } // Ensure that there is no injection point associated final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.push(EmptyInjectionPoint.INSTANCE); try { return getReference(bean, requestedType, creationalContext, false); } finally { stack.pop(); } }
@Override protected boolean matches(Resolvable resolvable, T bean) { AssignabilityRules rules = null; if (resolvable.isDelegate()) { rules = DelegateInjectionPointAssignabilityRules.instance(); } else { rules = BeanTypeAssignabilityRules.instance(); } return rules.matches(resolvable.getTypes(), bean.getTypes()) && Beans.containsAllQualifiers(resolvable.getQualifiers(), QualifierInstance.of(bean, store)); }
@Override protected boolean matches(Resolvable resolvable, DisposalMethod<?, ?> disposer) { return resolvable.getDeclaringBean().equals(disposer.getDeclaringBean()) && rules.matches(disposer.getGenericType(), resolvable.getTypes()) && Beans.containsAllQualifiers(disposer.getRequiredQualifiers(), resolvable.getQualifiers()); }
@Override public Object getReference(Bean<?> bean, Type requestedType, CreationalContext<?> creationalContext) { Preconditions.checkArgumentNotNull(bean, "bean"); Preconditions.checkArgumentNotNull(requestedType, "requestedType"); Preconditions.checkArgumentNotNull(creationalContext, CREATIONAL_CONTEXT); if (!BeanTypeAssignabilityRules.instance().matches(requestedType, bean.getTypes())) { throw BeanManagerLogger.LOG.specifiedTypeNotBeanType(requestedType, bean); } // Ensure that there is no injection point associated final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.push(EmptyInjectionPoint.INSTANCE); try { return getReference(bean, requestedType, creationalContext, false); } finally { stack.pop(); } }
@Override protected boolean matches(Resolvable resolvable, T bean) { AssignabilityRules rules = null; if (resolvable.isDelegate()) { rules = DelegateInjectionPointAssignabilityRules.instance(); } else { rules = BeanTypeAssignabilityRules.instance(); } return rules.matches(resolvable.getTypes(), bean.getTypes()) && Beans.containsAllQualifiers(resolvable.getQualifiers(), QualifierInstance.of(bean, store)); }
@Override protected boolean matches(Resolvable resolvable, DisposalMethod<?, ?> disposer) { return resolvable.getDeclaringBean().equals(disposer.getDeclaringBean()) && rules.matches(disposer.getGenericType(), resolvable.getTypes()) && Beans.containsAllQualifiers(disposer.getRequiredQualifiers(), resolvable.getQualifiers()); }
@Override public Object getReference(Bean<?> bean, Type requestedType, CreationalContext<?> creationalContext) { Preconditions.checkArgumentNotNull(bean, "bean"); Preconditions.checkArgumentNotNull(requestedType, "requestedType"); Preconditions.checkArgumentNotNull(creationalContext, CREATIONAL_CONTEXT); if (!BeanTypeAssignabilityRules.instance().matches(requestedType, bean.getTypes())) { throw BeanManagerLogger.LOG.specifiedTypeNotBeanType(requestedType, bean); } // Ensure that there is no injection point associated final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.push(EmptyInjectionPoint.INSTANCE); try { return getReference(bean, requestedType, creationalContext, false); } finally { stack.pop(); } }
@Override protected boolean matches(Resolvable resolvable, T bean) { AssignabilityRules rules = null; if (resolvable.isDelegate()) { rules = DelegateInjectionPointAssignabilityRules.instance(); } else { rules = BeanTypeAssignabilityRules.instance(); } return rules.matches(resolvable.getTypes(), bean.getTypes()) && Beans.containsAllQualifiers(resolvable.getQualifiers(), QualifierInstance.of(bean, store)); }
@Override protected boolean matches(Resolvable resolvable, DisposalMethod<?, ?> disposer) { return resolvable.getDeclaringBean().equals(disposer.getDeclaringBean()) && rules.matches(disposer.getGenericType(), resolvable.getTypes()) && Beans.containsAllQualifiers(disposer.getRequiredQualifiers(), resolvable.getQualifiers()); }
@Override public Object getReference(Bean<?> bean, Type requestedType, CreationalContext<?> creationalContext) { Preconditions.checkArgumentNotNull(bean, "bean"); Preconditions.checkArgumentNotNull(requestedType, "requestedType"); Preconditions.checkArgumentNotNull(creationalContext, CREATIONAL_CONTEXT); if (!BeanTypeAssignabilityRules.instance().matches(requestedType, bean.getTypes())) { throw BeanManagerLogger.LOG.specifiedTypeNotBeanType(requestedType, bean); } // Ensure that there is no injection point associated final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.push(EmptyInjectionPoint.INSTANCE); try { return getReference(bean, requestedType, creationalContext, false); } finally { stack.pop(); } }
@Override protected boolean matches(Resolvable resolvable, T bean) { AssignabilityRules rules = null; if (resolvable.isDelegate()) { rules = DelegateInjectionPointAssignabilityRules.instance(); } else { rules = BeanTypeAssignabilityRules.instance(); } return rules.matches(resolvable.getTypes(), bean.getTypes()) && Beans.containsAllQualifiers(resolvable.getQualifiers(), QualifierInstance.of(bean, store)); }
@Override protected boolean matches(Resolvable resolvable, DisposalMethod<?, ?> disposer) { return resolvable.getDeclaringBean().equals(disposer.getDeclaringBean()) && rules.matches(disposer.getGenericType(), resolvable.getTypes()) && Beans.containsAllQualifiers(disposer.getRequiredQualifiers(), resolvable.getQualifiers()); }
@Override public Object getReference(Bean<?> bean, Type requestedType, CreationalContext<?> creationalContext) { Preconditions.checkArgumentNotNull(bean, "bean"); Preconditions.checkArgumentNotNull(requestedType, "requestedType"); Preconditions.checkArgumentNotNull(creationalContext, CREATIONAL_CONTEXT); if (!BeanTypeAssignabilityRules.instance().matches(requestedType, bean.getTypes())) { throw BeanManagerLogger.LOG.specifiedTypeNotBeanType(requestedType, bean); } // Ensure that there is no injection point associated final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.push(EmptyInjectionPoint.INSTANCE); try { return getReference(bean, requestedType, creationalContext, false); } finally { stack.pop(); } }
@Override protected boolean matches(Resolvable resolvable, T bean) { AssignabilityRules rules = null; if (resolvable.isDelegate()) { rules = DelegateInjectionPointAssignabilityRules.instance(); } else { rules = BeanTypeAssignabilityRules.instance(); } return rules.matches(resolvable.getTypes(), bean.getTypes()) && Beans.containsAllQualifiers(resolvable.getQualifiers(), QualifierInstance.of(bean, store)); }
@Override public Object getReference(Bean<?> bean, Type requestedType, CreationalContext<?> creationalContext) { Preconditions.checkArgumentNotNull(bean, "bean"); Preconditions.checkArgumentNotNull(requestedType, "requestedType"); Preconditions.checkArgumentNotNull(creationalContext, CREATIONAL_CONTEXT); if (!BeanTypeAssignabilityRules.instance().matches(requestedType, bean.getTypes())) { throw BeanManagerLogger.LOG.specifiedTypeNotBeanType(requestedType, bean); } // Ensure that there is no injection point associated final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.push(EmptyInjectionPoint.INSTANCE); try { return getReference(bean, requestedType, creationalContext, false); } finally { stack.pop(); } }
@Override protected boolean matches(Resolvable resolvable, Decorator<?> bean) { return rules.matches(Collections.singleton(bean.getDelegateType()), resolvable.getTypes()) && Beans.containsAllQualifiers(QualifierInstance.of(bean.getDelegateQualifiers(), getStore()), resolvable.getQualifiers()) && getBeanManager().getEnabled().isDecoratorEnabled(bean.getBeanClass()); }