public boolean isInjectedByEEComponent(Bean<?> bean, BeanManagerImpl beanManager) { if (componentInjectionPoints.isEmpty()) { return false; } for (InjectionPoint injectionPoint : componentInjectionPoints) { if (beanManager.getBeanResolver().resolve(new ResolvableBuilder(injectionPoint, beanManager).create(), false).contains(bean)) { return true; } } return false; }
@Override public Set<Bean<?>> getBeans(Type beanType, Annotation... qualifiers) { Resolvable resolvable = new ResolvableBuilder(beanType, this).addQualifiers(qualifiers).create(); return beanResolver.resolve(resolvable, isCacheable(qualifiers)); }
@Override public Set<Bean<?>> getBeans(Type beanType, Annotation... qualifiers) { Resolvable resolvable = new ResolvableBuilder(beanType, this).addQualifiers(qualifiers).create(); return beanResolver.resolve(resolvable, isCacheable(qualifiers)); }
public Set<Bean<?>> getBeans(InjectionPoint injectionPoint) { boolean registerInjectionPoint = isRegisterableInjectionPoint(injectionPoint); final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.pushConditionally(injectionPoint, registerInjectionPoint); try { // We always cache, we assume that people don't use inline annotation literal declarations, a little risky but FAQd return beanResolver.resolve(new ResolvableBuilder(injectionPoint, this).create(), true); } finally { stack.pop(); } }
public Set<Bean<?>> getBeans(InjectionPoint injectionPoint) { boolean registerInjectionPoint = isRegisterableInjectionPoint(injectionPoint); final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.pushConditionally(injectionPoint, registerInjectionPoint); try { // We always cache, we assume that people don't use inline annotation literal declarations, a little risky but FAQd return beanResolver.resolve(new ResolvableBuilder(injectionPoint, this).create(), true); } finally { stack.pop(); } }
public Set<Bean<?>> getBeans(InjectionPoint injectionPoint) { boolean registerInjectionPoint = isRegisterableInjectionPoint(injectionPoint); final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.pushConditionally(injectionPoint, registerInjectionPoint); try { // We always cache, we assume that people don't use inline annotation literal declarations, a little risky but FAQd return beanResolver.resolve(new ResolvableBuilder(injectionPoint, this).create(), true); } finally { stack.pop(); } }
@Override public List<Decorator<?>> resolveDecorators(Set<Type> types, Annotation... qualifiers) { checkResolveDecoratorsArguments(types); return decoratorResolver.resolve(new DecoratorResolvableBuilder(this).addTypes(types).addQualifiers(qualifiers).create(), isCacheable(qualifiers)); }
@Override public Object getInjectableReference(InjectionPoint injectionPoint, CreationalContext<?> creationalContext) { if (injectionPoint.isDelegate()) { return DecorationHelper.peek().getNextDelegate(injectionPoint, creationalContext); } else { Bean<?> resolvedBean = getBean(new ResolvableBuilder(injectionPoint, this).create()); return getInjectableReference(injectionPoint, resolvedBean, creationalContext); } }
@Override public Object getInjectableReference(InjectionPoint injectionPoint, CreationalContext<?> creationalContext) { if (injectionPoint.isDelegate()) { return DecorationHelper.peek().getNextDelegate(injectionPoint, creationalContext); } else { Bean<?> resolvedBean = getBean(new ResolvableBuilder(injectionPoint, this).create()); return getInjectableReference(injectionPoint, resolvedBean, creationalContext); } }
@Override public Object getInjectableReference(InjectionPoint injectionPoint, CreationalContext<?> creationalContext) { if (injectionPoint.isDelegate()) { return DecorationHelper.peek().getNextDelegate(injectionPoint, creationalContext); } else { Bean<?> resolvedBean = getBean(new ResolvableBuilder(injectionPoint, this).create()); return getInjectableReference(injectionPoint, resolvedBean, creationalContext); } }
@Override public List<Decorator<?>> resolveDecorators(Set<Type> types, Annotation... qualifiers) { checkResolveDecoratorsArguments(types); return decoratorResolver.resolve(new DecoratorResolvableBuilder(this).addTypes(types).addQualifiers(qualifiers).create(), isCacheable(qualifiers)); }
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()).addType(Object.class) .addQualifiers(qualifiers).addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()) .addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()) .addType(Object.class) .addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY) .create(); }
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()).addType(Object.class) .addQualifiers(qualifiers).addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Set<Annotation> qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<Type> typeClosure = sharedObjectCache.getTypeClosureHolder(eventType).get(); return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(typeClosure).addType(Object.class).addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()).addType(Object.class) .addQualifiers(qualifiers).addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Set<Annotation> qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<Type> typeClosure = sharedObjectCache.getTypeClosureHolder(eventType).get(); return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(typeClosure).addType(Object.class).addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY).create(); }
private Set<Bean<?>> resolveBeans() { // Perform typesafe resolution, and possibly attempt to resolve the ambiguity Resolvable resolvable = new ResolvableBuilder(getType(), getBeanManager()).addQualifiers(getQualifiers()) .setDeclaringBean(getInjectionPoint().getBean()).create(); TypeSafeBeanResolver beanResolver = getBeanManager().getBeanResolver(); return beanResolver.resolve(beanResolver.resolve(resolvable, Reflections.isCacheable(getQualifiers()))); }
private Set<Bean<?>> resolveBeans() { // Perform typesafe resolution, and possibly attempt to resolve the ambiguity Resolvable resolvable = new ResolvableBuilder(getType(), getBeanManager()).addQualifiers(getQualifiers()) .setDeclaringBean(getInjectionPoint().getBean()).create(); TypeSafeBeanResolver beanResolver = getBeanManager().getBeanResolver(); return beanResolver.resolve(beanResolver.resolve(resolvable, Reflections.isCacheable(getQualifiers()))); }
private Set<Bean<?>> resolveBeans() { // Perform typesafe resolution, and possibly attempt to resolve the ambiguity Resolvable resolvable = new ResolvableBuilder(getType(), getBeanManager()).addQualifiers(getQualifiers()) .setDeclaringBean(getInjectionPoint().getBean()).create(); TypeSafeBeanResolver beanResolver = getBeanManager().getBeanResolver(); return beanResolver.resolve(beanResolver.resolve(resolvable, Reflections.isCacheable(getQualifiers()))); }