Java Examples for javax.enterprise.inject.Alternative

void createGenericBeans(@Observes AfterBeanDiscovery event, BeanManager beanManager) {
    beanDiscoveryOver = true;
    // For each generic configuration type, we iterate the generic configurations
    for (Entry<GenericIdentifier, GenericConfigurationHolder> genericConfigurationEntry : genericConfigurationPoints.entrySet()) {
        Class<? extends Annotation> producerScope = Dependent.class;
        for (Annotation annotation : genericConfigurationEntry.getValue().getAnnotated().getAnnotations()) {
            if (beanManager.isScope(annotation.annotationType())) {
                producerScope = annotation.annotationType();
            }
        }
        GenericConfigurationHolder genericConfigurationHolder = genericConfigurationEntry.getValue();
        GenericIdentifier identifier = genericConfigurationEntry.getKey();
        Class<? extends Annotation> genericConfigurationType = identifier.getAnnotationType();
        if (!genericBeans.containsKey(genericConfigurationType)) {
            throw new IllegalStateException("No generic bean definition exists for " + genericConfigurationType + ", but a generic producer does: " + genericConfigurationHolder.getAnnotated());
        }
        // Add a generic configuration bean for each generic configuration producer (allows us to inject the generic configuration annotation back into the generic bean)
        event.addBean(createGenericConfigurationBean(beanManager, identifier));
        // Register the GenericProduct bean
        event.addBean(createGenericProductAnnotatedMemberBean(beanManager, identifier));
        boolean alternative = genericConfigurationHolder.getAnnotated().isAnnotationPresent(Alternative.class);
        Class<?> javaClass = genericConfigurationHolder.getJavaClass();
        if (genericBeanProducerMethods.containsKey(genericConfigurationType)) {
            for (ProducerMethodHolder<?, ?> holder : genericBeanProducerMethods.get(genericConfigurationType)) {
                Class<? extends Annotation> scopeOverride = null;
                if (holder.getProducerMethod().isAnnotationPresent(ApplyScope.class)) {
                    scopeOverride = producerScope;
                }
                event.addBean(createGenericProducerMethod(holder, identifier, beanManager, scopeOverride, alternative, javaClass));
            }
        }
        if (genericBeanProducerFields.containsKey(genericConfigurationType)) {
            for (FieldHolder<?, ?> holder : genericBeanProducerFields.get(genericConfigurationType)) {
                Class<? extends Annotation> scopeOverride = null;
                if (holder.getField().isAnnotationPresent(ApplyScope.class)) {
                    scopeOverride = producerScope;
                }
                event.addBean(createGenericProducerField(holder.getBean(), identifier, holder.getField(), beanManager, scopeOverride, alternative, javaClass));
            }
        }
        if (genericBeanObserverMethods.containsKey(genericConfigurationType)) {
            for (ObserverMethodHolder<?, ?> holder : genericBeanObserverMethods.get(genericConfigurationType)) {
                event.addObserverMethod(createGenericObserverMethod(holder.getObserverMethod(), identifier, holder.getMethod(), null, beanManager));
            }
        }
        if (unwrapsMethods.containsKey(genericConfigurationType)) {
            for (AnnotatedMethod<?> i : unwrapsMethods.get(genericConfigurationType)) {
                Annotated annotated = genericConfigurationHolder.getAnnotated();
                Set<Annotation> unwrapsQualifiers = Beans.getQualifiers(beanManager, i.getAnnotations(), annotated.getAnnotations());
                if (unwrapsQualifiers.isEmpty()) {
                    unwrapsQualifiers.add(DefaultLiteral.INSTANCE);
                }
                Set<Annotation> beanQualifiers = Beans.getQualifiers(beanManager, i.getDeclaringType().getAnnotations(), annotated.getAnnotations());
                beanQualifiers.remove(AnyLiteral.INSTANCE);
                if (beanQualifiers.isEmpty()) {
                    beanQualifiers.add(DefaultLiteral.INSTANCE);
                }
                beanQualifiers.remove(genericBeanQualifier);
                event.addBean(new UnwrapsProducerBean(i, unwrapsQualifiers, beanQualifiers, beanManager));
            }
        }
        // For each generic bean that uses this genericConfigurationType, register a generic bean for this generic configuration
        for (BeanHolder<?> genericBeanHolder : genericBeans.get(genericConfigurationType)) {
            // Register the generic bean, this is the underlying definition, with the synthetic qualifier
            Class<? extends Annotation> scopeOverride = null;
            if (genericBeanHolder.getType().isAnnotationPresent(ApplyScope.class)) {
                scopeOverride = producerScope;
            }
            Bean<?> genericBean = createGenericBean(genericBeanHolder, identifier, beanManager, scopeOverride, alternative, javaClass);
            event.addBean(genericBean);
        }
    }
}

@Produces
@Alternative
public AuthenticationService authenticationService() {
    return new AuthenticationService() {

        boolean isLoggedIn = false;

        User user;

        @Override
        public User login(String username, String password) {
            isLoggedIn = true;
            user = new UserImpl(username);
            return user;
        }

        @Override
        public boolean isLoggedIn() {
            return false;
        }

        @Override
        public void logout() {
            user = null;
            isLoggedIn = false;
        }

        @Override
        public User getUser() {
            return user;
        }
    };
}

