package org.codehaus.plexus.util;
   
   /*
    * Copyright The Codehaus Foundation.
    *
    * Licensed 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.
   */
  
  import java.util.ArrayList;
  
  /**
   * Pools a bunch of objects . Runs a sweeper periodically to keep it down to size. The objects in the pool first get
   * disposed first.
   *
   * @author <a href="mailto:bert@tuaworks.co.nz">Bert van Brakel</a>
   *
   */
  public class SweeperPool {
      /***/
      private static final boolean DEBUG = false;
  
      /** Sweeps the pool periodically to trim it's size */
      private transient Sweeper sweeper;
  
      /** Absolute maximum size of the pool. */
      private transient int maxSize;
  
      /** The size the pool gets trimmed down to */
      private transient int minSize;
  
      /**
       * When the sweeper runs and the pool is over this size, then the pool is trimmed
       */
      private int triggerSize;
  
      /** Holds the pooled objects */
      private ArrayList<Object> pooledObjects;
  
      /** Flag indicating this pool is shuting down */
      private boolean shuttingDown = false;
  
      // private Vector used;
  
      /**
       * There are a number of settings to control how the pool operates.
       * @param maxSize if the pool has reached this size, any objects added are immediately disposed. If the
       *      pool is this size when the sweeper runs, then the pool is also trimmed to <code>minSize</code> irrespective of
       *      the triggerSize.
       * @param minSize - this is the size the pool is trimmed to
       * @param  triggerSize - this determines if the pool is trimmed when the sweeper runs. If the pool size is
       * greater or equal than this value then the pool is trimmed to <code>minSize</code>.
       *
       * @param sweepInterval how often the sweeper runs. Is actually the time since the sweeper last finished
       * a pass. 0 if the sweeper should not run.
       * @param intialCapacity the intial capacity
       * <p>Any value less than 0 is automatically converted to 0</p>
       */
      public SweeperPool(int maxSize, int minSize, int intialCapacity, int sweepInterval, int triggerSize) {
          super();
          this.maxSize = saneConvert(maxSize);
          this.minSize = saneConvert(minSize);
          this.triggerSize = saneConvert(triggerSize);
          pooledObjects = new ArrayList(intialCapacity);
  
          // only run a sweeper if sweep interval is positive
          if (sweepInterval > 0) {
              sweeper = new Sweeper(this, sweepInterval);
              sweeper.start();
          }
      }
  
      private int saneConvert(int value) {
          return Math.max(value, 0);
      }
  
      /**
       * Return the pooled object
       * @return first available object from the pool
       */
      public synchronized Object get() {
          if ((pooledObjects.size() == 0) || shuttingDown) {
              return null;
          } else {
              Object obj = pooledObjects.remove(0);
              objectRetrieved(obj);
  
              // used.add(obj);
              return obj;
          }
     }
 
     /**
      * Add an object to the pool
      *
      * @param obj the object to pool. Can be null.
      * @return true if the object was added to the pool, false if it was disposed or null
      */
     public synchronized boolean put(Object obj) {
         objectAdded(obj);
 
         if ((obj != null) && (pooledObjects.size() < maxSize) && (shuttingDown == false)) {
             pooledObjects.add(obj);
 
             return true;
         } else if (obj != null) {
             // no longer need the object, so dispose it
             objectDisposed(obj);
         }
 
         return false;
     }
 
     /**
      * Return the number of pooled objects. This is never greater than t maximum size of the pool
      *
      * @return the number of pooled objects
      */
     public synchronized int getSize() {
         return pooledObjects.size();
     }
 
     /**
      * Dispose of this pool. Stops the sweeper and disposes each object in the pool
      */
     public void dispose() {
         shuttingDown = true;
 
         if (sweeper != null) {
             sweeper.stop();
             try {
                 sweeper.join();
             } catch (InterruptedException e) {
                 System.err.println("Unexpected exception occurred: ");
                 e.printStackTrace();
             }
         }
 
         synchronized (this) {
             // use an array here as objects may still be being put back in the pool
             // and we don't want to throw a ConcurrentModificationException
             Object[] objects = pooledObjects.toArray();
 
             for (Object object : objects) {
                 objectDisposed(object);
             }
 
             pooledObjects.clear();
         }
     }
 
     /**
      * A pool has been disposed if has been shutdown and the sweeper has completed running.
      *
      * @return true if the pool has been disposed, false otherwise
      */
     boolean isDisposed() {
         if (!shuttingDown) {
             return false;
         }
 
         // A null sweeper means one was never started.
         if (sweeper == null) {
             return true;
         }
 
         return sweeper.hasStopped();
     }
 
     /**
      * Trim the pool down to min size
      */
     public synchronized void trim() {
         if (((triggerSize > 0) && (pooledObjects.size() >= triggerSize))
                 || ((maxSize > 0) && (pooledObjects.size() >= maxSize))) {
             while (pooledObjects.size() > minSize) {
                 objectDisposed(pooledObjects.remove(0));
             }
         }
     }
 
     /**
      * Override this to be notified of object disposal. Called after the object has been removed. Occurs when the pool
      * is trimmed.
      *
      * @param obj the Object
      */
     public void objectDisposed(Object obj) {}
 
     /**
      * Override this to be notified of object addition. Called before object is to be added.
      *
      * @param obj the Object
      */
     public void objectAdded(Object obj) {}
 
     /**
      * Override this to be notified of object retrieval. Called after object removed from the pool, but before returned
      * to the client.
      *
      * @param obj the Object
      */
     public void objectRetrieved(Object obj) {}
 
     /**
      * Periodically at <code>sweepInterval</code> goes through and tests if the pool should be trimmed.
      *
      * @author bert
      */
     private static class Sweeper implements Runnable {
         private final transient SweeperPool pool;
 
         private transient boolean service = false;
 
         private final transient int sweepInterval;
 
         private transient Thread t = null;
 
         /**
          *
          */
         public Sweeper(SweeperPool pool, int sweepInterval) {
             super();
             this.sweepInterval = sweepInterval;
             this.pool = pool;
         }
 
         /**
          * Run the sweeper.
          *
          * @see java.lang.Runnable#run()
          */
         @Override
         public void run() {
             debug("started");
 
             if (sweepInterval > 0) {
                 synchronized (this) {
                     while (service) {
                         try {
                             // wait specified number of seconds
                             // before running next sweep
                             wait(sweepInterval * 1000);
                         } catch (InterruptedException e) {
                         }
                         runSweep();
                     }
                 }
             }
 
             debug("stopped");
         }
 
         public void start() {
             if (!service) {
                 service = true;
                 t = new Thread(this);
                 t.setName("Sweeper");
                 t.start();
             }
         }
 
         public synchronized void stop() {
             service = false;
             notifyAll();
         }
 
         void join() throws InterruptedException {
             t.join();
         }
 
         boolean hasStopped() {
             return !service && !t.isAlive();
         }
 
         private final void debug(String msg) {
             if (DEBUG) {
                 System.err.println(this + ":" + msg);
             }
         }
 
         private void runSweep() {
             debug("runningSweep. time=" + System.currentTimeMillis());
             pool.trim();
         }
     }
 }