donaldp     2002/11/06 22:57:00

  Modified:    fortress/src/java/org/apache/excalibur/fortress
                        DefaultContainerManager.java
  Log:
  Use ContainerUtil internally and use m_ for var names,
  
  Revision  Changes    Path
  1.29      +51 -49    
jakarta-avalon-excalibur/fortress/src/java/org/apache/excalibur/fortress/DefaultContainerManager.java
  
  Index: DefaultContainerManager.java
  ===================================================================
  RCS file: 
/home/cvs/jakarta-avalon-excalibur/fortress/src/java/org/apache/excalibur/fortress/DefaultContainerManager.java,v
  retrieving revision 1.28
  retrieving revision 1.29
  diff -u -r1.28 -r1.29
  --- DefaultContainerManager.java      7 Nov 2002 05:33:01 -0000       1.28
  +++ DefaultContainerManager.java      7 Nov 2002 06:56:59 -0000       1.29
  @@ -66,6 +66,7 @@
   import org.apache.avalon.framework.parameters.Parameters;
   import org.apache.avalon.framework.service.ServiceManager;
   import org.apache.avalon.framework.service.Serviceable;
  +import org.apache.avalon.framework.container.ContainerUtil;
   import org.apache.excalibur.fortress.util.ComponentStateValidator;
   import org.apache.excalibur.fortress.util.ContextManager;
   
  @@ -86,12 +87,13 @@
    * @author <a href="mailto:bloritsch@;apache.org">Berin Loritsch</a>
    * @version CVS $Revision$ $Date$
    */
  -public class DefaultContainerManager implements ContainerManager, 