@SuppressWarnings("unchecked")
@Override
public void visitEnd() {
    if (!_ignore && _annotations.size() > 0 && !_annotations.containsKey("javax.enterprise.inject.Alternative")) {
        for (ScannerFeature listener : _features) {
            listener.found((Class<Object>) _class, _annotations);
        }
    }
    _name = null;
    _class = null;
    _ignore = false;
    _annotations.clear();
}

/**
     * Activates the alternatives declared with {@code @Beans} globally for the
     * application.
     * <p/>
     * For every types and every methods of every types declared with
     * {@link Beans#alternatives()}, the {@code Priority} annotation is added
     * so that the corresponding alternatives are selected globally for the
     * entire application.
     *
     * @see Beans
     */
private <T> void alternatives(@Observes @WithAnnotations(Alternative.class) ProcessAnnotatedType<T> pat) {
    AnnotatedType<T> type = pat.getAnnotatedType();
    if (!Arrays.asList(beans.alternatives()).contains(type.getJavaClass())) {
        // Only select globally the alternatives that are declared with @Beans
        return;
    }
    Set<AnnotatedMethod<? super T>> methods = new HashSet<>();
    for (AnnotatedMethod<? super T> method : type.getMethods()) {
        if (method.isAnnotationPresent(Alternative.class) && !method.isAnnotationPresent(Priority.class)) {
            methods.add(new AnnotatedMethodDecorator<>(method, PriorityLiteral.of(APPLICATION)));
        }
    }
    if (type.isAnnotationPresent(Alternative.class) && !type.isAnnotationPresent(Priority.class)) {
        pat.setAnnotatedType(new AnnotatedTypeDecorator<>(type, PriorityLiteral.of(APPLICATION), methods));
    } else if (!methods.isEmpty()) {
        pat.setAnnotatedType(new AnnotatedTypeDecorator<>(type, methods));
    }
}

private void activateGlobalAlternatives(ProcessAnnotatedType processAnnotatedType, BeanManager beanManager) {
    Class<Object> currentBean = processAnnotatedType.getAnnotatedType().getJavaClass();
    if (currentBean.isInterface()) {
        return;
    }
    Set<Class> beanBaseTypes = resolveBeanTypes(currentBean);
    boolean isAlternativeBeanImplementation = currentBean.isAnnotationPresent(Alternative.class);
    List<Annotation> qualifiersOfCurrentBean = resolveQualifiers(processAnnotatedType.getAnnotatedType().getAnnotations(), beanManager);
    String configuredBeanName;
    List<Annotation> qualifiersOfConfiguredBean;
    Class<Object> alternativeBeanClass;
    Set<Annotation> alternativeBeanAnnotations;
    for (Class currentType : beanBaseTypes) {
        alternativeBeanAnnotations = new HashSet<Annotation>();
        configuredBeanName = globalAlternatives.get(currentType.getName());
        if (configuredBeanName != null && configuredBeanName.length() > 0) {
            alternativeBeanClass = ClassUtils.tryToLoadClassForName(configuredBeanName);
            if (alternativeBeanClass == null) {
                throw new IllegalStateException("Can't find class " + configuredBeanName + " which is configured" + " for " + currentType.getName());
            }
            //check that the configured class is an alternative
            if (!alternativeBeanClass.isAnnotationPresent(Alternative.class)) {
                //we have to continue because other classes can be configured as well
                continue;
            }
            alternativeBeanAnnotations.addAll(Arrays.asList(alternativeBeanClass.getAnnotations()));
            qualifiersOfConfiguredBean = resolveQualifiers(alternativeBeanAnnotations, beanManager);
        } else {
            continue;
        }
        if (!doQualifiersMatch(qualifiersOfCurrentBean, qualifiersOfConfiguredBean)) {
            continue;
        }
        //current bean is annotated with @Alternative and of the same type as the configured bean
        if (isAlternativeBeanImplementation && alternativeBeanClass.equals(currentBean)) {
            LOG.info(processAnnotatedType.getAnnotatedType().getJavaClass().getName() + " is configured as global-alternative");
            //cdi 1.0
            if (priorityAnnotationInstance == null) {
                AnnotatedTypeBuilder<Object> annotatedTypeBuilder = new AnnotatedTypeBuilder<Object>().readFromType(processAnnotatedType.getAnnotatedType());
                annotatedTypeBuilder.removeFromClass(Alternative.class);
                processAnnotatedType.setAnnotatedType(annotatedTypeBuilder.create());
                return;
            } else //cdi 1.1+
            {
                AnnotatedTypeBuilder<Object> annotatedTypeBuilder = new AnnotatedTypeBuilder<Object>().readFromType(processAnnotatedType.getAnnotatedType());
                annotatedTypeBuilder.addToClass(priorityAnnotationInstance);
                processAnnotatedType.setAnnotatedType(annotatedTypeBuilder.create());
                return;
            }
        } else //current bean is the original implementation
        {
            //cdi 1.0 (no change needed with cdi 1.1+)
            if (priorityAnnotationInstance == null) {
                //veto this original implementation because the alternative will be added
                processAnnotatedType.veto();
                return;
            }
        }
    }
}

