* 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.

*

* @version $Rev: 1368948 $ $Date: 2012-08-03 15:40:12 +0200 (Fr, 03 Aug 2012) $

*/

    /**

     * Enforcing that interceptor callbacks should not be

     * able to throw checked exceptions is configurable

     */

    private static volatile Boolean enforceCheckedException;

    private final static Class<Instance<?>> INSTANCE_TYPE

            = new TypeLiteral<Instance<?>>()

    {

        private static final long serialVersionUID = 3555319035805031154L;

    }.getRawType();

    private final static Class<Provider<?>> PROVIDER_TYPE

            = new TypeLiteral<Provider<?>>()

    {

        private static final long serialVersionUID = -2611190564495920054L;

    }.getRawType();

    private final static Class<Event<?>>    EVENT_TYPE

            = new TypeLiteral<Event<?>>()

    {

        private static final long serialVersionUID = -1395145871249763477L;

    }.getRawType();

    private final WebBeansContext webBeansContext;

    public WebBeansUtil(WebBeansContext webBeansContext)

    {

        this.webBeansContext = webBeansContext;

    }

    /**

     * Lifycycle methods like {@link javax.annotation.PostConstruct} and

     * {@link javax.annotation.PreDestroy} must not define a checked Exception

     * regarding to the spec. But this is often unnecessary restrictive so we

     * allow to disable this check application wide.

     *

     * @return <code>true</code> if the spec rule of having no checked exception should be enforced

     */

    private boolean isNoCheckedExceptionEnforced()

    {

        if (enforceCheckedException == null)

        {

            enforceCheckedException = Boolean.parseBoolean(webBeansContext.getOpenWebBeansConfiguration().

                    getProperty(OpenWebBeansConfiguration.INTERCEPTOR_FORCE_NO_CHECKED_EXCEPTIONS, "true"));

        }

        return enforceCheckedException.booleanValue();

    }

    /**

     * 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.

     *

     * @param bean managed bean instance

     */

    public static void checkGenericType(Bean<?> bean)

    {

        Asserts.assertNotNull(bean);

        Class<?> clazz = bean.getBeanClass();

        if (ClassUtil.isDefinitionContainsTypeVariables(clazz))

        {

            if(!bean.getScope().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 = null;

        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;

    }

    /**

     * Return <code>true</code> if the given class is ok for manage bean conditions,

     * <code>false</code> otherwise.

     *

     * @param clazz class in hand

     * @return <code>true</code> if the given class is ok for simple web bean conditions.

     */

    public void isManagedBeanClass(Class<?> clazz)

    {

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

        int modifier = clazz.getModifiers();

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

        {

            throw new WebBeansConfigurationException("Bean implementation class : "

                                                     + clazz.getName() + " can not be non-static inner class");

        }

        if (!ClassUtil.isConcrete(clazz) && !AnnotationUtil.hasClassAnnotation(clazz, Decorator.class))

        {

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

                                                     + " have to be concrete if not defines as @Decorator");

        }

        if (!isConstructureOk(clazz))

        {

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

                                                     + " must define at least one Constructor");

        }

        if(Extension.class.isAssignableFrom(clazz))

        {

            throw new WebBeansConfigurationException("Bean implementation class can not implement "

                                                     + "javax.enterprise.inject.spi.Extension.!");

        }

        Class<?>[] interfaces = clazz.getInterfaces();

        if(interfaces != null && interfaces.length > 0)

        {

            for(Class<?> intr : interfaces)

            {

                if(intr.getName().equals("javax.ejb.EnterpriseBean"))

                {

                    throw new WebBeansConfigurationException("Bean implementation class can not implement "

                                                             + "javax.ejb.EnterpriseBean");

                }

            }

        }

        // 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);

            }

        }

    }

    /**

     * 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;

                }

            }

        }

        return false;

    }

    /**

     * Defines applicable constructor.

     * @param <T> type info

     * @param clazz class type

     * @return constructor

     * @throws WebBeansConfigurationException any configuration exception

     */

    public <T> Constructor<T> defineConstructor(Class<T> clazz) throws WebBeansConfigurationException

    {

        Asserts.nullCheckForClass(clazz);

        Constructor<?>[] constructors = webBeansContext.getSecurityService().doPrivilegedGetDeclaredConstructors(clazz);

        return defineConstructor(constructors, clazz);

    }

    public <T> Constructor<T> defineConstructor(Constructor<?>[] constructors, Class<T> clazz)

    {

        Constructor<T> result = null;

        boolean inAnnotation = false;

        /* Check for @Initializer */

        for (Constructor<?> constructor : constructors)

        {

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

            {

                if (inAnnotation)// duplicate @In

                {

                    throw new WebBeansConfigurationException("There are more than one Constructor with "

                                                             + "Initializer annotation in class " + clazz.getName());

                }

                inAnnotation = true;

                result = (Constructor<T>) constructor;

            }

        }

        if (result == null)

        {

            result = getNoArgConstructor(clazz);

            if(result == null)

            {

                throw new WebBeansConfigurationException("No constructor is found for the class : " + clazz.getName());

            }

        }

        Annotation[][] parameterAnns = result.getParameterAnnotations();

        for (Annotation[] parameters : parameterAnns)

        {

            for (Annotation param : parameters)

            {

                if (param.annotationType().equals(Disposes.class))

                {

                    throw new WebBeansConfigurationException("Constructor parameter annotations can not contain " +

                            "@Disposes annotation in class : " + clazz.getName());

                }

                if(param.annotationType().equals(Observes.class))