* Copyright (c) 1998-2010 Caucho Technology -- all rights reserved

*

* This file is part of Resin(R) Open Source

*

* Each copy or derived work must preserve the copyright notice and this

* notice unmodified.

*

* Resin Open Source is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

*

* Resin Open Source is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty

* of NON-INFRINGEMENT.  See the GNU General Public License for more

* details.

*

* You should have received a copy of the GNU General Public License

* along with Resin Open Source; if not, write to the

*

*   Free Software Foundation, Inc.

*   59 Temple Place, Suite 330

*   Boston, MA 02111-1307  USA

*

* @author Scott Ferguson

*/

* The web beans container for a given environment.

*/

@SuppressWarnings("serial")

  implements BeanManager, EnvironmentListener,

             java.io.Serializable, HandleAware

  private static final L10N L = new L10N(InjectManager.class);

  private static final Logger log

    = Logger.getLogger(InjectManager.class.getName());

  private static final EnvironmentLocal<InjectManager> _localContainer

    = new EnvironmentLocal<InjectManager>();

  private static final int DEFAULT_PRIORITY = 1;

  private static final Annotation []CURRENT_ANN

    = CurrentLiteral.CURRENT_ANN_LIST;

  private static final String []FORBIDDEN_ANNOTATIONS = {

    "javax.persistence.Entity",

    /*

    "javax.ejb.Stateful",

    "javax.ejb.Stateless",

    "javax.ejb.Singleton",

    "javax.ejb.MessageDriven"

    */

  };

  private static final String []FORBIDDEN_CLASSES = {

    "javax.servlet.Servlet",

    "javax.servlet.Filter",

    "javax.servlet.ServletContextListener",

    "javax.servlet.http.HttpSessionListener",

    "javax.servlet.ServletRequestListener",

    "javax.ejb.EnterpriseBean",

    "javax.faces.component.UIComponent",

    "javax.enterprise.inject.spi.Extension",

  };

  private static final Class<? extends Annotation> []_forbiddenAnnotations;

  private static final Class<?> []_forbiddenClasses;

  private String _id;

  private InjectManager _parent;

  private EnvironmentClassLoader _classLoader;

 

  private final InjectScanManager _scanManager;

  private final ExtensionManager _extensionManager

    = new ExtensionManager(this);

 

  private AtomicLong _version = new AtomicLong();

  private HashSet<String> _configuredClasses

    = new HashSet<String>();

  private HashSet<Class<?>> _specializedClasses

    = new HashSet<Class<?>>();

  private HashMap<Class<?>,Integer> _deploymentMap

    = new HashMap<Class<?>,Integer>();

  private BaseTypeFactory _baseTypeFactory = new BaseTypeFactory();

  private HashMap<Class<?>,InjectionPointHandler> _injectionMap

    = new HashMap<Class<?>,InjectionPointHandler>();

  //

  // self configuration

  //

  private HashMap<Class<?>,Set<TypedBean>> _selfBeanMap

    = new HashMap<Class<?>,Set<TypedBean>>();

  private HashMap<String,ArrayList<Bean<?>>> _selfNamedBeanMap

    = new HashMap<String,ArrayList<Bean<?>>>();

  private HashMap<Class<?>,ObserverMap> _extObserverMap

    = new HashMap<Class<?>,ObserverMap>();

  private HashMap<String,Bean<?>> _selfPassivationBeanMap

    = new HashMap<String,Bean<?>>();

  //

  // combined visibility configuration

  //

  private HashMap<Class<?>,WebComponent> _beanMap

    = new HashMap<Class<?>,WebComponent>();

  private HashMap<String,ArrayList<Bean<?>>> _namedBeanMap

    = new HashMap<String,ArrayList<Bean<?>>>();

  private HashMap<Class<?>,ObserverMap> _observerMap

    = new HashMap<Class<?>,ObserverMap>();

  private HashMap<Type,Bean<?>> _newBeanMap

    = new HashMap<Type,Bean<?>>();

 

  private HashSet<Class<? extends Annotation>> _qualifierSet

    = new HashSet<Class<? extends Annotation>>();

 

  private HashSet<Class<? extends Annotation>> _scopeTypeSet

    = new HashSet<Class<? extends Annotation>>();

 

  private HashSet<Class<? extends Annotation>> _normalScopeSet

    = new HashSet<Class<? extends Annotation>>();

 

  private HashSet<Class<? extends Annotation>> _passivatingScopeSet

    = new HashSet<Class<? extends Annotation>>();

  private HashMap<Class<?>,Context> _contextMap

    = new HashMap<Class<?>,Context>();

  private HashMap<Class<?>,ArrayList<ObserverMap>> _observerListCache

    = new HashMap<Class<?>,ArrayList<ObserverMap>>();

  private ArrayList<InterceptorEntry<?>> _interceptorList

    = new ArrayList<InterceptorEntry<?>>();

  private ArrayList<DecoratorEntry<?>> _decoratorList

    = new ArrayList<DecoratorEntry<?>>();

  private HashSet<Bean<?>> _beanSet = new HashSet<Bean<?>>();

  private boolean _isUpdateNeeded = true;

  private ArrayList<Path> _pendingPathList

    = new ArrayList<Path>();

  private ArrayList<AnnotatedType<?>> _pendingAnnotatedTypes

    = new ArrayList<AnnotatedType<?>>();

  private ArrayList<AbstractBean<?>> _pendingBindList

    = new ArrayList<AbstractBean<?>>();

  private ArrayList<Bean<?>> _pendingServiceList

    = new ArrayList<Bean<?>>();

  private boolean _isBeforeBeanDiscoveryComplete;

  private boolean _isAfterBeanDiscoveryComplete;

  // XXX: needs to be a local resolver

  private ELResolver _elResolver = new WebBeansContextResolver();

  private DependentContext _dependentContext = new DependentContext();

  private SingletonScope _singletonScope = new SingletonScope();

  private ApplicationScope _applicationScope = new ApplicationScope();

  private XmlStandardPlugin _xmlExtension;

  private RuntimeException _configException;

  private Object _serializationHandle;

  private InjectManager(String id,

                        InjectManager parent,

                        EnvironmentClassLoader loader,

                        boolean isSetLocal)

  {

    _id = id;

    _classLoader = loader;

   

    _parent = parent;

   

    _scanManager = new InjectScanManager(this);

    Thread thread = Thread.currentThread();

    ClassLoader oldLoader = thread.getContextClassLoader();

    try {

      thread.setContextClassLoader(_classLoader);

      if (isSetLocal) {

        _localContainer.set(this, _classLoader);

        if (_parent == null) {

          _localContainer.setGlobal(this);

        }

      }

      if (_classLoader != null)

        _classLoader.getNewTempClassLoader();

      else

        new DynamicClassLoader(null);

    } finally {

      thread.setContextClassLoader(oldLoader);

    }

  }

  private void init(boolean isSetLocal)

  {

    Thread thread = Thread.currentThread();

    ClassLoader oldLoader = thread.getContextClassLoader();

    try {

      thread.setContextClassLoader(_classLoader);

      try {

        InitialContext ic = new InitialContext();

        ic.rebind("java:comp/BeanManager", new WebBeansJndiProxy());

      } catch (Throwable e) {

        log.log(Level.FINEST, e.toString(), e);

      }

      addContext("com.caucho.server.webbeans.RequestScope");

      addContext("com.caucho.server.webbeans.SessionScope");

      addContext("com.caucho.server.webbeans.ConversationScope");

      addContext("com.caucho.server.webbeans.TransactionScope");

      addContext(_applicationScope);

      addContext(_singletonScope);

      addContext(_dependentContext);

      _injectionMap.put(PersistenceContext.class,

                        new PersistenceContextHandler(this));

      _injectionMap.put(PersistenceUnit.class,

                        new PersistenceUnitHandler(this));

      _injectionMap.put(Resource.class,

                        new ResourceHandler(this));

      _injectionMap.put(EJB.class,

                        new EjbHandler(this));

      _deploymentMap.put(CauchoDeployment.class, 0);

      // DEFAULT_PRIORITY

      _deploymentMap.put(Configured.class, 2);

      BeanFactory<InjectManager> factory = createBeanFactory(InjectManager.class);

      // factory.deployment(Standard.class);

      factory.type(InjectManager.class);

      factory.type(BeanManager.class);

      factory.annotation(ModulePrivateLiteral.create());

      addBean(factory.singleton(this));

      _xmlExtension = new XmlStandardPlugin(this);

      addExtension(_xmlExtension);

      _extensionManager.createExtension("com.caucho.server.webbeans.ResinStandardPlugin");

     

      if (_classLoader != null && isSetLocal) {

        // _classLoader.addScanListener(this);

        _classLoader.addScanListener(_scanManager);

      }

      Environment.addEnvironmentListener(this, _classLoader);

    } finally {

      thread.setContextClassLoader(oldLoader);

    }

  }

  /**

   * Returns the modification version.

   */

  public long getVersion()

  {

    return _version.get();

  }

 

  InjectScanManager getScanManager()

  {

    return _scanManager;

  }

  private void addContext(String contextClassName)

  {

    try {

      Class<?> cl = Class.forName(contextClassName);

      Context context = (Context) cl.newInstance();

      addContext(context);

    } catch (ClassNotFoundException e) {

      log.log(Level.FINER, e.toString(), e);