private void createStereotype(String beanstestPackage, String stereotype) throws FileNotFoundException {
    //        @Stereotype
    //        @Alternative
    //        @Target(ElementType.METHOD)
    //        @Retention(RetentionPolicy.RUNTIME)
    //        public @interface BeanstestAlternative {
    //        }
    //TODO how do i create a nested annotation with Forge ?
    JavaResource stereotypeResource = getStereotype(stereotype);
    if (!stereotypeResource.exists()) {
        JavaAnnotation javaAnnotation = JavaParser.create(JavaAnnotation.class);
        javaAnnotation.setName(stereotype);
        javaAnnotation.setPackage(beanstestPackage);
        javaAnnotation.addAnnotation(Stereotype.class);
        javaAnnotation.addAnnotation(Alternative.class);
        javaAnnotation.addAnnotation(Target.class).setEnumValue(ElementType.METHOD);
        javaAnnotation.addAnnotation(Retention.class).setEnumValue(RetentionPolicy.RUNTIME);
        stereotypeResource.setContents(javaAnnotation);
        BeansDescriptor beansDescriptor = project.getFacet(CDITestFacet.class).getConfig();
        if (!beansDescriptor.getAlternativeStereotypes().contains(javaAnnotation.getCanonicalName())) {
            beansDescriptor.alternativeStereotype(javaAnnotation.getCanonicalName());
            project.getFacet(CDITestFacet.class).saveConfig(beansDescriptor);
        }
    }
}

@SuppressWarnings("unchecked")
@Override
public void scan(final Object cls) {
    ClassFile classFile = (ClassFile) cls;
    AnnotationsAttribute annotationsAttribute = (AnnotationsAttribute) classFile.getAttribute(AnnotationsAttribute.visibleTag);
    if (annotationsAttribute == null) {
        return;
    }
    Class<Object> objectClass;
    try {
        objectClass = (Class<Object>) Class.forName(classFile.getName(), true, Thread.currentThread().getContextClassLoader());
    } catch (ClassNotFoundException e) {
        ReflectionsScanner.this._logger.log(Level.WARNING, "Failure while trying to load the Class \"" + classFile.getName() + "\" from Classpath.", e);
        return;
    }
    Map<String, java.lang.annotation.Annotation> map = new HashMap<String, java.lang.annotation.Annotation>();
    for (Annotation annotation : annotationsAttribute.getAnnotations()) {
        Class<java.lang.annotation.Annotation> annotationClass;
        try {
            annotationClass = (Class<java.lang.annotation.Annotation>) Class.forName(annotation.getTypeName());
            map.put(annotationClass.getName(), objectClass.getAnnotation(annotationClass));
        } catch (ClassNotFoundException e) {
            ReflectionsScanner.this._logger.log(Level.WARNING, "Failure while trying to load the Annotations from Classpath.", e);
            continue;
        }
    }
    if (map.containsKey("javax.enterprise.inject.Alternative")) {
        return;
    }
    for (ScannerFeature feature : features) {
        feature.found(objectClass, map);
    }
}

@Test
public void testAlternativeOpenOn() {
    /* open on bean class */
    new DefaultStyledText().selectText("s:Alternative");
    KeyboardFactory.getKeyboard().invokeKeyCombination(SWT.F3);
    new DefaultEditor("Alternative.class");
    /* test opened object */
    assertExpectedOpenedClass("javax.enterprise.inject.Alternative");
}

public BeansDef alternativeClasses(Class<?>... classes) {
    for (Class<?> c : classes) {
        // FIXME this validation needs to be thorough
        if (!c.isAnnotationPresent(Alternative.class)) {
            throw new IllegalArgumentException("Class is not an alternative");
        }
        beans.getAlternatives().getClasses().add(c.getName());
    }
    return this;
}

private BeanBuilder<Object> readFromMember(BeanBuilder<Object> beanBuilder, AnnotatedMember<Object> annotatedMember, Bean<Object> bean, boolean isOwbBug) {
    // Init the qualifiers set
    beanBuilder.qualifiers();
    Set<Class<? extends Annotation>> stereotypes = new HashSet<Class<? extends Annotation>>();
    for (Annotation annotation : annotatedMember.getAnnotations()) {
        if (beanBuilder.getBeanManager().isQualifier(annotation.annotationType())) {
            beanBuilder.addQualifier(annotation);
        } else if (beanBuilder.getBeanManager().isScope(annotation.annotationType())) {
            beanBuilder.scope(annotation.annotationType());
        } else if (beanBuilder.getBeanManager().isStereotype(annotation.annotationType())) {
            stereotypes.add(annotation.annotationType());
        }
        if (annotation instanceof Named) {
            beanBuilder.name(((Named) annotation).value());
        }
        if (annotation instanceof Alternative) {
            beanBuilder.alternative(true);
        }
    }
    beanBuilder.stereotypes(stereotypes);
    if (beanBuilder.getScope() == null) {
        beanBuilder.scope(Dependent.class);
    }
    boolean isDependent = beanBuilder.getScope() == Dependent.class;
    Class<?> declaringClass = annotatedMember.getDeclaringType().getJavaClass();
    if (annotatedMember instanceof AnnotatedField<?>) {
        AnnotatedField<Object> annotatedField = (AnnotatedField<Object>) annotatedMember;
        Field field = annotatedField.getJavaMember();
        Class<?> rawType = ReflectionUtils.getResolvedFieldType(declaringClass, field);
        beanBuilder.beanClass(rawType);
        beanBuilder.beanLifecycle(new ProducerFieldCreationalContext(bean, annotatedField, beanBuilder.getBeanManager()));
    } else {
        AnnotatedMethod<Object> annotatedMethod = (AnnotatedMethod<Object>) annotatedMember;
        Method method = annotatedMethod.getJavaMember();
        Class<?> rawType = ReflectionUtils.getResolvedMethodReturnType(declaringClass, method);
        beanBuilder.beanClass(rawType);
        ProducerMethodCreationalContext ctx = new ProducerMethodCreationalContext(bean, annotatedMethod, beanBuilder.getBeanManager(), isDependent && isOwbBug);
        beanBuilder.beanLifecycle(ctx);
        beanBuilder.injectionPoints(ctx.getInjectionPoints());
    }
    beanBuilder.types(annotatedMember.getTypeClosure());
    if (beanBuilder.getQualifiers().isEmpty()) {
        beanBuilder.addQualifier(new DefaultLiteral());
    }
    beanBuilder.addQualifier(new AnyLiteral());
    return beanBuilder;
}