ContainerManagerConstants
  +public class DefaultContainerManager
  +    implements ContainerManager, ContainerManagerConstants
   {
  -    private final ContextManager contextManager;
  -    private Logger logger;
  -    private Object containerInstance;
  -    private ComponentStateValidator validator;
  +    private final ContextManager m_contextManager;
  +    private Logger m_logger;
  +    private Object m_containerInstance;
  +    private ComponentStateValidator m_validator;
   
       public DefaultContainerManager( ContextManager contextManager )
       {
  @@ -100,9 +102,9 @@
   
       public DefaultContainerManager( ContextManager contextManager, Logger logger )
       {
  -        this.contextManager = contextManager;
  -        this.logger = ( logger == null ?
  -            createLoggerFromContext( 
this.contextManager.getContainerManagerContext() ) : logger );
  +        m_contextManager = contextManager;
  +        m_logger = ( logger == null ?
  +            createLoggerFromContext( m_contextManager.getContainerManagerContext() 
) : logger );
       }
   
       public DefaultContainerManager( Context initParameters )
  @@ -170,13 +172,13 @@
   
       protected void initializeContainer() throws InitializationException
       {
  -        if( null == containerInstance )
  +        if( null == m_containerInstance )
           {
               Object instance = null;
   
               try
               {
  -                instance = ( 
(Class)this.contextManager.getContainerManagerContext().
  +                instance = ( (Class)m_contextManager.getContainerManagerContext().
                       get( CONTAINER_CLASS ) ).newInstance();
               }
               catch( Exception e )
  @@ -187,26 +189,24 @@
                       "Cannot set up container. Unable to create container class", e 
);
               }
   
  -            validator = new ComponentStateValidator( instance );
  +            m_validator = new ComponentStateValidator( instance );
   
               try
               {
                   if( instance instanceof LogEnabled )
                   {
  -                    validator.checkLogEnabled();
  -                    ( (LogEnabled)instance ).enableLogging( logger );
  +                    m_validator.checkLogEnabled();
  +                    ContainerUtil.enableLogging( instance, m_logger );
                   }
   
  +                final Context managerContext =
  +                    m_contextManager.getContainerManagerContext();
                   if( instance instanceof Contextualizable )
                   {
  -                    validator.checkContextualized();
  -                    ( (Contextualizable)instance ).contextualize(
  -                        this.contextManager.getContainerManagerContext() );
  +                    m_validator.checkContextualized();
  +                    ContainerUtil.contextualize( instance, managerContext );
                   }
   
  -                ServiceManager smanager = getServiceManager(
  -                    this.contextManager.getContainerManagerContext() );
  -
                   if( instance instanceof Composable )
                   {
                       throw new InitializationException( "Composable containers are 
not supported" );
  @@ -214,46 +214,49 @@
   
                   if( instance instanceof Serviceable )
                   {
  -                    validator.checkServiced();
  -
  -                    ( (Serviceable)instance ).service( smanager );
  +                    m_validator.checkServiced();
  +                    final ServiceManager smanager = getServiceManager( 
managerContext );
  +                    ContainerUtil.service( instance, smanager );
                   }
   
                   if( instance instanceof Configurable )
                   {
  -                    validator.checkConfigured();
  -                    ( (Configurable)instance ).configure( (Configuration)
  -                        this.contextManager.getContainerManagerContext().get( 
CONFIGURATION ) );
  +                    m_validator.checkConfigured();
  +                    final Configuration config =
  +                        (Configuration)managerContext.get( CONFIGURATION );
  +                    ContainerUtil.configure( instance, config );
                   }
   
                   if( instance instanceof Parameterizable )
                   {
  -                    validator.checkParameterized();
  -                    ( (Parameterizable)instance ).parameterize( (Parameters)
  -                        this.contextManager.getContainerManagerContext().get( 
PARAMETERS ) );
  +                    m_validator.checkParameterized();
  +                    final Parameters parameters = (Parameters) managerContext.get( 
PARAMETERS );
  +                    ContainerUtil.parameterize( instance, parameters );
  +
                   }
   
                   if( instance instanceof Initializable )
                   {
  -                    validator.checkInitialized();
  -                    ( (Initializable)instance ).initialize();
  +                    m_validator.checkInitialized();
  +                    ContainerUtil.initialize( instance );
                   }
   
                   if( instance instanceof Startable )
                   {
  -                    validator.checkStarted();
  -                    ( (Startable)instance ).start();
  +                    m_validator.checkStarted();
  +                    ContainerUtil.start( instance );
                   }
               }
               catch( Exception e )
               {
                   instance = null;
   
  -                throw new InitializationException(
  -                    "Cannot set up container. Startup lifecycle failure", e );
  +                final String message =
  +                    "Cannot set up container. Startup lifecycle failure";
  +                throw new InitializationException( message, e );
               }
   
  -            containerInstance = instance;
  +            m_containerInstance = instance;
           }
       }
   
  @@ -277,14 +280,14 @@
   
       protected void disposeContainer()
       {
  -        if( null != containerInstance )
  +        if( null != m_containerInstance )
           {
  -            if( containerInstance instanceof Startable )
  +            if( m_containerInstance instanceof Startable )
               {
                   try
                   {
  -                    validator.checkStopped();
  -                    ( (Startable)containerInstance ).stop();
  +                    m_validator.checkStopped();
  +                    ( (Startable)m_containerInstance ).stop();
                   }
                   catch( Exception e )
                   {
  @@ -296,14 +299,14 @@
                   }
               }
   
  -            if( containerInstance instanceof Disposable )
  +            if( m_containerInstance instanceof Disposable )
               {
  -                validator.checkDisposed();
  -                ( (Disposable)containerInstance ).dispose();
  +                m_validator.checkDisposed();
  +                ( (Disposable)m_containerInstance ).dispose();
               }
   
  -            validator = null;
  -            containerInstance = null;
  +            m_validator = null;
  +            m_containerInstance = null;
           }
       }
   
  @@ -313,7 +316,7 @@
       public void dispose()
       {
           disposeContainer();
  -        this.contextManager.dispose();
  +        m_contextManager.dispose();
       }
   
       /**
  @@ -322,13 +325,12 @@
        */
       public Object getContainer()
       {
  -        return containerInstance;
  +        return m_containerInstance;
       }
   
       public Logger getLogger()
       {
  -        return logger;
  +        return m_logger;
       }
  -
   }
   
  
  
  

--
To unsubscribe, e-mail:   <mailto:avalon-cvs-unsubscribe@;jakarta.apache.org>
For additional commands, e-mail: <mailto:avalon-cvs-help@;jakarta.apache.org>

Reply via email to