cvs commit: jakarta-avalon-excalibur/microcontainer/src/test/org/apache/excalibur/microcontainer/test Chooser.java ChooserImpl.java SelectorTestCase.java

[le...@apache.org]

leosutic    2002/06/27 02:48:06

  Added:       microcontainer/src/java/org/apache/excalibur/microcontainer
                        AbstractManager.java
                        MicroContainerServiceManager.java
               microcontainer/src/test/org/apache/excalibur/microcontainer/test
                        Chooser.java ChooserImpl.java SelectorTestCase.java
  Log:
  no message
  
  Revision  Changes    Path
  1.1                  jakarta-avalon-excalibur/microcontainer/src/java/org/apache/excalibur/microcontainer/AbstractManager.java
  
  Index: AbstractManager.java
  ===================================================================
  package org.apache.excalibur.microcontainer;
  
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  /**
   * Abstract implementation of a lookup service.
   */
  abstract class AbstractManager 
  {
      private final HashMap handlers = new HashMap ();
      private final HashMap used = new HashMap ();
      
      protected AbstractManager( Map components ) 
      {
          Iterator iter = components.keySet().iterator();
          while (iter.hasNext()) 
          {
              Object key = iter.next();
              Object component = components.get( key );
              
              // Verify that component is a MicroContainerProxy...
              
              handlers.put( key, translateEntry(component) );
          }
      }
      
      protected abstract Object translateEntry( Object entry );
      
      protected boolean has( Object key ) 
      {
          return handlers.containsKey( key );
      }
      
      protected synchronized Object doLookup( Object key ) 
      {
          Object object = handlers.get( key );
          if( object instanceof MicroContainerProxy )
          {
              MicroContainerProxy handler = (MicroContainerProxy) object;
              
              Object component = handler.MicroContainerProxy__newInstance();
              
              used.put( component, handler );
              
              return component;
          }
          else
          {
              return object;
          }
      }
      
      protected synchronized void doRelease( Object instance ) 
      {
          if( instance instanceof AbstractManager )
          {
              // We're getting a XXXXSelector back.
          }
          else
          {
              MicroContainerProxy handler = (MicroContainerProxy) used.remove( instance );
              
              handler.MicroContainerProxy__releaseInstance( instance );
          }
      }    
  }
  
  
  
  1.1                  jakarta-avalon-excalibur/microcontainer/src/java/org/apache/excalibur/microcontainer/MicroContainerServiceManager.java
  
  Index: MicroContainerServiceManager.java
  ===================================================================
  package org.apache.excalibur.microcontainer;
  
  import java.util.Map;
  
  import org.apache.avalon.framework.service.ServiceManager;
  
  /**
   * An implementation of the ServiceManager interface for
   * MicroContainers.
   */
  class MicroContainerServiceManager extends AbstractManager implements ServiceManager 
  {
      
      public MicroContainerServiceManager( Map components ) 
      {
          super( components );
      }
      
      public boolean hasService( String role ) 
      {
          return super.has( role );
      }
      
      public boolean isSelectable( Object hint ) 
      {
          return super.has( hint );
      }
      
      public Object lookup( String role ) 
      {
          return super.doLookup( role );
      }
      
      public synchronized void release( Object instance ) 
      {
          super.doRelease( instance );
      }    
      
      public Object select( Object hint ) 
      {
          return super.doLookup( hint );
      }
      
      protected Object translateEntry( Object entry )
      {
          if( entry instanceof Map )
          {
              return new MicroContainerServiceManager( (Map) entry );
          }
          else
          {
              return entry;
          }
      }
  }
  
  
  
  1.1                  jakarta-avalon-excalibur/microcontainer/src/test/org/apache/excalibur/microcontainer/test/Chooser.java
  
  Index: Chooser.java
  ===================================================================
  package org.apache.excalibur.microcontainer.test;
  
  import org.apache.avalon.framework.component.Component;
  
  public interface Chooser extends Component 
  {
      public static final String ROLE = Chooser.class.getName();
      
      public int choose( String role, Object hint ) throws Exception;
  }
  
  
  
  1.1                  jakarta-avalon-excalibur/microcontainer/src/test/org/apache/excalibur/microcontainer/test/ChooserImpl.java
  
  Index: ChooserImpl.java
  ===================================================================
  package org.apache.excalibur.microcontainer.test;
  
  import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.avalon.framework.component.ComponentManager;
  import org.apache.avalon.framework.component.ComponentSelector;
  import org.apache.avalon.framework.component.Composable;
  
  public class ChooserImpl implements Chooser, Composable {
      
      private ComponentManager manager;
      
      public void compose( ComponentManager manager ) 
      {
          this.manager = manager;
      }
      
      public int choose( String role, Object hint ) throws Exception
      {
          ComponentSelector selector = (ComponentSelector) manager.lookup( role );
          Supplier supplier = (Supplier) selector.select( hint );
          try
          {
              return supplier.getId();
          }
          finally
          {
              selector.release( supplier );
              manager.release( selector );
          }
      }
  }
  
  
  1.1                  jakarta-avalon-excalibur/microcontainer/src/test/org/apache/excalibur/microcontainer/test/SelectorTestCase.java
  
  Index: SelectorTestCase.java
  ===================================================================
  package org.apache.excalibur.microcontainer.test;
  
  import junit.framework.TestCase;
  
  import org.apache.excalibur.microcontainer.MicroContainer;
  
  public class SelectorTestCase extends TestCase
  {
      
      public SelectorTestCase(String name) 
      {
          super(name);
      }
      
      public void testChooserImpl() throws Exception 
      {
          Supplier supplier1 = SupplierImpl.getInstance (1);
          Supplier supplier2 = SupplierImpl.getInstance (2);
          
          Chooser chooser = (Chooser) new MicroContainer( ChooserImpl.class )
              .component( Supplier.ROLE, new Integer(1), supplier1 )
              .component( Supplier.ROLE, new Integer(2), supplier2 )
              .sharedInstance( true )
              .create();
          
          assertEquals( 1, chooser.choose( Supplier.ROLE, new Integer(1) ) );
          assertEquals( 2, chooser.choose( Supplier.ROLE, new Integer(2) ) );
          
          MicroContainer.release( chooser );
          MicroContainer.release( supplier2 );
          MicroContainer.release( supplier1 );
      }    
      
      public void testIllegalState() throws Exception 
      {
          Supplier supplier1 = SupplierImpl.getInstance (1);
          
          try 
          {
              Chooser chooser = (Chooser) new MicroContainer( ChooserImpl.class )
                  .component( Supplier.ROLE, supplier1 )
                  .component( Supplier.ROLE, new Integer(1), supplier1 )
                  .sharedInstance( true )
                  .create();
              fail( "IllegalStateException not thrown, although invalid mapping attempted." );
          } 
          catch( IllegalStateException ie )
          {
          }
          
          try 
          {
              Chooser chooser = (Chooser) new MicroContainer( ChooserImpl.class )
                  .component( Supplier.ROLE, new Integer(1), supplier1 )
                  .component( Supplier.ROLE, supplier1 )
                  .sharedInstance( true )
                  .create();
              fail( "IllegalStateException not thrown, although invalid mapping attempted." );
          } 
          catch( IllegalStateException ie )
          {
          }
      }
  }
  
  

--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>