public BeanAttributesImpl(BeanAttributes<T> beanAttributes, boolean nullable) { this(beanAttributes.getTypes(), beanAttributes.getQualifiers(), beanAttributes.getScope(), beanAttributes.getName(), nullable, beanAttributes.getStereotypes(), beanAttributes.isAlternative()); }
/** * Utility constructor used for overriding Bean qualifiers and name for specialization purposes. */ public ImmutableBeanAttributes(Set<Annotation> qualifiers, String name, BeanAttributes<T> attributes) { this(attributes.getStereotypes(), attributes.isAlternative(), name, qualifiers, attributes.getTypes(), attributes.getScope()); }
/** * @param source source {@link BeanAttributes}. * @return a safe copy of source {@link BeanAttributes}. */ public static <T> BeanAttributes<T> of(BeanAttributes<T> source, BeanManager manager) { validateBeanAttributes(source, manager); BeanAttributes<T> attributes = new ImmutableBeanAttributes<T>(defensiveCopy(source.getStereotypes()), source.isAlternative(), source.getName(), defensiveCopy(source.getQualifiers()), defensiveCopy(source.getTypes()), source.getScope()); return attributes; }
@SuppressWarnings("unchecked") @Test @SpecAssertion(section = BM_OBTAIN_BEANATTRIBUTES, id = "a") public void testBeanAttributesForManagedBean() { AnnotatedType<Mountain> type = getCurrentManager().createAnnotatedType(Mountain.class); BeanAttributes<Mountain> attributes = getCurrentManager().createBeanAttributes(type); assertTrue(typeSetMatches(attributes.getTypes(), Landmark.class, Object.class)); assertTrue(typeSetMatches(attributes.getStereotypes(), TundraStereotype.class)); assertTrue(annotationSetMatches(attributes.getQualifiers(), Natural.class, Any.class)); assertEquals(attributes.getScope(), ApplicationScoped.class); assertEquals(attributes.getName(), "mountain"); assertTrue(attributes.isAlternative()); }
@SuppressWarnings("unchecked") @Test @SpecAssertions({ @SpecAssertion(section = PROCESS_BEAN_ATTRIBUTES, id = "aa"), @SpecAssertion(section = PROCESS_BEAN_ATTRIBUTES, id = "ad") }) public void testManagedBeanAttributes() { assertEquals(getCurrentManager().getBeans(Alpha.class, New.Literal.of(Alpha.class)).size(), 1); // No event is fired for any @New qualified bean assertEquals(extension.getAlphaAttributesObserved(), 1); BeanAttributes<Alpha> attributes = extension.getAlphaAttributes(); assertNotNull(attributes); assertEquals(attributes.getScope(), ApplicationScoped.class); verifyName(attributes, "alpha"); assertTrue(attributes.isAlternative()); assertTrue(typeSetMatches(attributes.getTypes(), Object.class, Alpha.class)); assertTrue(typeSetMatches(attributes.getStereotypes(), AlphaStereotype.class)); assertTrue(annotationSetMatches(attributes.getQualifiers(), AlphaQualifier.class, Named.class, Any.class)); // Event is not fired for managed bean that is not enabled assertNull(extension.getMike()); }
public static void validateStereotypes(BeanAttributes<?> attributes, BeanManager manager) { if(attributes.getStereotypes() == null) { throw MetadataLogger.LOG.stereotypesNull(attributes); } for (Class<? extends Annotation> annotation : attributes.getStereotypes()) { if (!manager.isStereotype(annotation)) { throw MetadataLogger.LOG.notAStereotype(annotation, attributes); } } }
@Test @SpecAssertion(section = PROCESS_BEAN_ATTRIBUTES, id = "bca") public void configuratorInitializedWithOriginalBeanAttributes() { Bean<Mace> configuredBean = getUniqueBean(Mace.class); BeanAttributes<Mace> originalBA = getCurrentManager().getExtension(ProcessBeanAttributesObserver.class).getOriginalBA(); assertEquals(configuredBean.getTypes(), originalBA.getTypes()); assertEquals(configuredBean.getQualifiers(), originalBA.getQualifiers()); assertEquals(configuredBean.getStereotypes(), originalBA.getStereotypes()); assertEquals(configuredBean.getScope(), originalBA.getScope()); } }
public static void validateTypes(BeanAttributes<?> attributes, BeanManager manager) { if(attributes.getTypes() == null) { throw MetadataLogger.LOG.typesNull(attributes); } if (attributes.getTypes().isEmpty()) { throw MetadataLogger.LOG.typesEmpty(attributes); } for (Type type : attributes.getTypes()) { validateBeanType(type, attributes); } }
protected <X> DisposalMethod<X, ?> resolveDisposalMethod(BeanAttributes<?> attributes, AbstractClassBean<X> declaringBean) { Set<DisposalMethod<X, ?>> disposalBeans = environment.<X>resolveDisposalBeans(attributes.getTypes(), attributes.getQualifiers(), declaringBean); if (disposalBeans.size() == 1) { return disposalBeans.iterator().next(); } else if (disposalBeans.size() > 1) { throw BeanLogger.LOG.multipleDisposalMethods(this, WeldCollections.toMultiRowString(disposalBeans)); } return null; }
private static void checkBeanTypeForWildcardsAndTypeVariables(Type beanType, Type type, BeanAttributes<?> attributes) { if (type instanceof TypeVariable<?>) { if (!attributes.getScope().equals(Dependent.class)) { throw MetadataLogger.LOG.beanWithParameterizedTypeContainingTypeVariablesMustBeDependentScoped(beanType, attributes); } } else if (type instanceof WildcardType) { throw MetadataLogger.LOG.parameterizedTypeContainingWildcardParameterIsNotAValidBeanType(beanType, attributes); } else if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; for (Type typeArgument : parameterizedType.getActualTypeArguments()) { checkBeanTypeForWildcardsAndTypeVariables(beanType, typeArgument, attributes); } } else if (type instanceof GenericArrayType) { GenericArrayType arrayType = (GenericArrayType) type; checkBeanTypeForWildcardsAndTypeVariables(beanType, arrayType.getGenericComponentType(), attributes); } }
private static BeanIdentifier createId(BeanAttributes<?> attributes, EnhancedAnnotatedMethod<?, ?> method, AbstractClassBean<?> declaringBean) { if (Dependent.class.equals(attributes.getScope()) || ApplicationScoped.class.equals(attributes.getScope())) { return new ProducerMethodIdentifier(method, declaringBean); } else { return new StringBeanIdentifier(BeanIdentifiers.forProducerMethod(method, declaringBean)); } }
private static BeanIdentifier createId(BeanAttributes<?> attributes, EnhancedAnnotatedType<?> clazz) { if (Dependent.class.equals(attributes.getScope()) || ApplicationScoped.class.equals(attributes.getScope())) { return new ManagedBeanIdentifier(clazz.slim().getIdentifier()); } else { return new StringBeanIdentifier(forManagedBean(clazz)); } }
@Override public Set<Type> getTypes() { return attributes().getTypes(); }
@Override public Set<Annotation> getQualifiers() { return attributes().getQualifiers(); }
@Override public Set<Class<? extends Annotation>> getStereotypes() { return attributes().getStereotypes(); }
private void verifyName(BeanAttributes<?> attributes, String name) { assertEquals(name, attributes.getName()); for (Annotation qualifier : attributes.getQualifiers()) { if (Named.class.equals(qualifier.annotationType())) { assertEquals(name, ((Named) qualifier).value()); return; } } fail("@Named qualifier not found."); } }
@Override public String getName() { return attributes().getName(); }
@Override public boolean isAlternative() { return attributes().isAlternative(); }
@Override public Class<? extends Annotation> getScope() { return attributes().getScope(); }