public int getDeploymentPriority(Bean<?> bean) {
    int priority = DEFAULT_PRIORITY;
    Set<Class<? extends Annotation>> stereotypes = bean.getStereotypes();
    if (bean.isAlternative()) {
        priority = -1;
        Integer value = _deploymentMap.get(bean.getBeanClass());
        if (value != null)
            priority = value;
    }
    if (stereotypes != null) {
        for (Class<? extends Annotation> annType : stereotypes) {
            Integer value = _deploymentMap.get(annType);
            if (value != null) {
                if (priority < value)
                    priority = value;
            } else if (annType.isAnnotationPresent(Alternative.class) && priority == DEFAULT_PRIORITY)
                priority = -1;
        }
    }
    if (priority < 0)
        return priority;
    else if (bean instanceof AbstractBean<?>) {
        // ioc/0213
        AbstractBean<?> absBean = (AbstractBean<?>) bean;
        if (absBean.getBeanManager() == this)
            priority += 1000000;
    } else
        priority += 1000000;
    return priority;
}

public int getDeploymentPriority(Bean<?> bean) {
    int priority = DEFAULT_PRIORITY;
    if (bean.isAlternative()) {
        priority = -1;
        Integer value = getPriority(bean.getBeanClass());
        if (value != null)
            priority = value;
    }
    Set<Class<? extends Annotation>> stereotypes = bean.getStereotypes();
    if (stereotypes != null) {
        for (Class<? extends Annotation> annType : stereotypes) {
            Integer value = _deploymentMap.get(annType);
            if (value != null) {
                if (priority < value)
                    priority = value;
            } else if (annType.isAnnotationPresent(Alternative.class) && priority == DEFAULT_PRIORITY)
                priority = -1;
        }
    }
    if (priority < 0)
        return priority;
    else if (bean instanceof AbstractBean<?>) {
        // ioc/0213
        AbstractBean<?> absBean = (AbstractBean<?>) bean;
        if (absBean.getBeanManager() == this)
            priority += 1000000;
    } else
        priority += 1000000;
    return priority;
}

