* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements. See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership. The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied. See the License for the

* specific language governing permissions and limitations

* under the License.

*/

* Contains some utility methods used in the all project.

*/

    private static final Logger logger = WebBeansLoggerFacade.getLogger(WebBeansUtil.class);

    private final WebBeansContext webBeansContext;

    // cache to skip some validations

    private final ConcurrentMap<Type, Boolean> noTypeVariables = new ConcurrentHashMap<Type, Boolean>();

    private final ConcurrentMap<EventCacheKey, Boolean> validEventType = new ConcurrentHashMap<EventCacheKey, Boolean>();

    private final ConcurrentMap<Type, Boolean> notContainerEvents = new ConcurrentHashMap<Type, Boolean>();

    public WebBeansUtil(WebBeansContext webBeansContext)

    {

        this.webBeansContext = webBeansContext;

    }

    /**

     * Gets current classloader with current thread.

     *

     * @return Current class loader instance

     */

    public static ClassLoader getCurrentClassLoader()

    {

        ClassLoader loader =  Thread.currentThread().getContextClassLoader();

        if (loader == null)

        {

            loader = WebBeansUtil.class.getClassLoader();

        }

        return loader;

    }

    /**

     * Checks the generic type requirements.

     */

    public static void checkGenericType(Class<?> clazz, Class<? extends Annotation> scope)

    {

        Asserts.assertNotNull(clazz);

        if (clazz.getTypeParameters().length > 0)

        {

            if(!scope.equals(Dependent.class))

            {

                throw new WebBeansConfigurationException("Generic type may only defined with scope @Dependent " +

                        "for ManagedBean class : " + clazz.getName());

            }

        }

    }

    /**

     * Check producer method/field bean return type.

     * @param bean producer bean instance

     * @param member related member instance

     */

    public static void checkProducerGenericType(Bean<?> bean,Member member)

    {

        Asserts.assertNotNull(bean,"Bean is null");

        Type type;

        if(bean instanceof ProducerMethodBean)

        {

            type = ((ProducerMethodBean<?>)bean).getCreatorMethod().getGenericReturnType();

        }

        else if(bean instanceof ProducerFieldBean)

        {

            type = ((ProducerFieldBean<?>)bean).getCreatorField().getGenericType();

        }

        else

        {

            throw new IllegalArgumentException("Bean must be Producer Field or Method Bean instance : " + bean);

        }

        String messageTemplate = "Producer Field/Method Bean with name : %s" +

                         " in bean class : %s";

        String memberName = member.getName();

        String declaringClassName = member.getDeclaringClass().getName();

        if(checkGenericForProducers(type, messageTemplate, memberName, declaringClassName))

        {

            if(!bean.getScope().equals(Dependent.class))

            {

                String message = format(messageTemplate, memberName, declaringClassName);

                throw new WebBeansConfigurationException(message + " scope must bee @Dependent");

            }

        }

    }

    /**

     * Check generic types for producer method and fields.

     * @param type generic return type

     * @param messageTemplate error message

     * @return true if parametrized type argument is TypeVariable

     */

    //Helper method

    private static boolean checkGenericForProducers(Type type, String messageTemplate, Object... errorMessageArgs)

    {

        boolean result = false;

        if(type instanceof TypeVariable)

        {

            String message = format(messageTemplate, errorMessageArgs);

            throw new WebBeansConfigurationException(message + " return type can not be type variable");

        }

        if(ClassUtil.isParametrizedType(type))

        {

            Type[] actualTypes = ClassUtil.getActualTypeArguments(type);

            if(actualTypes.length == 0)

            {

                String message = format(messageTemplate, errorMessageArgs);

                throw new WebBeansConfigurationException(message +

                        " return type must define actual type arguments or type variable");

            }

            for(Type actualType : actualTypes)

            {

                if(ClassUtil.isWildCardType(actualType))

                {

                    String message = format(messageTemplate, errorMessageArgs);

                    throw new WebBeansConfigurationException(message +

                            " return type can not define wildcard actual type argument");

                }

                if(ClassUtil.isTypeVariable(actualType))

                {

                    result = true;

                }

            }

        }

        return result;

    }

    /**

     * Returns true if this class can be candidate for simple web bean, false otherwise.

     *

     * @param clazz implementation class

     * @throws WebBeansConfigurationException if any configuration exception occurs

     */

    public void checkManagedBean(Class<?> clazz)

    {

        Asserts.nullCheckForClass(clazz, "Class is null");

        int modifier = clazz.getModifiers();

        if (!Modifier.isStatic(modifier) && ClassUtil.isInnerClazz(clazz))

        {

            throw new WebBeansConfigurationException("Skipping CDI bean detection for non-static inner class: "

                                                     + clazz.getName() );

        }

        if(Extension.class.isAssignableFrom(clazz))

        {

            throw new WebBeansConfigurationException("Skipping CDI bean detection for CDI Extension class"

                                                     + clazz.getName());

        }

        // and finally call all checks which are defined in plugins like JSF, JPA, etc

        List<OpenWebBeansPlugin> plugins = webBeansContext.getPluginLoader().getPlugins();

        for (OpenWebBeansPlugin plugin : plugins)

        {

            try

            {

                plugin.isManagedBean(clazz);

            }

            catch (Exception e)

            {

                PluginLoader.throwsException(e);

            }

        }

    }

    public void checkManagedBeanCondition(Class<?> clazz) throws WebBeansConfigurationException

    {

        if (AnnotationUtil.hasClassAnnotation(clazz, Decorator.class) && AnnotationUtil.hasClassAnnotation(clazz, javax.interceptor.Interceptor.class))

        {

            throw new WebBeansConfigurationException("ManagedBean implementation class : " + clazz.getName()

                                                     + " may not annotated with both @Interceptor and @Decorator annotation");

        }

        if (!AnnotationUtil.hasClassAnnotation(clazz, Decorator.class) && !AnnotationUtil.hasClassAnnotation(clazz, javax.interceptor.Interceptor.class))

        {

            webBeansContext.getInterceptorUtil().checkSimpleWebBeansInterceptorConditions(clazz);

        }

    }

    /**

     * Returns true if given class supports injections,

     * false otherwise.

     * <p>

     * Each plugin is asked with given class that supports

     * injections or not.

     * </p>

     * @param clazz scanned class

     * @return  true if given class supports injections

     */

    public boolean supportsJavaEeComponentInjections(Class<?> clazz)

    {

        if (clazz.isInterface() || clazz.isAnnotation() || clazz.isEnum())

        {

            // interfaces, annotations and enums are no subject of injection

            return false;

        }

        // and finally call all checks which are defined in plugins like JSF, JPA, etc

        List<OpenWebBeansPlugin> plugins = webBeansContext.getPluginLoader().getPlugins();

        for (OpenWebBeansPlugin plugin : plugins)

        {

            //Ejb plugin handles its own events

            //Also EJb beans supports injections

            if(!(plugin instanceof OpenWebBeansEjbPlugin))

            {

                if(plugin.supportsJavaEeComponentInjections(clazz))

                {

                    return true;

                }

            }

            else

            {

                return ((OpenWebBeansEjbPlugin) plugin).isSessionBean(clazz);

            }

        }

        return false;

    }

    /**

     * Check that simple web beans class has compatible constructor.

     * @param annotatedType web beans annotatedType

     * @throws WebBeansConfigurationException if the web beans has incompatible

     *             constructor

     */

    public boolean isConstructorOk(AnnotatedType<?> annotatedType) throws WebBeansConfigurationException

    {

        Class<?> clazz = annotatedType.getJavaClass();

        if (getNoArgConstructor(clazz) != null)

        {

            // if we have a default ct, then all is fine in any case

            return true;

        }

        Set<? extends AnnotatedConstructor<?>> constructors = annotatedType.getConstructors();

        for (AnnotatedConstructor<?> constructor : constructors)

        {

            if (constructor.getAnnotation(Inject.class) != null)

            {

                return true;

            }

        }

        return false;

    }

    private boolean isNormalScoped(final AnnotatedType<?> type)

    {

        final Set<Annotation> annotations = type.getAnnotations();

        BeanManagerImpl beanManager = webBeansContext.getBeanManagerImpl();

        if (annotations != null)

        {

            for (final Annotation a : annotations)

            {

                if (AnnotationUtil.hasMetaAnnotation(a.annotationType().getAnnotations(), NormalScope.class)

                    || AnnotationUtil.hasAnnotation(a.annotationType().getAnnotations(), NormalScope.class))

                {

                    return true;

                }

                for (ExternalScope externalScope : beanManager.getAdditionalScopes())

                {

                    if (externalScope.isNormal() && externalScope.getScope().equals(a))

                    {

                        return true;

                    }

                }

            }

        }

        return false;

    }

    public <T> Bean<T> createNewComponent(Class<T> type)

    {

        Asserts.nullCheckForClass(type);

        final OpenWebBeansEjbPlugin ejbPlugin = webBeansContext.getPluginLoader().getEjbPlugin();

        if (ejbPlugin != null && ejbPlugin.isNewSessionBean(type))

        {

            return ejbPlugin.defineNewSessionBean(type);

        }

        AnnotatedType<T> annotatedType = webBeansContext.getAnnotatedElementFactory().newAnnotatedType(type);

        BeanAttributesImpl<T> defaultBeanAttributes = BeanAttributesBuilder.forContext(webBeansContext).newBeanAttibutes(annotatedType).build();

        BeanAttributesImpl<T> newBeanAttributes = new BeanAttributesImpl<T>(defaultBeanAttributes.getTypes(), Collections.<Annotation>singleton(new NewLiteral(type)));

        // TODO replace this by InjectionPointBuilder

        ManagedBeanBuilder<T, ManagedBean<T>> beanBuilder = new ManagedBeanBuilder<T, ManagedBean<T>>(webBeansContext, annotatedType, newBeanAttributes);

        NewManagedBean<T> newBean

            = new NewManagedBean<T>(webBeansContext, WebBeansType.MANAGED, annotatedType, newBeanAttributes, type, beanBuilder.getBean().getInjectionPoints());

        return newBean;

    }

   

    /**

     * New WebBeans component class.

     *

     * @return the new component

     */

    public <T> NewManagedBean<T> createNewComponent(OwbBean<T> bean, Class<T> type)

    {

        Asserts.assertNotNull(bean, "bean may not be null");

        if (!EnumSet.of(WebBeansType.MANAGED, WebBeansType.ENTERPRISE, WebBeansType.PRODUCERMETHOD, WebBeansType.PRODUCERFIELD).contains(bean.getWebBeansType()))

        {

            throw new WebBeansConfigurationException("@New annotation on type : " + bean.getBeanClass()

                    + " must defined as a simple or an enterprise web bean");

        }

        AnnotatedType<T> annotatedType = webBeansContext.getAnnotatedElementFactory().newAnnotatedType(type);

        BeanAttributesImpl<T> newBeanAttributes = new BeanAttributesImpl<T>(bean.getTypes(), Collections.<Annotation>singleton(new NewLiteral(type)));

        NewManagedBean<T> newBean = new NewManagedBean<T>(bean.getWebBeansContext(), bean.getWebBeansType(), annotatedType, newBeanAttributes, type, bean.getInjectionPoints());

        //TODO XXX set producer

        return newBean;

    }

    /**

     * Creates a new extension bean.

     *

     * @param <T> extension service class

     * @param clazz impl. class

     * @return a new extension service bean

     */

    public <T> ExtensionBean<T> createExtensionComponent(Class<T> clazz)

    {

        Asserts.nullCheckForClass(clazz);

        ExtensionBeanBuilder<T> extensionBeanBuilder = new ExtensionBeanBuilder<T>(webBeansContext, clazz);

        ExtensionBean<T> bean = extensionBeanBuilder.getBean();

        new ObserverMethodsBuilder<T>(webBeansContext, extensionBeanBuilder.getAnnotatedType()).defineObserverMethods(bean);

        return bean;

    }

    /**

     * Creates a new manager bean instance.

     * @return new manager bean instance

     */

    public BeanManagerBean getManagerBean()

    {

        return new BeanManagerBean(webBeansContext);

    }

    /**

     * Creates a new instance bean.

     * @return new instance bean

     */

    public <T> InstanceBean<T> getInstanceBean()

    {

        return new InstanceBean<T>(webBeansContext);

    }

    /**

     * Creates a new event bean.

     * @return new event bean

     */

    public <T> EventBean<T> getEventBean()

    {

        return new EventBean<T>(webBeansContext);

    }

    /**

     * Creates a new event bean.

     * @return new event bean

     */

    public EventMetadataBean getEventMetadataBean()

    {

        return new EventMetadataBean(webBeansContext);

    }

    /**

     * Creates a new bean metadata bean.

     * @return new  bean

     */

    public <T> BeanMetadataBean<T> getBeanMetadataBean()

    {

        return new BeanMetadataBean<T>(webBeansContext);

    }

    /**

     * Creates a new bean metadata bean.

     * @return new  bean

     */

    public PrincipalBean getPrincipalBean()

    {

        return new PrincipalBean(webBeansContext);

    }

    /**

     * Creates a new interceptor metadata bean.

     * @return new bean

     */

    public <T> InterceptorMetadataBean<T> getInterceptorMetadataBean()

    {

        return new InterceptorMetadataBean<T>(webBeansContext);

    }

    /**

     * Creates a new decorator metadata bean.

     * @return new bean

     */

    public <T> DecoratorMetadataBean<T> getDecoratorMetadataBean()

    {

        return new DecoratorMetadataBean<T>(webBeansContext);

    }

    /**

     * Creates a new metadata bean.

     * @return new bean

     */

    public <T> InterceptedOrDecoratedBeanMetadataBean<T> getInterceptedOrDecoratedBeanMetadataBean()

    {

        return new InterceptedOrDecoratedBeanMetadataBean<T>(webBeansContext);

    }

    /**

     * Returns new conversation bean instance.

     * The name is explicitly specified in 6.7.2 and is not the normal default name.

     * @return new conversation bean

     */

    public ConversationBean getConversationBean()

    {

        ConversationBean conversationComp = new ConversationBean(webBeansContext);

        return conversationComp;

    }

    /**

     * Returns a new injected point bean instance.

     * @return new injected point bean

     */

    public InjectionPointBean getInjectionPointBean()

    {

        return new InjectionPointBean(webBeansContext);

    }

    public static String getManagedBeanDefaultName(String clazzName)

    {

        Asserts.assertNotNull(clazzName);

        if(clazzName.length() > 0)

        {

            StringBuilder name = new StringBuilder(clazzName);

            name.setCharAt(0, Character.toLowerCase(name.charAt(0)));

            return name.toString();

        }

        return clazzName;

    }

    public static String getProducerDefaultName(String methodName)

    {

        StringBuilder buffer = new StringBuilder(methodName);

        if (buffer.length() > 3 &&  (buffer.substring(0, 3).equals("get") || buffer.substring(0, 3).equals("set")))

        {

            if(Character.isUpperCase(buffer.charAt(3)))

            {

                buffer.setCharAt(3, Character.toLowerCase(buffer.charAt(3)));

            }

            return buffer.substring(3);

        }

        else if ((buffer.length() > 2 &&  buffer.substring(0, 2).equals("is")))

        {

            if(Character.isUpperCase(buffer.charAt(2)))

            {

                buffer.setCharAt(2, Character.toLowerCase(buffer.charAt(2)));

            }

            return buffer.substring(2);

        }

        else

        {

            buffer.setCharAt(0, Character.toLowerCase(buffer.charAt(0)));

            return buffer.toString();

        }

    }

    /**

     * Configure a list of producer method beans, which override the same method

     * and the bean classes are directly extended each other.

     *

     * @param sortedProducerBeans

     */

    protected void configSpecializedProducerMethodBeans(List<ProducerMethodBean> sortedProducerBeans)

    {

        if (sortedProducerBeans.isEmpty())

        {

            return;

        }

        AlternativesManager altManager = webBeansContext.getAlternativesManager();

        Method superMethod = sortedProducerBeans.get(0).getCreatorMethod();

        for(int i=1; i<sortedProducerBeans.size(); i++)

        {

            ProducerMethodBean bean = sortedProducerBeans.get(i);

            ProducerMethodBean superBean = sortedProducerBeans.get(i - 1);

            // inherit name is super class has name

            boolean isSuperHasName = isSuperMethodNamed(bean, bean.getCreatorMethod(), superMethod);

            // disable super bean if needed

            if (bean.getCreatorMethod().getAnnotation(Alternative.class) == null)

            {

                //disable superbean if the current bean is not an alternative

                superBean.setEnabled(false);

            }

            else if(altManager.isAlternative(bean))

            {

                //disable superbean if the current bean is an enabled alternative

                superBean.setEnabled(false);

            }

            //if no name defined, set superMethod to this bean since this

            //bean's method might have name defined.

            if (!isSuperHasName)

            {

                superMethod = bean.getCreatorMethod();

            }

        }

    }

    /**

     * Configure direct/indirect specialized producer method beans.

     */

    public void configureProducerMethodSpecializations()

    {

        Method method;

        ProducerMethodBean pbean;

        ProducerMethodBean pLeft;

        ProducerMethodBean pRight;

        // collect all producer method beans

        Set<Bean<?>> beans = webBeansContext.getBeanManagerImpl().getBeans();

        List<ProducerMethodBean> producerBeans = new ArrayList<ProducerMethodBean>();

        Set<Class> classesDisabledDueToSpecialization = new HashSet<Class>();

        for(Bean b : beans)

        {

            if (b instanceof ProducerMethodBean)

            {

                producerBeans.add((ProducerMethodBean)b);

                if (((ProducerMethodBean) b).isSpecializedBean())

                {

                    Class superClass = b.getBeanClass().getSuperclass();

                    if (classesDisabledDueToSpecialization.contains(superClass))

                    {

                        throw new DeploymentException("Multiple specializations for the same producer method got detected for type"

                                + b.toString());

                    }

                    classesDisabledDueToSpecialization.add(superClass);

                }

            }

        }

        classesDisabledDueToSpecialization.clear(); // not needed any longer

        // create sorted bean helper.

        SortedListHelper<ProducerMethodBean> producerBeanListHelper = new

                SortedListHelper<ProducerMethodBean>(new ArrayList<ProducerMethodBean>(),

                new Comparator<ProducerMethodBean>()

                {

                    @Override

                    public int compare(ProducerMethodBean e1, ProducerMethodBean e2)

                    {

                        if (e1.getBeanClass().isAssignableFrom(e2.getBeanClass()))

                        {

                            return -1;

                        }

                        else if (e1.equals(e2))

                        {

                            return 0;

                        }

                        return 1;

                    }

                });

        Set<Method> disabledProducerMethods = new HashSet<Method>();

        while(true)

        {

            pbean = null;

            method = null;

            producerBeanListHelper.clear();

            //locate the first specialized bean

            for(ProducerMethodBean pb : producerBeans)

            {

                if (pb.isSpecializedBean())

                {

                    pbean = pb;

                    method = pb.getCreatorMethod();

                    producerBeanListHelper.add(pb);

                    break;

                }

            }

            if (pbean == null)

            {

                break;

            }

            pRight = pbean;

            pLeft = pRight;

            boolean pLeftContinue = true;

            boolean pRightContinue = true;

            // find all pbean's super beans and sub sub beans

            while(pLeftContinue || pRightContinue)

            {

                pRightContinue = false;

                pLeftContinue = false;

                for(ProducerMethodBean pb : producerBeans)

                {

                    //left

                    if (pLeft!= null &&

                        pLeft.getBeanClass().getSuperclass().equals(pb.getBeanClass()))

                    {

                        Method superMethod = webBeansContext.getSecurityService().doPrivilegedGetDeclaredMethod(pb.getBeanClass(), method.getName(), method.getParameterTypes());

                        //Added by GE, method check is necessary otherwise getting wrong method qualifier annotations

                        if (superMethod != null && superMethod.equals(pb.getCreatorMethod()))

                        {

                            if (disabledProducerMethods.contains(superMethod))

                            {

                                throw new DefinitionException("Multiple specializations for the same producer method got detected for type"

                                        + pbean.toString());

                            }

                            disabledProducerMethods.add(superMethod);

                            producerBeanListHelper.add(pb);

                            pLeft = (pb.isSpecializedBean()) ? pb : null;

                        }

                        else

                        {

                            pLeft = null;

                        }

                        if (pLeft != null)

                        {

                            pLeftContinue = true;

                        }

                    }

                    //right

                    if (pRight != null &&

                        pb.getBeanClass().getSuperclass().equals(pRight.getBeanClass()))

                    {

                        if (!pb.isSpecializedBean())

                        {

                            pRight = null;

                        }

                        else

                        {

                            Method superMethod = webBeansContext.getSecurityService().doPrivilegedGetDeclaredMethod(pb.getBeanClass(),

                                                                                                                    method.getName(), method.getParameterTypes());

                            //Added by GE, method check is necessary otherwise getting wrong method qualifier annotations

                            if (superMethod != null && superMethod.equals(pb.getCreatorMethod()))

                            {

                                producerBeanListHelper.add(pb);

                                pRight = pb;

                            }

                            else

                            {

                                pRight = null;

                            }

                        }

                        if (pRight != null)

                        {

                            pRightContinue = true;

                        }

                    }

                } // for

            } // while

            //remove the group from producer bean list

            for(ProducerMethodBean pb : producerBeanListHelper.getList())

            {

                producerBeans.remove(pb);

            }

            //configure the directly extended producer beans

            configSpecializedProducerMethodBeans(producerBeanListHelper.getList());

        }

    }

    public <T> Constructor<T> getNoArgConstructor(Class<T> clazz)

    {

        return webBeansContext.getSecurityService().doPrivilegedGetDeclaredConstructor(clazz);

    }

    /**

     * Configures the name of the producer method for specializing the parent.

     *

     * @param component producer method component

     * @param method specialized producer method

     * @param superMethod overriden super producer method

     */

    public boolean isSuperMethodNamed(AbstractOwbBean<?> component, Method method, Method superMethod)

    {

        return webBeansContext.getAnnotationManager().isSuperMethodNamed(component, method, superMethod);

    }

    /**

     * Returns true if instance injection point false otherwise.

     *

     * @param injectionPoint injection point definition

     * @return true if instance injection point

     */

    public static boolean checkObtainsInjectionPointConditions(InjectionPoint injectionPoint)

    {

        Type type = injectionPoint.getType();

        Class<?> candidateClazz = ClassUtil.getClass(type);

        if(!candidateClazz.isAssignableFrom(Instance.class))

        {

            return false;

        }

        Class<?> rawType;

        if(ClassUtil.isParametrizedType(injectionPoint.getType()))

        {

            ParameterizedType pt = (ParameterizedType)injectionPoint.getType();

            rawType = (Class<?>) pt.getRawType();

            Type[] typeArgs = pt.getActualTypeArguments();

            if(!(rawType.isAssignableFrom(Instance.class)))

            {

                throw new WebBeansConfigurationException("<Instance> field injection " + injectionPoint.toString()

                        + " must have type javax.inject.Instance");

            }

            else

            {

                if(typeArgs.length != 1)

                {

                    throw new WebBeansConfigurationException("<Instance> field injection " + injectionPoint.toString()

                            + " must not have more than one actual type argument");

                }

            }

        }

        else

        {

            throw new IllegalArgumentException("<Instance> field injection " + injectionPoint.toString()

                    + " must be defined as ParameterizedType with one actual type argument");

        }

        return true;

    }

    public static void checkNullInstance(Object instance, Class<? > scopeType, String errorMessage,

            Object... errorMessageArgs)

    {

        if (instance == null)

        {

            if (!scopeType.equals(Dependent.class))

            {

                String message = format(errorMessage, errorMessageArgs);

                throw new IllegalProductException(message);

            }

        }

    }

    public void checkSerializableScopeType(Class<? extends Annotation> scopeType, boolean isSerializable, String errorMessage,

            Object... errorMessageArgs)

    {

        if (webBeansContext.getBeanManagerImpl().isPassivatingScope(scopeType))

        {

            if (!isSerializable)

            {

                String message = format(errorMessage, errorMessageArgs);

                throw new IllegalProductException(message);

            }

        }

    }

    public static Bean<?> getMostSpecializedBean(BeanManager manager, Bean<?> component)

    {

         Set<Bean<?>> beans;

         if (component instanceof EnterpriseBeanMarker)

         {

             beans = new HashSet<Bean<?>>();

             Set<Bean<?>> allBeans = manager.getBeans(Object.class, AnnotationUtil.asArray(component.getQualifiers()));

             for(Bean<?> candidateBean : allBeans)

             {

                 if (candidateBean instanceof EnterpriseBeanMarker)

                 {

                     /*

                      * If a bean class of a session bean X is annotated @Specializes, then the bean class of X must directly extend

                      * the bean class of another session bean Y. Then X directly specializes Y, as defined in Section 4.3, ‚"Specialization".

                      */

                     Class<?> candidateSuperClass = candidateBean.getBeanClass().getSuperclass();

                     if (candidateSuperClass.equals(component.getBeanClass()))

                     {

                         beans.add(candidateBean);

                     }

                 }

             }

         }

         else

         {

             beans = manager.getBeans(component.getBeanClass(),

                     AnnotationUtil.asArray(component.getQualifiers()));

         }

        for(Bean<?> bean : beans)

        {

            Bean<?> find = bean;

            if(!find.equals(component))

            {

                if(AnnotationUtil.hasClassAnnotation(find.getBeanClass(), Specializes.class))

                {

                    return getMostSpecializedBean(manager, find);

                }

            }

        }

        return component;

    }

    /**

     * Returns <code>ProcessAnnotatedType</code> event.

     * @param <T> bean type

     * @param annotatedType bean class

     * @return event

     */

    public <T> GProcessAnnotatedType fireProcessAnnotatedTypeEvent(AnnotatedType<T> annotatedType)

    {

        GProcessAnnotatedType processAnnotatedEvent = new GProcessAnnotatedType(annotatedType);

        //Fires ProcessAnnotatedType

        webBeansContext.getBeanManagerImpl().fireEvent(processAnnotatedEvent, true, AnnotationUtil.EMPTY_ANNOTATION_ARRAY);

        if (processAnnotatedEvent.isModifiedAnnotatedType())

        {

            webBeansContext.getAnnotatedElementFactory().setAnnotatedType(processAnnotatedEvent.getAnnotatedType());

        }

        return processAnnotatedEvent;

    }

    /**

     * Returns <code>ProcessAnnotatedType</code> event.

     * @param <T> bean type

     * @param annotatedType bean class

     * @return event

     */

    public <T> GProcessSyntheticAnnotatedType fireProcessSyntheticAnnotatedTypeEvent(AnnotatedType<T> annotatedType)

    {

        Extension source = AnnotatedTypeWrapper.class.isInstance(annotatedType) ? AnnotatedTypeWrapper.class.cast(annotatedType).getSource() : null;

        GProcessSyntheticAnnotatedType gProcessSyntheticAnnotatedType = new GProcessSyntheticAnnotatedType(source, annotatedType);

        //Fires ProcessSyntheticAnnotatedType

        webBeansContext.getBeanManagerImpl().fireEvent(gProcessSyntheticAnnotatedType, true, AnnotationUtil.EMPTY_ANNOTATION_ARRAY);

        if (gProcessSyntheticAnnotatedType.isModifiedAnnotatedType())

        {

            webBeansContext.getAnnotatedElementFactory().setAnnotatedType(gProcessSyntheticAnnotatedType.getAnnotatedType());

        }

        return gProcessSyntheticAnnotatedType;

    }

    /**

     * @param injectionPoint the original {@link InjectionPoint}

     * @return fired {@link ProcessInjectionPoint} event

     */

    public GProcessInjectionPoint fireProcessInjectionPointEvent(InjectionPoint injectionPoint)

    {

        GProcessInjectionPoint event = new GProcessInjectionPoint(injectionPoint);

        webBeansContext.getBeanManagerImpl().fireEvent(event, true, AnnotationUtil.EMPTY_ANNOTATION_ARRAY);

        return event;

    }

    /**

     * Returns <code>ProcessInjectionTarget</code> event.

     * @param <T> bean type

     * @return event

     */

    public <T> GProcessInjectionTarget fireProcessInjectionTargetEvent(InjectionTargetImpl<T> injectionTarget, AnnotatedType<T> annotatedType)

    {

        final GProcessInjectionTarget processInjectionTargetEvent = new GProcessInjectionTarget(injectionTarget, annotatedType);

        return fireProcessInjectionTargetEvent(processInjectionTargetEvent);

    }

    private GProcessInjectionTarget fireProcessInjectionTargetEvent(GProcessInjectionTarget processInjectionTargetEvent)

    {

        //Fires ProcessInjectionTarget

        webBeansContext.getBeanManagerImpl().fireEvent(processInjectionTargetEvent, true, AnnotationUtil.EMPTY_ANNOTATION_ARRAY);

        return processInjectionTargetEvent;

    }

    /**

     * Returns <code>ProcessInjectionTarget</code> event.

     * @param <T> bean type

     * @return event

     */

    public <T> GProcessInjectionTarget fireProcessInjectionTargetEventForJavaEeComponents(Class<T> componentClass)

    {

        final AnnotatedType<T> annotatedType = webBeansContext.getAnnotatedElementFactory().newAnnotatedType(componentClass);

        final InjectionTargetImpl<T> injectionTarget = InjectionTargetImpl.class.cast(webBeansContext.getBeanManagerImpl().createInjectionTarget(annotatedType));

        final GProcessInjectionTarget processInjectionTargetEvent = new GProcessInjectionTarget(injectionTarget,annotatedType);

        //Fires ProcessInjectionTarget

        return fireProcessInjectionTargetEvent(processInjectionTargetEvent);

    }

    public <T> Producer<T> fireProcessProducerEvent(Producer<T> producer, AnnotatedMember<?> annotatedMember)

    {

        GProcessProducer processProducerEvent = new GProcessProducer(producer, annotatedMember);

        //Fires ProcessProducer

        webBeansContext.getBeanManagerImpl().fireEvent(processProducerEvent, true, AnnotationUtil.EMPTY_ANNOTATION_ARRAY);

        webBeansContext.getWebBeansUtil().inspectErrorStack("There are errors that are added by ProcessProducer event observers. Look at logs for further details");

        return processProducerEvent.getProducer();

    }

    public void fireProcessProducerMethodBeanEvent(Map<ProducerMethodBean<?>, AnnotatedMethod<?>> annotatedMethods, AnnotatedType<?> annotatedType)

    {

        WebBeansContext webBeansContext = this.webBeansContext;

        AnnotationManager annotationManager = webBeansContext.getAnnotationManager();

        for(Map.Entry<ProducerMethodBean<?>, AnnotatedMethod<?>> beanEntry : annotatedMethods.entrySet())

        {

            ProducerMethodBean<?> bean = beanEntry.getKey();

            AnnotatedMethod<?> annotatedMethod = beanEntry.getValue();

            Annotation[] annotationsFromSet = AnnotationUtil.asArray(bean.getQualifiers());

            Method disposal = annotationManager.getDisposalWithGivenAnnotatedMethod(annotatedType, bean.getReturnType(), annotationsFromSet);

            AnnotatedMethod<?> disposalAnnotated;

            GProcessProducerMethod processProducerMethodEvent;

            if(disposal != null)

            {

                disposalAnnotated = webBeansContext.getAnnotatedElementFactory().newAnnotatedMethod(disposal, annotatedType);

                processProducerMethodEvent = new GProcessProducerMethod(bean,annotatedMethod,

                                                                        disposalAnnotated.getParameters().get(0));

            }

            else

            {

                processProducerMethodEvent = new GProcessProducerMethod(bean,annotatedMethod,null);

            }

            //Fires ProcessProducer

            webBeansContext.getBeanManagerImpl().fireEvent(processProducerMethodEvent, true, AnnotationUtil.EMPTY_ANNOTATION_ARRAY);

        }

    }

    public void fireProcessObservableMethodBeanEvent(Map<ObserverMethod<?>,AnnotatedMethod<?>> annotatedMethods)

    {

        for(Map.Entry<ObserverMethod<?>, AnnotatedMethod<?>> observableMethodEntry : annotatedMethods.entrySet())

        {

            ObserverMethod<?> observableMethod = observableMethodEntry.getKey();

            AnnotatedMethod<?> annotatedMethod = observableMethodEntry.getValue();

            GProcessObservableMethod event = new GProcessObservableMethod(annotatedMethod, observableMethod);

            //Fires ProcessProducer

            webBeansContext.getBeanManagerImpl().fireEvent(event, true, AnnotationUtil.EMPTY_ANNOTATION_ARRAY);

        }

    }

    public void fireProcessProducerFieldBeanEvent(Map<ProducerFieldBean<?>,AnnotatedField<?>> annotatedFields)

    {

        for(Map.Entry<ProducerFieldBean<?>, AnnotatedField<?>> beanEntry : annotatedFields.entrySet())

        {

            ProducerFieldBean<?> bean = beanEntry.getKey();

            AnnotatedField<?> field = beanEntry.getValue();

            GProcessProducerField processProducerFieldEvent = new GProcessProducerField(bean, field, null);

            //Fire ProcessProducer

            webBeansContext.getBeanManagerImpl().fireEvent(processProducerFieldEvent, true, AnnotationUtil.EMPTY_ANNOTATION_ARRAY);

        }

    }

    public static void checkInjectionPointNamedQualifier(InjectionPoint injectionPoint)

    {

        Set<Annotation> qualifierset = injectionPoint.getQualifiers();

        Named namedQualifier = null;

        for(Annotation qualifier : qualifierset)

        {

            if(qualifier.annotationType().equals(Named.class))

            {

                namedQualifier = (Named)qualifier;

                break;

            }

        }

        if(namedQualifier != null)

        {

            String value = namedQualifier.value();

            if(value == null || value.equals(""))

            {

                Member member = injectionPoint.getMember();

                if(!(member instanceof Field))

                {

                    throw new WebBeansConfigurationException("Injection point type : " + injectionPoint

                                                             + " can not define @Named qualifier without value!");

                }

            }

        }

    }

    /**

     * Sets bean enabled flag.

     * @param bean bean instance

     */

    public void setInjectionTargetBeanEnableFlag(InjectionTargetBean<?> bean)

    {

        bean.setEnabled(isBeanEnabled(bean.getAnnotatedType(), bean.getStereotypes()));

    }

    public boolean isBeanEnabled(AnnotatedType<?> at, Set<Class<? extends Annotation>> stereotypes)

    {

        boolean isAlternative = isAlternative(at, stereotypes);

        return !isAlternative || webBeansContext.getAlternativesManager().isAlternative(at.getJavaClass(), stereotypes);

    }

    public static boolean isAlternative(AnnotatedType<?> beanType, Set<Class<? extends Annotation>> stereotypes)

    {

        Asserts.assertNotNull(beanType, "bean type can not be null");

        Asserts.assertNotNull(stereotypes, "stereotypes can not be null");

        boolean alternative = false;

        if(beanType.getAnnotation(Alternative.class) != null)

        {

            alternative = true;

        }

        if(!alternative)