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(); }
public ResolvableBuilder addQualifiers(Annotation[] qualifiers) { for (Annotation qualifier : qualifiers) { addQualifier(qualifier); } return this; }
@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 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; }
Member member = injectionPoint.getMember(); if (member instanceof Executable) { AnnotatedParameter<?> annotatedParameter = (AnnotatedParameter<?>) injectionPoint.getAnnotated(); Parameter parameter = executable.getParameters()[annotatedParameter.getPosition()]; named = new NamedLiteral(parameter.getName()); } else { named = new NamedLiteral(injectionPoint.getMember().getName()); checkQualifier(qualifier, qualifierInstance, annotationType); this.qualifierInstances.add(qualifierInstance); return this;
public ResolvableBuilder(InjectionPoint injectionPoint, final BeanManagerImpl manager) { this(injectionPoint.getType(), manager); addQualifiers(injectionPoint.getQualifiers(), injectionPoint); setDeclaringBean(injectionPoint.getBean()); this.delegate = injectionPoint.isDelegate(); }
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 ResolvableBuilder addQualifier(Annotation qualifier, InjectionPoint injectionPoint) { QualifierInstance qualifierInstance = QualifierInstance.of(qualifier, store); final Class<? extends Annotation> annotationType = qualifierInstance.getAnnotationClass(); // Handle the @New qualifier special case if (annotationType.equals(New.class)) { New newQualifier = New.class.cast(qualifier); if (newQualifier.value().equals(New.class) && rawType == null) { throw new IllegalStateException("Cannot transform @New when there is no known raw type"); } else if (newQualifier.value().equals(New.class)) { qualifier = new NewLiteral(rawType); qualifierInstance = QualifierInstance.of(qualifier, store); } } else if (injectionPoint != null && annotationType.equals(Named.class)) { Named named = (Named) qualifier; if (named.value().equals("")) { // WELD-1739 // This is an injection point with an @Named qualifier, with no value specified, we need to assume the name of the field in the value named = new NamedLiteral(injectionPoint.getMember().getName()); qualifier = named; qualifierInstance = QualifierInstance.of(named, store); } } checkQualifier(qualifier, qualifierInstance, annotationType); this.qualifierInstances.add(qualifierInstance); this.annotationTypes.add(annotationType); return this; }
@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); } }
requiredType = Parsers.parseType(filterValues.get(REQUIRED_TYPE), beanManager.getServices().get(ResourceLoader.class)); } else { requiredType = Object.class; return getError("Invalid required type: parsing error or the type is not accessible from the specified bean archive!"); ResolvableBuilder resolvableBuilder = new ResolvableBuilder(requiredType, beanManager); qualifierInstances = Parsers.parseQualifiers(filterValues.get(QUALIFIERS), beanManager.getServices().get(ResourceLoader.class), beanManager); } else { qualifierInstances = Collections.singletonList(QualifierInstance.DEFAULT); return getError("Invalid qualifiers: parsing error or one of the qualifier types is not accessible from the specified bean archive!"); resolvableBuilder.addQualifierUnchecked(qualifierInstance); Resolvable resolvable = resolvableBuilder.create(); beans = beanManager.getBeanResolver().resolve(resolvable, false); if (Boolean.valueOf(filterValues.get(RESOLVE))) { beans = beanManager.getBeanResolver().resolve(beans);
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 Resolvable create() { if (qualifierInstances.isEmpty()) { this.qualifierInstances.add(QualifierInstance.DEFAULT); } for (Type type : types) { Class<?> rawType = Reflections.getRawType(type); for (Class<?> facadeType : FACADE_TYPES) { if (facadeType.equals(rawType)) { return createFacade(facadeType); } } for (Class<?> metadataType : METADATA_TYPES) { if (metadataType.equals(rawType)) { return createMetadataProvider(metadataType); } } } return new ResolvableImpl(rawType, types, declaringBean, qualifierInstances, delegate); }
@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 InterceptorResolvableBuilder addType(Type type) { super.addType(type); return this; }
@Override public InterceptorResolvableBuilder addTypes(Set<Type> types) { super.addTypes(types); return this; }
Member member = injectionPoint.getMember(); if (member instanceof Executable) { AnnotatedParameter<?> annotatedParameter = (AnnotatedParameter<?>) injectionPoint.getAnnotated(); Parameter parameter = executable.getParameters()[annotatedParameter.getPosition()]; named = new NamedLiteral(parameter.getName()); } else { named = new NamedLiteral(injectionPoint.getMember().getName()); checkQualifier(qualifier, qualifierInstance, annotationType); this.qualifierInstances.add(qualifierInstance); return this;
public ResolvableBuilder(InjectionPoint injectionPoint, final BeanManagerImpl manager) { this(injectionPoint.getType(), manager); addQualifiers(injectionPoint.getQualifiers(), injectionPoint); setDeclaringBean(injectionPoint.getBean()); this.delegate = injectionPoint.isDelegate(); }
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()))); }
@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); } }
requiredType = Parsers.parseType(filterValues.get(REQUIRED_TYPE), beanManager.getServices().get(ResourceLoader.class)); } else { requiredType = Object.class; return getError("Invalid required type: parsing error or the type is not accessible from the specified bean archive!"); ResolvableBuilder resolvableBuilder = new ResolvableBuilder(requiredType, beanManager); qualifierInstances = Parsers.parseQualifiers(filterValues.get(QUALIFIERS), beanManager.getServices().get(ResourceLoader.class), beanManager); } else { qualifierInstances = Collections.singletonList(QualifierInstance.DEFAULT); return getError("Invalid qualifiers: parsing error or one of the qualifier types is not accessible from the specified bean archive!"); resolvableBuilder.addQualifierUnchecked(qualifierInstance); Resolvable resolvable = resolvableBuilder.create(); beans = beanManager.getBeanResolver().resolve(resolvable, false); if (Boolean.valueOf(filterValues.get(RESOLVE))) { beans = beanManager.getBeanResolver().resolve(beans);