void createGenericBeans(@Observes AfterBeanDiscovery event, BeanManager beanManager) {
    beanDiscoveryOver = true;
    // For each generic configuration type, we iterate the generic configurations
    for (Entry<GenericIdentifier, GenericConfigurationHolder> genericConfigurationEntry : genericConfigurationPoints.entrySet()) {
        Class<? extends Annotation> producerScope = Dependent.class;
        for (Annotation annotation : genericConfigurationEntry.getValue().getAnnotated().getAnnotations()) {
            if (beanManager.isScope(annotation.annotationType())) {
                producerScope = annotation.annotationType();
            }
        }
        GenericConfigurationHolder genericConfigurationHolder = genericConfigurationEntry.getValue();
        GenericIdentifier identifier = genericConfigurationEntry.getKey();
        Class<? extends Annotation> genericConfigurationType = identifier.getAnnotationType();
        if (!genericBeans.containsKey(genericConfigurationType)) {
            throw new IllegalStateException("No generic bean definition exists for " + genericConfigurationType + ", but a generic producer does: " + genericConfigurationHolder.getAnnotated());
        }
        // Add a generic configuration bean for each generic configuration producer (allows us to inject the generic configuration annotation back into the generic bean)
        event.addBean(createGenericConfigurationBean(beanManager, identifier));
        // Register the GenericProduct bean
        event.addBean(createGenericProductAnnotatedMemberBean(beanManager, identifier));
        boolean alternative = genericConfigurationHolder.getAnnotated().isAnnotationPresent(Alternative.class);
        Class<?> javaClass = genericConfigurationHolder.getJavaClass();
        if (genericBeanProducerMethods.containsKey(genericConfigurationType)) {
            for (ProducerMethodHolder<?, ?> holder : genericBeanProducerMethods.get(genericConfigurationType)) {
                Class<? extends Annotation> scopeOverride = null;
                if (holder.getProducerMethod().isAnnotationPresent(ApplyScope.class)) {
                    scopeOverride = producerScope;
                }
                event.addBean(createGenericProducerMethod(holder, identifier, beanManager, scopeOverride, alternative, javaClass));
            }
        }
        if (genericBeanProducerFields.containsKey(genericConfigurationType)) {
            for (FieldHolder<?, ?> holder : genericBeanProducerFields.get(genericConfigurationType)) {
                Class<? extends Annotation> scopeOverride = null;
                if (holder.getField().isAnnotationPresent(ApplyScope.class)) {
                    scopeOverride = producerScope;
                }
                event.addBean(createGenericProducerField(holder.getBean(), identifier, holder.getField(), beanManager, scopeOverride, alternative, javaClass));
            }
        }
        if (genericBeanObserverMethods.containsKey(genericConfigurationType)) {
            for (ObserverMethodHolder<?, ?> holder : genericBeanObserverMethods.get(genericConfigurationType)) {
                event.addObserverMethod(createGenericObserverMethod(holder.getObserverMethod(), identifier, holder.getMethod(), null, beanManager));
            }
        }
        if (unwrapsMethods.containsKey(genericConfigurationType)) {
            for (AnnotatedMethod<?> i : unwrapsMethods.get(genericConfigurationType)) {
                Annotated annotated = genericConfigurationHolder.getAnnotated();
                Set<Annotation> unwrapsQualifiers = Beans.getQualifiers(beanManager, i.getAnnotations(), annotated.getAnnotations());
                if (unwrapsQualifiers.isEmpty()) {
                    unwrapsQualifiers.add(DefaultLiteral.INSTANCE);
                }
                Set<Annotation> beanQualifiers = Beans.getQualifiers(beanManager, i.getDeclaringType().getAnnotations(), annotated.getAnnotations());
                beanQualifiers.remove(AnyLiteral.INSTANCE);
                if (beanQualifiers.isEmpty()) {
                    beanQualifiers.add(DefaultLiteral.INSTANCE);
                }
                beanQualifiers.remove(genericBeanQualifier);
                event.addBean(new UnwrapsProducerBean(i, unwrapsQualifiers, beanQualifiers, beanManager));
            }
        }
        // For each generic bean that uses this genericConfigurationType, register a generic bean for this generic configuration
        for (BeanHolder<?> genericBeanHolder : genericBeans.get(genericConfigurationType)) {
            // Register the generic bean, this is the underlying definition, with the synthetic qualifier
            Class<? extends Annotation> scopeOverride = null;
            if (genericBeanHolder.getType().isAnnotationPresent(ApplyScope.class)) {
                scopeOverride = producerScope;
            }
            Bean<?> genericBean = createGenericBean(genericBeanHolder, identifier, beanManager, scopeOverride, alternative, javaClass);
            event.addBean(genericBean);
        }
    }
}

