/*
    * Copyright (c) 1998, 2005 Gargoyle Software Inc. All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain the above copyright notice,
    *    this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   * 3. The end-user documentation included with the redistribution, if any, must
   *    include the following acknowledgment:
   *
   *       "This product includes software developed by Gargoyle Software Inc.
   *        (http://www.GargoyleSoftware.com/)."
   *
   *    Alternately, this acknowledgment may appear in the software itself, if
   *    and wherever such third-party acknowledgments normally appear.
   * 4. The name "Gargoyle Software" must not be used to endorse or promote
   *    products derived from this software without prior written permission.
   *    For written permission, please contact info@GargoyleSoftware.com.
   * 5. Products derived from this software may not be called "GSBase", nor may
   *    "GSBase" appear in their name, without prior written permission of
   *    Gargoyle Software Inc.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARGOYLE
   * SOFTWARE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
   * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
   * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package com.gargoylesoftware.base.resource;
  
  import java.util.ArrayList;
  import java.util.List;
  import junit.framework.AssertionFailedError;
  
  /***
   *  A resource factory that logs tracing information to a list
   *
   * @version  $Revision: 1.6 $
   * @author <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
   */
  public class ProxyResourceFactory
           extends ResourceFactory {
  
      private boolean allowReinitialization_ = true;
      private String resourceFactoryName_;
      private List methodCollectingList_;
  
      private int counter_ = 1;
      private final List allocatedResourcesList_ = new ArrayList();
  
  
      /***
       *  Create an instance
       */
      public ProxyResourceFactory() {
      }
  
  
      /***
       *  Create an instance
       *
       * @param  collectingList The list that will collect the tracing information
       */
      public ProxyResourceFactory( final List collectingList ) {
          if( collectingList == null ) {
              throw new NullPointerException( "collectingList" );
          }
          methodCollectingList_ = collectingList;
      }
  
  
      /***
       *  Set the name
       *
       * @param  name The name of the factory
       */
      public void setResourceFactoryName( final String name ) {
          resourceFactoryName_ = name;
          trace( "setResourceFactoryName" );
      }
  
  
      /***
       * Set whether or not to allow reinitialization of resources
       * @param  allow true if reinitialization is to be allowed
       */
      public void setAllowReinitialization( final boolean allow ) {
          allowReinitialization_ = allow;
      }
  
 
     /***
      *  Allocate and return a resource
      *
      * @param  resourceManager The ResourceManager that owns this factory
      * @return  The resource
      */
     public ManagedResource getResourceImpl( final ResourceManager resourceManager ) {
         trace( "getResourceImpl" );
         final ManagedResource resource
                  = new FakeResource( String.valueOf( counter_++ ) );
         allocatedResourcesList_.add( resource );
         return resource;
     }
 
 
     /***
      *  Return the name
      *
      * @return  The name
      */
     public String getResourceFactoryName() {
         trace( "setResourceFactoryName()" );
         return resourceFactoryName_;
     }
 
 
     /***
      * Return a count of the allocated resources
      * @return The number of allocated resources
      */
     public int getAllocatedResourceCount() {
         return allocatedResourcesList_.size();
     }
 
 
     /***
      *  Release a resource which had been previously allocated from this factory
      *
      * @param  resourceManager The resource manager that owns this factory
      * @param  resource The resource to release
      */
     public void releaseResourceImpl( final ResourceManager resourceManager, final ManagedResource resource ) {
         trace( "releaseResourceImpl" );
 
         if( allocatedResourcesList_.contains( resource ) == false ) {
             throw new AssertionFailedError( "resource wasn't allocated from this store" );
         }
         allocatedResourcesList_.remove( resource );
     }
 
 
     /***
      *  Release all resources that had been allocated from this factory
      *
      * @param  resourceManager The resource manager that owns this factory
      */
     public void releaseAllResources( final ResourceManager resourceManager ) {
         trace( "releaseAllResources" );
         super.releaseAllResources( resourceManager );
     }
 
 
     /***
      *  Try to reinitialize the specified resource to a known state
      *
      * @param  resource The resource to reinitialize
      * @return  true if reinitialization was successful
      */
     public boolean reinitializeResourceIfPossible( final ManagedResource resource ) {
         trace( "reinitializeResourceIfPossible" );
         return allowReinitialization_;
     }
 
 
     private void trace( final String methodName ) {
         if( methodCollectingList_ != null ) {
             methodCollectingList_.add( methodName );
         }
     }
 
     /*** Fake class for testing */
     static class FakeResource implements ManagedResource {
         private final String name_;
         private String resourceFactoryName_;
 
 
         /***
          *  Create an instance
          *
          * @param  name The name of the resource
          */
         public FakeResource( final String name ) {
             name_ = name;
         }
 
         /***
          * Set the name of the resource factory
          * @param name The new name.
          */
         public void setResourceFactoryName( final String name ) {
             resourceFactoryName_ = name;
         }
 
         /***
          * Get the name of the resource factory
          * @return The name
          */
         public String getResourceFactoryName() {
             return resourceFactoryName_;
         }
 
 
         /*** @return A string representation of this object */
         public String toString() {
             return name_;
         }
     }
 }