commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ma...@apache.org
Subject svn commit: r1102194 [3/3] - in /commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl: GenericObjectPool.java GenericObjectPoolFactory.java
Date Thu, 12 May 2011 07:54:47 GMT
Modified: commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolFactory.java
URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolFactory.java?rev=1102194&r1=1102193&r2=1102194&view=diff
==============================================================================
--- commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolFactory.java
(original)
+++ commons/proper/pool/trunk/src/java/org/apache/commons/pool2/impl/GenericObjectPoolFactory.java
Thu May 12 07:54:47 2011
@@ -23,193 +23,425 @@ import org.apache.commons.pool2.Poolable
 
 /**
  * A factory for creating {@link GenericObjectPool} instances.
- *
+ * 
  * @see GenericObjectPool
  * @see ObjectPoolFactory
- *
- * @param <T> Type of element pooled in the built pool.
- *
+ * @param <T>
+ *            Type of element pooled in the built pool.
  * @author Rodney Waldhoff
- * @version $Revision$ $Date$
+ * @version $Revision$ $Date: 2011-05-11 14:56:24 +0100 (Wed, 11 May
+ *          2011) $
  * @since Pool 1.0
  */
 public class GenericObjectPoolFactory<T> implements ObjectPoolFactory<T> {
     /**
      * Create a new GenericObjectPoolFactory.
-     *
-     * @param factory the PoolableObjectFactory used by created pools.
+     * 
+     * @param factory
+     *            the PoolableObjectFactory used by created pools.
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory)
      */
     public GenericObjectPoolFactory(PoolableObjectFactory<T> factory) {
-        this(factory,GenericObjectPool.DEFAULT_MAX_ACTIVE,GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION,GenericObjectPool.DEFAULT_MAX_WAIT,GenericObjectPool.DEFAULT_MAX_IDLE,GenericObjectPool.DEFAULT_MIN_IDLE,GenericObjectPool.DEFAULT_TEST_ON_BORROW,GenericObjectPool.DEFAULT_TEST_ON_RETURN,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
+        this(factory, GenericObjectPool.DEFAULT_MAX_ACTIVE,
+                GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION,
+                GenericObjectPool.DEFAULT_MAX_WAIT,
+                GenericObjectPool.DEFAULT_MAX_IDLE,
+                GenericObjectPool.DEFAULT_MIN_IDLE,
+                GenericObjectPool.DEFAULT_TEST_ON_BORROW,
+                GenericObjectPool.DEFAULT_TEST_ON_RETURN,
+                GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
+                GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
+                GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
+                GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
     }
 
     /**
      * Create a new GenericObjectPoolFactory.
-     *
-     * @param factory the PoolableObjectFactory used by created pools.
-     * @param config a non-<code>null</code> GenericObjectPool.Config describing
the configuration.
-     * @throws NullPointerException when config is <code>null</code>.
-     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, GenericObjectPool.Config)
-     */
-    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, GenericObjectPool.Config
config) throws NullPointerException {
-        this(factory,config.maxActive,config.whenExhaustedAction,config.maxWait,config.maxIdle,config.minIdle,config.testOnBorrow,config.testOnReturn,config.timeBetweenEvictionRunsMillis,config.numTestsPerEvictionRun,config.minEvictableIdleTimeMillis,config.testWhileIdle,config.softMinEvictableIdleTimeMillis,
config.lifo);
+     * 
+     * @param factory
+     *            the PoolableObjectFactory used by created pools.
+     * @param config
+     *            a non-<code>null</code> GenericObjectPool.Config describing
+     *            the configuration.
+     * @throws NullPointerException
+     *             when config is <code>null</code>.
+     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory,
+     *      GenericObjectPool.Config)
+     */
+    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
+            GenericObjectPool.Config config) throws NullPointerException {
+        this(factory, config.maxActive, config.whenExhaustedAction,
+                config.maxWait, config.maxIdle, config.minIdle,
+                config.testOnBorrow, config.testOnReturn,
+                config.timeBetweenEvictionRunsMillis,
+                config.numTestsPerEvictionRun,
+                config.minEvictableIdleTimeMillis, config.testWhileIdle,
+                config.softMinEvictableIdleTimeMillis, config.lifo);
     }
 
     /**
      * Create a new GenericObjectPoolFactory.
-     *
-     * @param factory the PoolableObjectFactory used by created pools.
-     * @param maxActive maximum number of objects that can be borrowed from created pools
at one time.
+     * 
+     * @param factory
+     *            the PoolableObjectFactory used by created pools.
+     * @param maxActive
+     *            maximum number of objects that can be borrowed from created
+     *            pools at one time.
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int)
      */
-    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive)
{
-        this(factory,maxActive,GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION,GenericObjectPool.DEFAULT_MAX_WAIT,GenericObjectPool.DEFAULT_MAX_IDLE,GenericObjectPool.DEFAULT_MIN_IDLE,GenericObjectPool.DEFAULT_TEST_ON_BORROW,GenericObjectPool.DEFAULT_TEST_ON_RETURN,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
-    }
-
-    /**
-     * Create a new GenericObjectPoolFactory.
-     *
-     * @param factory the PoolableObjectFactory used by created pools.
-     * @param maxActive maximum number of objects that can be borrowed from created pools
at one time.
-     * @param whenExhaustedAction the action to take when the pool is exhausted.
-     * @param maxWait the maximum amount of time to wait for an idle object when the pool
is exhausted.
-     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long)
-     */
-    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive,
byte whenExhaustedAction, long maxWait) {
-        this(factory,maxActive,whenExhaustedAction,maxWait,GenericObjectPool.DEFAULT_MAX_IDLE,GenericObjectPool.DEFAULT_MIN_IDLE,GenericObjectPool.DEFAULT_TEST_ON_BORROW,GenericObjectPool.DEFAULT_TEST_ON_RETURN,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
-    }
-
-    /**
-     * Create a new GenericObjectPoolFactory.
-     *
-     * @param factory the PoolableObjectFactory used by created pools.
-     * @param maxActive maximum number of objects that can be borrowed from created pools
at one time.
-     * @param whenExhaustedAction the action to take when the pool is exhausted.
-     * @param maxWait the maximum amount of time to wait for an idle object when the pool
is exhausted.
-     * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
-     * @param testOnReturn whether to validate objects after they are returned to the returnObject.
-     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, boolean,
boolean)
-     */
-    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive,
byte whenExhaustedAction, long maxWait, boolean testOnBorrow, boolean testOnReturn) {
-        this(factory,maxActive,whenExhaustedAction,maxWait,GenericObjectPool.DEFAULT_MAX_IDLE,GenericObjectPool.DEFAULT_MIN_IDLE,testOnBorrow,testOnReturn,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
-    }
-
-    /**
-     * Create a new GenericObjectPoolFactory.
-     *
-     * @param factory the PoolableObjectFactory used by created pools.
-     * @param maxActive maximum number of objects that can be borrowed from created pools
at one time.
-     * @param whenExhaustedAction the action to take when the pool is exhausted.
-     * @param maxWait the maximum amount of time to wait for an idle object when the pool
is exhausted.
-     * @param maxIdle the maximum number of idle objects in my pool.
-     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int)
-     */
-    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive,
byte whenExhaustedAction, long maxWait, int maxIdle) {
-        this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,GenericObjectPool.DEFAULT_MIN_IDLE,GenericObjectPool.DEFAULT_TEST_ON_BORROW,GenericObjectPool.DEFAULT_TEST_ON_RETURN,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
-    }
-
-    /**
-     * Create a new GenericObjectPoolFactory.
-     *
-     * @param factory the PoolableObjectFactory used by created pools.
-     * @param maxActive maximum number of objects that can be borrowed from created pools
at one time.
-     * @param whenExhaustedAction the action to take when the pool is exhausted.
-     * @param maxWait the maximum amount of time to wait for an idle object when the pool
is exhausted.
-     * @param maxIdle the maximum number of idle objects in my pool.
-     * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
-     * @param testOnReturn whether to validate objects after they are returned to the returnObject.
-     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int,
boolean, boolean)
-     */
-    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive,
byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn)
{
-        this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,GenericObjectPool.DEFAULT_MIN_IDLE,testOnBorrow,testOnReturn,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
-    }
-
-    /**
-     * Create a new GenericObjectPoolFactory.
-     *
-     * @param factory the PoolableObjectFactory used by created pools.
-     * @param maxActive maximum number of objects that can be borrowed from created pools
at one time.
-     * @param whenExhaustedAction the action to take when the pool is exhausted.
-     * @param maxWait the maximum amount of time to wait for an idle object when the pool
is exhausted.
-     * @param maxIdle the maximum number of idle objects in my pool.
-     * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
-     * @param testOnReturn whether to validate objects after they are returned to the returnObject.
-     * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining
idle objects for eviction.
-     * @param numTestsPerEvictionRun the number of idle objects to examine per run within
the idle object eviction thread.
-     * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can
sit idle in the pool before it is eligible for eviction.
-     * @param testWhileIdle whether or not to validate objects in the idle object eviction
thread.
-     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int,
boolean, boolean, long, int, long, boolean)
-     */
-    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive,
byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn,
long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis,
boolean testWhileIdle) {
-        this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,GenericObjectPool.DEFAULT_MIN_IDLE,testOnBorrow,testOnReturn,timeBetweenEvictionRunsMillis,numTestsPerEvictionRun,minEvictableIdleTimeMillis,testWhileIdle,
GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
-    }
-
-    /**
-     * Create a new GenericObjectPoolFactory.
-     *
-     * @param factory the PoolableObjectFactory used by created pools.
-     * @param maxActive maximum number of objects that can be borrowed from created pools
at one time.
-     * @param whenExhaustedAction the action to take when the pool is exhausted.
-     * @param maxWait the maximum amount of time to wait for an idle object when the pool
is exhausted.
-     * @param maxIdle the maximum number of idle objects in my pool.
-     * @param minIdle the minimum number of idle objects in my pool.
-     * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
-     * @param testOnReturn whether to validate objects after they are returned to the returnObject.
-     * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining
idle objects for eviction.
-     * @param numTestsPerEvictionRun the number of idle objects to examine per run within
the idle object eviction thread.
-     * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can
sit idle in the pool before it is eligible for eviction.
-     * @param testWhileIdle whether or not to validate objects in the idle object eviction
thread.
-     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int,
int, boolean, boolean, long, int, long, boolean)
-     */
-    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive,
byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean
testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis,
boolean testWhileIdle) {
-        this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,minIdle,testOnBorrow,testOnReturn,timeBetweenEvictionRunsMillis,numTestsPerEvictionRun,minEvictableIdleTimeMillis,testWhileIdle,
GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
-    }
-
-    /**
-     * Create a new GenericObjectPoolFactory.
-     *
-     * @param factory the PoolableObjectFactory used by created pools.
-     * @param maxActive maximum number of objects that can be borrowed from created pools
at one time.
-     * @param whenExhaustedAction the action to take when the pool is exhausted.
-     * @param maxWait the maximum amount of time to wait for an idle object when the pool
is exhausted.
-     * @param maxIdle the maximum number of idle objects in my pool.
-     * @param minIdle the minimum number of idle objects in my pool.
-     * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
-     * @param testOnReturn whether to validate objects after they are returned to the returnObject.
-     * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining
idle objects for eviction.
-     * @param numTestsPerEvictionRun the number of idle objects to examine per run within
the idle object eviction thread.
-     * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can
sit idle in the pool before it is eligible for eviction.
-     * @param testWhileIdle whether or not to validate objects in the idle object eviction
thread.
-     * @param softMinEvictableIdleTimeMillis the minimum number of milliseconds an object
can sit idle in the pool before it is eligible for eviction with the extra condition that
at least "minIdle" amount of object remain in the pool.
+    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
+            int maxActive) {
+        this(factory, maxActive,
+                GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION,
+                GenericObjectPool.DEFAULT_MAX_WAIT,
+                GenericObjectPool.DEFAULT_MAX_IDLE,
+                GenericObjectPool.DEFAULT_MIN_IDLE,
+                GenericObjectPool.DEFAULT_TEST_ON_BORROW,
+                GenericObjectPool.DEFAULT_TEST_ON_RETURN,
+                GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
+                GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
+                GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
+                GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
+    }
+
+    /**
+     * Create a new GenericObjectPoolFactory.
+     * 
+     * @param factory
+     *            the PoolableObjectFactory used by created pools.
+     * @param maxActive
+     *            maximum number of objects that can be borrowed from created
+     *            pools at one time.
+     * @param whenExhaustedAction
+     *            the action to take when the pool is exhausted.
+     * @param maxWait
+     *            the maximum amount of time to wait for an idle object when the
+     *            pool is exhausted.
+     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
+     *      byte, long)
+     */
+    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
+            int maxActive, byte whenExhaustedAction, long maxWait) {
+        this(factory, maxActive, whenExhaustedAction, maxWait,
+                GenericObjectPool.DEFAULT_MAX_IDLE,
+                GenericObjectPool.DEFAULT_MIN_IDLE,
+                GenericObjectPool.DEFAULT_TEST_ON_BORROW,
+                GenericObjectPool.DEFAULT_TEST_ON_RETURN,
+                GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
+                GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
+                GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
+                GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
+    }
+
+    /**
+     * Create a new GenericObjectPoolFactory.
+     * 
+     * @param factory
+     *            the PoolableObjectFactory used by created pools.
+     * @param maxActive
+     *            maximum number of objects that can be borrowed from created
+     *            pools at one time.
+     * @param whenExhaustedAction
+     *            the action to take when the pool is exhausted.
+     * @param maxWait
+     *            the maximum amount of time to wait for an idle object when the
+     *            pool is exhausted.
+     * @param testOnBorrow
+     *            whether to validate objects before they are returned by the
+     *            borrowObject.
+     * @param testOnReturn
+     *            whether to validate objects after they are returned to the
+     *            returnObject.
+     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
+     *      byte, long, boolean, boolean)
+     */
+    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
+            int maxActive, byte whenExhaustedAction, long maxWait,
+            boolean testOnBorrow, boolean testOnReturn) {
+        this(factory, maxActive, whenExhaustedAction, maxWait,
+                GenericObjectPool.DEFAULT_MAX_IDLE,
+                GenericObjectPool.DEFAULT_MIN_IDLE, testOnBorrow, testOnReturn,
+                GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
+                GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
+                GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
+                GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
+    }
+
+    /**
+     * Create a new GenericObjectPoolFactory.
+     * 
+     * @param factory
+     *            the PoolableObjectFactory used by created pools.
+     * @param maxActive
+     *            maximum number of objects that can be borrowed from created
+     *            pools at one time.
+     * @param whenExhaustedAction
+     *            the action to take when the pool is exhausted.
+     * @param maxWait
+     *            the maximum amount of time to wait for an idle object when the
+     *            pool is exhausted.
+     * @param maxIdle
+     *            the maximum number of idle objects in my pool.
+     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
+     *      byte, long, int)
+     */
+    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
+            int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle) {
+        this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
+                GenericObjectPool.DEFAULT_MIN_IDLE,
+                GenericObjectPool.DEFAULT_TEST_ON_BORROW,
+                GenericObjectPool.DEFAULT_TEST_ON_RETURN,
+                GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
+                GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
+                GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
+                GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
+    }
+
+    /**
+     * Create a new GenericObjectPoolFactory.
+     * 
+     * @param factory
+     *            the PoolableObjectFactory used by created pools.
+     * @param maxActive
+     *            maximum number of objects that can be borrowed from created
+     *            pools at one time.
+     * @param whenExhaustedAction
+     *            the action to take when the pool is exhausted.
+     * @param maxWait
+     *            the maximum amount of time to wait for an idle object when the
+     *            pool is exhausted.
+     * @param maxIdle
+     *            the maximum number of idle objects in my pool.
+     * @param testOnBorrow
+     *            whether to validate objects before they are returned by the
+     *            borrowObject.
+     * @param testOnReturn
+     *            whether to validate objects after they are returned to the
+     *            returnObject.
+     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
+     *      byte, long, int, boolean, boolean)
+     */
+    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
+            int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle,
+            boolean testOnBorrow, boolean testOnReturn) {
+        this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
+                GenericObjectPool.DEFAULT_MIN_IDLE, testOnBorrow, testOnReturn,
+                GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
+                GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
+                GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
+                GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
+    }
+
+    /**
+     * Create a new GenericObjectPoolFactory.
+     * 
+     * @param factory
+     *            the PoolableObjectFactory used by created pools.
+     * @param maxActive
+     *            maximum number of objects that can be borrowed from created
+     *            pools at one time.
+     * @param whenExhaustedAction
+     *            the action to take when the pool is exhausted.
+     * @param maxWait
+     *            the maximum amount of time to wait for an idle object when the
+     *            pool is exhausted.
+     * @param maxIdle
+     *            the maximum number of idle objects in my pool.
+     * @param testOnBorrow
+     *            whether to validate objects before they are returned by the
+     *            borrowObject.
+     * @param testOnReturn
+     *            whether to validate objects after they are returned to the
+     *            returnObject.
+     * @param timeBetweenEvictionRunsMillis
+     *            the number of milliseconds to sleep between examining idle
+     *            objects for eviction.
+     * @param numTestsPerEvictionRun
+     *            the number of idle objects to examine per run within the idle
+     *            object eviction thread.
+     * @param minEvictableIdleTimeMillis
+     *            the minimum number of milliseconds an object can sit idle in
+     *            the pool before it is eligible for eviction.
+     * @param testWhileIdle
+     *            whether or not to validate objects in the idle object eviction
+     *            thread.
+     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
+     *      byte, long, int, boolean, boolean, long, int, long, boolean)
+     */
+    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
+            int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle,
+            boolean testOnBorrow, boolean testOnReturn,
+            long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun,
+            long minEvictableIdleTimeMillis, boolean testWhileIdle) {
+        this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
+                GenericObjectPool.DEFAULT_MIN_IDLE, testOnBorrow, testOnReturn,
+                timeBetweenEvictionRunsMillis, numTestsPerEvictionRun,
+                minEvictableIdleTimeMillis, testWhileIdle,
+                GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
+    }
+
+    /**
+     * Create a new GenericObjectPoolFactory.
+     * 
+     * @param factory
+     *            the PoolableObjectFactory used by created pools.
+     * @param maxActive
+     *            maximum number of objects that can be borrowed from created
+     *            pools at one time.
+     * @param whenExhaustedAction
+     *            the action to take when the pool is exhausted.
+     * @param maxWait
+     *            the maximum amount of time to wait for an idle object when the
+     *            pool is exhausted.
+     * @param maxIdle
+     *            the maximum number of idle objects in my pool.
+     * @param minIdle
+     *            the minimum number of idle objects in my pool.
+     * @param testOnBorrow
+     *            whether to validate objects before they are returned by the
+     *            borrowObject.
+     * @param testOnReturn
+     *            whether to validate objects after they are returned to the
+     *            returnObject.
+     * @param timeBetweenEvictionRunsMillis
+     *            the number of milliseconds to sleep between examining idle
+     *            objects for eviction.
+     * @param numTestsPerEvictionRun
+     *            the number of idle objects to examine per run within the idle
+     *            object eviction thread.
+     * @param minEvictableIdleTimeMillis
+     *            the minimum number of milliseconds an object can sit idle in
+     *            the pool before it is eligible for eviction.
+     * @param testWhileIdle
+     *            whether or not to validate objects in the idle object eviction
+     *            thread.
+     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
+     *      byte, long, int, int, boolean, boolean, long, int, long, boolean)
+     */
+    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
+            int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle,
+            int minIdle, boolean testOnBorrow, boolean testOnReturn,
+            long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun,
+            long minEvictableIdleTimeMillis, boolean testWhileIdle) {
+        this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
+                minIdle, testOnBorrow, testOnReturn,
+                timeBetweenEvictionRunsMillis, numTestsPerEvictionRun,
+                minEvictableIdleTimeMillis, testWhileIdle,
+                GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
+    }
+
+    /**
+     * Create a new GenericObjectPoolFactory.
+     * 
+     * @param factory
+     *            the PoolableObjectFactory used by created pools.
+     * @param maxActive
+     *            maximum number of objects that can be borrowed from created
+     *            pools at one time.
+     * @param whenExhaustedAction
+     *            the action to take when the pool is exhausted.
+     * @param maxWait
+     *            the maximum amount of time to wait for an idle object when the
+     *            pool is exhausted.
+     * @param maxIdle
+     *            the maximum number of idle objects in my pool.
+     * @param minIdle
+     *            the minimum number of idle objects in my pool.
+     * @param testOnBorrow
+     *            whether to validate objects before they are returned by the
+     *            borrowObject.
+     * @param testOnReturn
+     *            whether to validate objects after they are returned to the
+     *            returnObject.
+     * @param timeBetweenEvictionRunsMillis
+     *            the number of milliseconds to sleep between examining idle
+     *            objects for eviction.
+     * @param numTestsPerEvictionRun
+     *            the number of idle objects to examine per run within the idle
+     *            object eviction thread.
+     * @param minEvictableIdleTimeMillis
+     *            the minimum number of milliseconds an object can sit idle in
+     *            the pool before it is eligible for eviction.
+     * @param testWhileIdle
+     *            whether or not to validate objects in the idle object eviction
+     *            thread.
+     * @param softMinEvictableIdleTimeMillis
+     *            the minimum number of milliseconds an object can sit idle in
+     *            the pool before it is eligible for eviction with the extra
+     *            condition that at least "minIdle" amount of object remain in
+     *            the pool.
      * @since Pool 1.3
-     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int,
int, boolean, boolean, long, int, long, boolean, long)
-     */
-    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive,
byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean
testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis,
boolean testWhileIdle, long softMinEvictableIdleTimeMillis) {
-        this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,minIdle,testOnBorrow,testOnReturn,timeBetweenEvictionRunsMillis,numTestsPerEvictionRun,minEvictableIdleTimeMillis,testWhileIdle,softMinEvictableIdleTimeMillis,
GenericObjectPool.DEFAULT_LIFO);
+     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
+     *      byte, long, int, int, boolean, boolean, long, int, long, boolean,
+     *      long)
+     */
+    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
+            int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle,
+            int minIdle, boolean testOnBorrow, boolean testOnReturn,
+            long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun,
+            long minEvictableIdleTimeMillis, boolean testWhileIdle,
+            long softMinEvictableIdleTimeMillis) {
+        this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle,
+                minIdle, testOnBorrow, testOnReturn,
+                timeBetweenEvictionRunsMillis, numTestsPerEvictionRun,
+                minEvictableIdleTimeMillis, testWhileIdle,
+                softMinEvictableIdleTimeMillis, GenericObjectPool.DEFAULT_LIFO);
     }
 
     /**
      * Create a new GenericObjectPoolFactory.
-     *
-     * @param factory the PoolableObjectFactory used by created pools.
-     * @param maxActive maximum number of objects that can be borrowed from created pools
at one time.
-     * @param whenExhaustedAction the action to take when the pool is exhausted.
-     * @param maxWait the maximum amount of time to wait for an idle object when the pool
is exhausted.
-     * @param maxIdle the maximum number of idle objects in my pool.
-     * @param minIdle the minimum number of idle objects in my pool.
-     * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
-     * @param testOnReturn whether to validate objects after they are returned to the returnObject.
-     * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining
idle objects for eviction.
-     * @param numTestsPerEvictionRun the number of idle objects to examine per run within
the idle object eviction thread.
-     * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can
sit idle in the pool before it is eligible for eviction.
-     * @param testWhileIdle whether or not to validate objects in the idle object eviction
thread.
-     * @param softMinEvictableIdleTimeMillis the minimum number of milliseconds an object
can sit idle in the pool before it is eligible for eviction with the extra condition that
at least "minIdle" amount of object remain in the pool.
-     * @param lifo whether or not objects are returned in last-in-first-out order from the
idle object pool.
+     * 
+     * @param factory
+     *            the PoolableObjectFactory used by created pools.
+     * @param maxActive
+     *            maximum number of objects that can be borrowed from created
+     *            pools at one time.
+     * @param whenExhaustedAction
+     *            the action to take when the pool is exhausted.
+     * @param maxWait
+     *            the maximum amount of time to wait for an idle object when the
+     *            pool is exhausted.
+     * @param maxIdle
+     *            the maximum number of idle objects in my pool.
+     * @param minIdle
+     *            the minimum number of idle objects in my pool.
+     * @param testOnBorrow
+     *            whether to validate objects before they are returned by the
+     *            borrowObject.
+     * @param testOnReturn
+     *            whether to validate objects after they are returned to the
+     *            returnObject.
+     * @param timeBetweenEvictionRunsMillis
+     *            the number of milliseconds to sleep between examining idle
+     *            objects for eviction.
+     * @param numTestsPerEvictionRun
+     *            the number of idle objects to examine per run within the idle
+     *            object eviction thread.
+     * @param minEvictableIdleTimeMillis
+     *            the minimum number of milliseconds an object can sit idle in
+     *            the pool before it is eligible for eviction.
+     * @param testWhileIdle
+     *            whether or not to validate objects in the idle object eviction
+     *            thread.
+     * @param softMinEvictableIdleTimeMillis
+     *            the minimum number of milliseconds an object can sit idle in
+     *            the pool before it is eligible for eviction with the extra
+     *            condition that at least "minIdle" amount of object remain in
+     *            the pool.
+     * @param lifo
+     *            whether or not objects are returned in last-in-first-out order
+     *            from the idle object pool.
      * @since Pool 1.4
-     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int,
int, boolean, boolean, long, int, long, boolean, long, boolean)
-     */
-    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive,
byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean
testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis,
boolean testWhileIdle, long softMinEvictableIdleTimeMillis, boolean lifo) {
+     * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int,
+     *      byte, long, int, int, boolean, boolean, long, int, long, boolean,
+     *      long, boolean)
+     */
+    public GenericObjectPoolFactory(PoolableObjectFactory<T> factory,
+            int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle,
+            int minIdle, boolean testOnBorrow, boolean testOnReturn,
+            long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun,
+            long minEvictableIdleTimeMillis, boolean testWhileIdle,
+            long softMinEvictableIdleTimeMillis, boolean lifo) {
         _maxIdle = maxIdle;
         _minIdle = minIdle;
         _maxActive = maxActive;
@@ -230,12 +462,16 @@ public class GenericObjectPoolFactory<T>
      * {@inheritDoc}
      */
     public ObjectPool<T> createPool() {
-        return new GenericObjectPool<T>(_factory,_maxActive,_whenExhaustedAction,_maxWait,_maxIdle,_minIdle,_testOnBorrow,_testOnReturn,_timeBetweenEvictionRunsMillis,_numTestsPerEvictionRun,_minEvictableIdleTimeMillis,_testWhileIdle,_softMinEvictableIdleTimeMillis,_lifo);
+        return new GenericObjectPool<T>(_factory, _maxActive,
+                _whenExhaustedAction, _maxWait, _maxIdle, _minIdle,
+                _testOnBorrow, _testOnReturn, _timeBetweenEvictionRunsMillis,
+                _numTestsPerEvictionRun, _minEvictableIdleTimeMillis,
+                _testWhileIdle, _softMinEvictableIdleTimeMillis, _lifo);
     }
 
-    
     /**
-     * @return the {@link GenericObjectPool#getMaxIdle() maxIdle} setting for pools created
by this factory.
+     * @return the {@link GenericObjectPool#getMaxIdle() maxIdle} setting for
+     *         pools created by this factory.
      * @since 1.5.5
      */
     public int getMaxIdle() {
@@ -243,7 +479,8 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getMinIdle() minIdle} setting for pools created
by this factory.
+     * @return the {@link GenericObjectPool#getMinIdle() minIdle} setting for
+     *         pools created by this factory.
      * @since 1.5.5
      */
     public int getMinIdle() {
@@ -251,7 +488,8 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getMaxActive() maxActive} setting for pools created
by this factory.
+     * @return the {@link GenericObjectPool#getMaxActive() maxActive} setting
+     *         for pools created by this factory.
      * @since 1.5.5
      */
     public int getMaxActive() {
@@ -259,7 +497,8 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getMaxWait() maxWait} setting for pools created
by this factory.
+     * @return the {@link GenericObjectPool#getMaxWait() maxWait} setting for
+     *         pools created by this factory.
      * @since 1.5.5
      */
     public long getMaxWait() {
@@ -267,8 +506,8 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getWhenExhaustedAction() whenExhaustedAction}
setting for pools
-     * created by this factory.
+     * @return the {@link GenericObjectPool#getWhenExhaustedAction()
+     *         whenExhaustedAction} setting for pools created by this factory.
      * @since 1.5.5
      */
     public byte getWhenExhaustedAction() {
@@ -276,8 +515,8 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getTestOnBorrow() testOnBorrow} setting for pools
-     * created by this factory.
+     * @return the {@link GenericObjectPool#getTestOnBorrow() testOnBorrow}
+     *         setting for pools created by this factory.
      * @since 1.5.5
      */
     public boolean getTestOnBorrow() {
@@ -285,8 +524,8 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getTestOnReturn() testOnReturn} setting for pools
-     * created by this factory.
+     * @return the {@link GenericObjectPool#getTestOnReturn() testOnReturn}
+     *         setting for pools created by this factory.
      * @since 1.5.5
      */
     public boolean getTestOnReturn() {
@@ -294,8 +533,8 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getTestWhileIdle() testWhileIdle} setting for
pools
-     * created by this factory.
+     * @return the {@link GenericObjectPool#getTestWhileIdle() testWhileIdle}
+     *         setting for pools created by this factory.
      * @since 1.5.5
      */
     public boolean getTestWhileIdle() {
@@ -303,8 +542,9 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis() timeBetweenEvictionRunsMillis}
-     * setting for pools created by this factory.
+     * @return the {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis()
+     *         timeBetweenEvictionRunsMillis} setting for pools created by this
+     *         factory.
      * @since 1.5.5
      */
     public long getTimeBetweenEvictionRunsMillis() {
@@ -312,8 +552,9 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getNumTestsPerEvictionRun() numTestsPerEvictionRun}
-     * setting for pools created by this factory.
+     * @return the {@link GenericObjectPool#getNumTestsPerEvictionRun()
+     *         numTestsPerEvictionRun} setting for pools created by this
+     *         factory.
      * @since 1.5.5
      */
     public int getNumTestsPerEvictionRun() {
@@ -321,8 +562,9 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getMinEvictableIdleTimeMillis() minEvictableIdleTimeMillis}
-     * setting for pools created by this factory.
+     * @return the {@link GenericObjectPool#getMinEvictableIdleTimeMillis()
+     *         minEvictableIdleTimeMillis} setting for pools created by this
+     *         factory.
      * @since 1.5.5
      */
     public long getMinEvictableIdleTimeMillis() {
@@ -330,8 +572,9 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis() softMinEvicatableIdleTimeMillis}
-     * setting for pools created by this factory.
+     * @return the {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis()
+     *         softMinEvicatableIdleTimeMillis} setting for pools created by
+     *         this factory.
      * @since 1.5.5
      */
     public long getSoftMinEvictableIdleTimeMillis() {
@@ -339,7 +582,8 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link GenericObjectPool#getLifo() lifo} setting for pools created by
this factory.
+     * @return the {@link GenericObjectPool#getLifo() lifo} setting for pools
+     *         created by this factory.
      * @since 1.5.5
      */
     public boolean getLifo() {
@@ -347,82 +591,97 @@ public class GenericObjectPoolFactory<T>
     }
 
     /**
-     * @return the {@link PoolableObjectFactory} used by pools created by this factory
+     * @return the {@link PoolableObjectFactory} used by pools created by this
+     *         factory
      */
     public PoolableObjectFactory<T> getFactory() {
         return _factory;
     }
-  
+
     /**
-     * The {@link GenericObjectPool#getMaxIdle() maxIdle} setting for pools created by this
factory.
+     * The {@link GenericObjectPool#getMaxIdle() maxIdle} setting for pools
+     * created by this factory.
      */
     private int _maxIdle = GenericObjectPool.DEFAULT_MAX_IDLE;
-    
+
     /**
-     * The {@link GenericObjectPool#getMinIdle() minIdle} setting for pools created by this
factory.
+     * The {@link GenericObjectPool#getMinIdle() minIdle} setting for pools
+     * created by this factory.
      */
     private int _minIdle = GenericObjectPool.DEFAULT_MIN_IDLE;
-    
+
     /**
-     * The {@link GenericObjectPool#getMaxActive() maxActive} setting for pools created by
this factory.
+     * The {@link GenericObjectPool#getMaxActive() maxActive} setting for pools
+     * created by this factory.
      */
     private int _maxActive = GenericObjectPool.DEFAULT_MAX_ACTIVE;
-    
+
     /**
-     * The {@link GenericObjectPool#getMaxWait() maxWait} setting for pools created by this
factory.
+     * The {@link GenericObjectPool#getMaxWait() maxWait} setting for pools
+     * created by this factory.
      */
     private long _maxWait = GenericObjectPool.DEFAULT_MAX_WAIT;
-    
+
     /**
-     * The {@link GenericObjectPool#getWhenExhaustedAction() whenExhaustedAction} setting
for pools
-     * created by this factory.
+     * The {@link GenericObjectPool#getWhenExhaustedAction()
+     * whenExhaustedAction} setting for pools created by this factory.
      */
-    private byte _whenExhaustedAction = GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION;
-    
+    private byte _whenExhaustedAction =
+        GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION;
+
     /**
-     * The {@link GenericObjectPool#getTestOnBorrow() testOnBorrow} setting for pools created
by this factory.
+     * The {@link GenericObjectPool#getTestOnBorrow() testOnBorrow} setting for
+     * pools created by this factory.
      */
     private boolean _testOnBorrow = GenericObjectPool.DEFAULT_TEST_ON_BORROW;
-    
+
     /**
-     * The {@link GenericObjectPool#getTestOnReturn() testOnReturn} setting for pools created
by this factory.
+     * The {@link GenericObjectPool#getTestOnReturn() testOnReturn} setting for
+     * pools created by this factory.
      */
     private boolean _testOnReturn = GenericObjectPool.DEFAULT_TEST_ON_RETURN;
-    
+
     /**
-     * The {@link GenericObjectPool#getTestWhileIdle() testWhileIdle} setting for pools created
by this factory.
+     * The {@link GenericObjectPool#getTestWhileIdle() testWhileIdle} setting
+     * for pools created by this factory.
      */
     private boolean _testWhileIdle = GenericObjectPool.DEFAULT_TEST_WHILE_IDLE;
-    
+
     /**
-     * The {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis() timeBetweenEvictionRunsMillis}
-     * setting for pools created by this factory.
+     * The {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis()
+     * timeBetweenEvictionRunsMillis} setting for pools created by this factory.
      */
-    private long _timeBetweenEvictionRunsMillis = GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
-    
+    private long _timeBetweenEvictionRunsMillis =
+        GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
+
     /**
-     * The {@link GenericObjectPool#getNumTestsPerEvictionRun() numTestsPerEvictionRun} setting
-     * for pools created by this factory.
+     * The {@link GenericObjectPool#getNumTestsPerEvictionRun()
+     * numTestsPerEvictionRun} setting for pools created by this factory.
      */
-    private int _numTestsPerEvictionRun =  GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN;
-    
+    private int _numTestsPerEvictionRun =
+        GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN;
+
     /**
-     * The {@link GenericObjectPool#getMinEvictableIdleTimeMillis() minEvictableIdleTimeMillis}
-     * setting for pools created by this factory.
+     * The {@link GenericObjectPool#getMinEvictableIdleTimeMillis()
+     * minEvictableIdleTimeMillis} setting for pools created by this factory.
      */
-    private long _minEvictableIdleTimeMillis = GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
-    
+    private long _minEvictableIdleTimeMillis =
+        GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
+
     /**
-     * The {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis() softMinEvictableIdleTimeMillis}
-     * setting for pools created by this factory.
+     * The {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis()
+     * softMinEvictableIdleTimeMillis} setting for pools created by this
+     * factory.
      */
-    private long _softMinEvictableIdleTimeMillis = GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
-    
+    private long _softMinEvictableIdleTimeMillis =
+        GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
+
     /**
-     * The {@link GenericObjectPool#getLifo() lifo} setting for pools created by this factory.
+     * The {@link GenericObjectPool#getLifo() lifo} setting for pools created by
+     * this factory.
      */
     private boolean _lifo = GenericObjectPool.DEFAULT_LIFO;
-    
+
     /**
      * The {@link PoolableObjectFactory} used by pools created by this factory.
      */



Mime
View raw message