void createGenericBeans(@Observes AfterBeanDiscovery event, BeanManager beanManager) {
    // For each generic configuration type, we iterate the generic configurations
    for (Entry<Annotation, ProducerHolder<?, ?>> genericConfigurationEntry : genericProducers.entrySet()) {
        Class<? extends Annotation> producerScope = Dependent.class;
        for (Annotation annotation : genericConfigurationEntry.getValue().getMember().getAnnotations()) {
            if (beanManager.isScope(annotation.annotationType())) {
                producerScope = annotation.annotationType();
            }
        }
        ProducerHolder<?, ?> producerHolder = genericConfigurationEntry.getValue();
        Annotation genericConfiguration = genericConfigurationEntry.getKey();
        Set<Annotation> qualifiers = new HashSet<Annotation>();
        qualifiers.addAll(Beans.getQualifiers(beanManager, genericConfigurationEntry.getValue().getMember().getAnnotations()));
        if (qualifiers.isEmpty()) {
            qualifiers.add(DefaultLiteral.INSTANCE);
        }
        Class<? extends Annotation> genericConfigurationType = genericConfiguration.annotationType();
        if (!genericBeans.containsKey(genericConfigurationType)) {
            throw new IllegalStateException("No generic bean definition exists for " + genericConfigurationType + ", but a generic producer does: " + producerHolder.getMember());
        }
        // Add a generic configuration bean for each generic configuration producer (allows us to inject the generic configuration annotation back into the generic bean)
        event.addBean(createGenericConfigurationBean(beanManager, genericConfiguration, qualifiers));
        // Register the GenericProduct bean
        event.addBean(createGenericProductAnnotatedMemberBean(beanManager, genericConfiguration, qualifiers));
        boolean alternative = producerHolder.getMember().isAnnotationPresent(Alternative.class);
        Class<?> javaClass = producerHolder.getMember().getDeclaringType().getJavaClass();
        if (genericBeanProducerMethods.containsKey(genericConfigurationType)) {
            for (ProducerMethodHolder<?, ?> holder : genericBeanProducerMethods.get(genericConfigurationType)) {
                Class<? extends Annotation> scopeOverride = null;
                if (holder.getProducerMethod().isAnnotationPresent(ApplyScope.class)) {
                    scopeOverride = producerScope;
                }
                event.addBean(createGenericProducerMethod(holder, genericConfiguration, beanManager, scopeOverride, alternative, javaClass));
            }
        }
        if (genericBeanProducerFields.containsKey(genericConfigurationType)) {
            for (FieldHolder<?, ?> holder : genericBeanProducerFields.get(genericConfigurationType)) {
                Class<? extends Annotation> scopeOverride = null;
                if (holder.getField().isAnnotationPresent(ApplyScope.class)) {
                    scopeOverride = producerScope;
                }
                event.addBean(createGenericProducerField(holder.getBean(), genericConfiguration, holder.getField(), beanManager, scopeOverride, alternative, javaClass));
            }
        }
        if (genericBeanObserverMethods.containsKey(genericConfigurationType)) {
            for (ObserverMethodHolder<?, ?> holder : genericBeanObserverMethods.get(genericConfigurationType)) {
                event.addObserverMethod(createGenericObserverMethod(holder.getObserverMethod(), genericConfiguration, holder.getMethod(), null, beanManager));
            }
        }
        if (unwrapsMethods.containsKey(genericConfigurationType)) {
            for (AnnotatedMethod<?> i : unwrapsMethods.get(genericConfigurationType)) {
                AnnotatedMember<?> member = producerHolder.getMember();
                Set<Annotation> unwrapsQualifiers = Beans.getQualifiers(beanManager, i.getAnnotations(), member.getAnnotations());
                if (unwrapsQualifiers.isEmpty()) {
                    unwrapsQualifiers.add(DefaultLiteral.INSTANCE);
                }
                Set<Annotation> beanQualifiers = Beans.getQualifiers(beanManager, i.getDeclaringType().getAnnotations(), member.getAnnotations());
                beanQualifiers.remove(AnyLiteral.INSTANCE);
                if (beanQualifiers.isEmpty()) {
                    beanQualifiers.add(DefaultLiteral.INSTANCE);
                }
                beanQualifiers.remove(genericBeanQualifier);
                event.addBean(new UnwrapsProducerBean(i, unwrapsQualifiers, beanQualifiers, beanManager));
            }
        }
        // For each generic bean that uses this genericConfigurationType, register a generic bean for this generic configuration 
        for (BeanHolder<?> genericBeanHolder : genericBeans.get(genericConfigurationType)) {
            // Register the generic bean, this is the underlying definition, with the synthetic qualifier
            Class<? extends Annotation> scopeOverride = null;
            if (genericBeanHolder.getType().isAnnotationPresent(ApplyScope.class)) {
                scopeOverride = producerScope;
            }
            Bean<?> genericBean = createGenericBean(genericBeanHolder, genericConfiguration, beanManager, scopeOverride, alternative, javaClass);
            event.addBean(genericBean);
        }
    }
}

private WiringElementType[] getWiringTypes(final MetaClass type, final Class<? extends Annotation> directScope) {
    final List<WiringElementType> wiringTypes = new ArrayList<>();
    wiringTypes.addAll(getWiringTypesForScopeAnnotation(directScope));
    if (type.isAnnotationPresent(Alternative.class)) {
        wiringTypes.add(WiringElementType.AlternativeBean);
    }
    if (isPublishableJsType(type)) {
        wiringTypes.add(WiringElementType.JsType);
    }
    if (type.isAnnotationPresent(SharedSingleton.class)) {
        wiringTypes.add(WiringElementType.SharedSingleton);
    }
    if (type.isAnnotationPresent(Specializes.class)) {
        wiringTypes.add(WiringElementType.Specialization);
    }
    if (type.isAnnotationPresent(LoadAsync.class)) {
        wiringTypes.add(WiringElementType.LoadAsync);
    }
    return wiringTypes.toArray(new WiringElementType[wiringTypes.size()]);
}

/**
    * <p>
    * Read the {@link AnnotatedType}, creating a bean from the class and it's annotations.
    * </p>
    * <p/>
    * <p>
    * By default the bean lifecycle will wrap the result of calling
    * {@link BeanManager#createInjectionTarget(AnnotatedType)}.
    * </p>
    * <p/>
    * <p>
    * {@link BeanBuilder} does <em>not</em> support reading members of the class to create producers or observer
    * methods.
    * </p>
    * 
    * @param type the type to read
    */
public BeanBuilder<T> readFromType(AnnotatedType<T> type) {
    this.beanClass = type.getJavaClass();
    InjectionTarget<T> injectionTarget;
    if (!type.getJavaClass().isInterface()) {
        injectionTarget = beanManager.createInjectionTarget(type);
    } else {
        injectionTarget = new DummyInjectionTarget<>();
    }
    this.beanLifecycle = new DelegatingContextualLifecycle<>(injectionTarget);
    this.injectionPoints = injectionTarget.getInjectionPoints();
    this.qualifiers = new HashSet<>();
    this.stereotypes = new HashSet<>();
    this.types = new HashSet<>();
    for (Annotation annotation : type.getAnnotations()) {
        if (beanManager.isQualifier(annotation.annotationType())) {
            this.qualifiers.add(annotation);
        } else if (beanManager.isScope(annotation.annotationType())) {
            this.scope = annotation.annotationType();
        } else if (beanManager.isStereotype(annotation.annotationType())) {
            this.stereotypes.add(annotation.annotationType());
        }
        if (annotation instanceof Named) {
            this.name = ((Named) annotation).value();
        }
        if (annotation instanceof Alternative) {
            this.alternative = true;
        }
    }
    if (this.scope == null) {
        this.scope = Dependent.class;
    }
    for (Class<?> c = type.getJavaClass(); c != Object.class && c != null; c = c.getSuperclass()) {
        this.types.add(c);
    }
    for (Class<?> i : type.getJavaClass().getInterfaces()) {
        this.types.add(i);
    }
    if (qualifiers.isEmpty()) {
        qualifiers.add(DefaultLiteral.INSTANCE);
    }
    qualifiers.add(AnyLiteral.INSTANCE);
    this.id = ImmutableBeanWrapper.class.getName() + ":" + Annotateds.createTypeId(type);
    return this;
}

/**
     * <p>
     * Read the {@link AnnotatedType}, creating a bean from the class and it's
     * annotations.
     * </p>
     * <p/>
     * <p>
     * By default the bean lifecycle will wrap the result of calling
     * {@link BeanManager#createInjectionTarget(AnnotatedType)}.
     * </p>
     * <p/>
     * <p>
     * {@link BeanBuilder} does <em>not</em> support reading members of the class
     * to create producers or observer methods.
     * </p>
     *
     * @param type the type to read
     */
public BeanBuilder<T> readFromType(AnnotatedType<T> type) {
    this.beanClass = type.getJavaClass();
    InjectionTarget<T> injectionTarget;
    if (!type.getJavaClass().isInterface()) {
        injectionTarget = beanManager.createInjectionTarget(type);
    } else {
        injectionTarget = new DummyInjectionTarget<T>();
    }
    this.beanLifecycle = new DelegatingContextualLifecycle<T>(injectionTarget);
    this.injectionPoints = injectionTarget.getInjectionPoints();
    this.qualifiers = new HashSet<Annotation>();
    this.stereotypes = new HashSet<Class<? extends Annotation>>();
    for (Annotation annotation : type.getAnnotations()) {
        if (beanManager.isQualifier(annotation.annotationType())) {
            this.qualifiers.add(annotation);
        } else if (beanManager.isScope(annotation.annotationType())) {
            this.scope = annotation.annotationType();
        } else if (beanManager.isStereotype(annotation.annotationType())) {
            this.stereotypes.add(annotation.annotationType());
        }
        if (annotation instanceof Named) {
            this.name = ((Named) annotation).value();
        }
        if (annotation instanceof Alternative) {
            this.alternative = true;
        }
    }
    if (this.scope == null) {
        this.scope = Dependent.class;
    }
    for (Class<?> c = type.getJavaClass(); c != Object.class && c != null; c = c.getSuperclass()) {
        this.types.add(c);
    }
    for (Class<?> i : type.getJavaClass().getInterfaces()) {
        this.types.add(i);
    }
    if (qualifiers.isEmpty()) {
        qualifiers.add(DefaultLiteral.INSTANCE);
    }
    qualifiers.add(AnyLiteral.INSTANCE);
    this.id = ImmutableBean.class.getName() + ":" + Annotateds.createTypeId(type);
    return this;
}

void createGenericBeans(@Observes AfterBeanDiscovery event, BeanManager beanManager) {
    beanDiscoveryOver = true;
    // For each generic configuration type, we iterate the generic configurations
    for (Entry<GenericIdentifier, GenericConfigurationHolder> genericConfigurationEntry : genericConfigurationPoints.entrySet()) {
        Class<? extends Annotation> producerScope = Dependent.class;
        for (Annotation annotation : genericConfigurationEntry.getValue().getAnnotated().getAnnotations()) {
            if (beanManager.isScope(annotation.annotationType())) {
                producerScope = annotation.annotationType();
            }
        }
        GenericConfigurationHolder genericConfigurationHolder = genericConfigurationEntry.getValue();
        GenericIdentifier identifier = genericConfigurationEntry.getKey();
        Class<? extends Annotation> genericConfigurationType = identifier.getAnnotationType();
        if (!genericBeans.containsKey(genericConfigurationType)) {
            throw new IllegalStateException("No generic bean definition exists for " + genericConfigurationType + ", but a generic producer does: " + genericConfigurationHolder.getAnnotated());
        }
        // Add a generic configuration bean for each generic configuration producer (allows us to inject the generic configuration annotation back into the generic bean)
        event.addBean(createGenericConfigurationBean(beanManager, identifier));
        // Register the GenericProduct bean
        event.addBean(createGenericProductAnnotatedMemberBean(beanManager, identifier));
        boolean alternative = genericConfigurationHolder.getAnnotated().isAnnotationPresent(Alternative.class);
        Class<?> javaClass = genericConfigurationHolder.getJavaClass();
        if (genericBeanProducerMethods.containsKey(genericConfigurationType)) {
            for (ProducerMethodHolder<?, ?> holder : genericBeanProducerMethods.get(genericConfigurationType)) {
                Class<? extends Annotation> scopeOverride = null;
                if (holder.getProducerMethod().isAnnotationPresent(ApplyScope.class)) {
                    scopeOverride = producerScope;
                }
                event.addBean(createGenericProducerMethod(holder, identifier, beanManager, scopeOverride, alternative, javaClass));
            }
        }
        if (genericBeanProducerFields.containsKey(genericConfigurationType)) {
            for (FieldHolder<?, ?> holder : genericBeanProducerFields.get(genericConfigurationType)) {
                Class<? extends Annotation> scopeOverride = null;
                if (holder.getField().isAnnotationPresent(ApplyScope.class)) {
                    scopeOverride = producerScope;
                }
                event.addBean(createGenericProducerField(holder.getBean(), identifier, holder.getField(), beanManager, scopeOverride, alternative, javaClass));
            }
        }
        if (genericBeanObserverMethods.containsKey(genericConfigurationType)) {
            for (ObserverMethodHolder<?, ?> holder : genericBeanObserverMethods.get(genericConfigurationType)) {
                event.addObserverMethod(createGenericObserverMethod(holder.getObserverMethod(), identifier, holder.getMethod(), null, beanManager));
            }
        }
        if (unwrapsMethods.containsKey(genericConfigurationType)) {
            for (AnnotatedMethod<?> i : unwrapsMethods.get(genericConfigurationType)) {
                Annotated annotated = genericConfigurationHolder.getAnnotated();
                Set<Annotation> unwrapsQualifiers = Beans.getQualifiers(beanManager, i.getAnnotations(), annotated.getAnnotations());
                if (unwrapsQualifiers.isEmpty()) {
                    unwrapsQualifiers.add(DefaultLiteral.INSTANCE);
                }
                Set<Annotation> beanQualifiers = Beans.getQualifiers(beanManager, i.getDeclaringType().getAnnotations(), annotated.getAnnotations());
                beanQualifiers.remove(AnyLiteral.INSTANCE);
                if (beanQualifiers.isEmpty()) {
                    beanQualifiers.add(DefaultLiteral.INSTANCE);
                }
                beanQualifiers.remove(genericBeanQualifier);
                event.addBean(new UnwrapsProducerBean(i, unwrapsQualifiers, beanQualifiers, beanManager));
            }
        }
        // For each generic bean that uses this genericConfigurationType, register a generic bean for this generic configuration
        for (BeanHolder<?> genericBeanHolder : genericBeans.get(genericConfigurationType)) {
            // Register the generic bean, this is the underlying definition, with the synthetic qualifier
            Class<? extends Annotation> scopeOverride = null;
            if (genericBeanHolder.getType().isAnnotationPresent(ApplyScope.class)) {
                scopeOverride = producerScope;
            }
            Bean<?> genericBean = createGenericBean(genericBeanHolder, identifier, beanManager, scopeOverride, alternative, javaClass);
            event.addBean(genericBean);
        }
    }
}

private boolean isAlternativeCandidate(Class<?> enabledClass, BeanManagerImpl beanManager) {
    // <class> exists and is annotated with @Alternative or alternative stereotype
    if (isAlternativeOrHasAlternativeStereotype(enabledClass, beanManager)) {
        return true;
    }
    // Intentionally do not process the class hierarchy -
    for (Method declaredMethod : AccessController.doPrivileged(new GetDeclaredMethodsAction(enabledClass))) {
        if (declaredMethod.isAnnotationPresent(Produces.class) && isAlternativeOrHasAlternativeStereotype(declaredMethod, beanManager)) {
            return true;
        }
    }
    for (Field declaredField : AccessController.doPrivileged(new GetDeclaredFieldsAction(enabledClass))) {
        if (declaredField.isAnnotationPresent(Produces.class) && isAlternativeOrHasAlternativeStereotype(declaredField, beanManager)) {
            return true;
        }
    }
    return false;
}

@Override
public void logMessage(String message) {
    System.out.println("Alternative: " + message);
}

@Produces
@Alternative
public Greeting getGreeting() {
    return new SimpleGreeting();
}

@Produces
@Alternative
public Greeting getGreeting() {
    return new SimpleGreeting();
}

@Alternative
@Produces
@Tame
public Bar produceTameBar() {
    return new Bar();
}

@Override
public String ping() {
    return super.ping() + "Alternative";
}

@Produces
@Alternative
public M2RepoService m2RepoService() {
    return mock(M2RepoService.class);
}

@Produces
@Tame
@Alternative
public Cat produce() {
    return cat;
}

@Override
public String testInjection() {
    ALTERNATIVE_BEAN_HAS_BEEN_CALLED = true;
    System.out.println("*************** testinjection in alternative bean in web-inf/lib called");
    return "Alternative";
}

@SuppressWarnings("serial")
@Test
public void testAlternativeLiteral() {
    assertEquals(new AnnotationLiteral<Alternative>() {
    }, Alternative.Literal.INSTANCE);
}

/*
	 * (non-Javadoc)
	 * @see javax.enterprise.inject.spi.Bean#isAlternative()
	 */
public boolean isAlternative() {
    return beanClass.isAnnotationPresent(Alternative.class);
}

private boolean isAlternativeStereotype(Class<?> c) {
    return c.isAnnotationPresent(Stereotype.class) && c.isAnnotationPresent(Alternative.class);
}

/*
	 * (non-Javadoc)
	 * @see javax.enterprise.inject.spi.Bean#isAlternative()
	 */
public boolean isAlternative() {
    return repositoryType.isAnnotationPresent(Alternative.class);
}