Coverage Report - org.apache.commons.pool.impl.GenericObjectPoolFactory
 
Classes in this File Line Coverage Branch Coverage Complexity
GenericObjectPoolFactory
0%
0/65
N/A
1
 
 1  
 /*
 2  
  * Licensed to the Apache Software Foundation (ASF) under one or more
 3  
  * contributor license agreements.  See the NOTICE file distributed with
 4  
  * this work for additional information regarding copyright ownership.
 5  
  * The ASF licenses this file to You under the Apache License, Version 2.0
 6  
  * (the "License"); you may not use this file except in compliance with
 7  
  * the License.  You may obtain a copy of the License at
 8  
  *
 9  
  *      http://www.apache.org/licenses/LICENSE-2.0
 10  
  *
 11  
  * Unless required by applicable law or agreed to in writing, software
 12  
  * distributed under the License is distributed on an "AS IS" BASIS,
 13  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14  
  * See the License for the specific language governing permissions and
 15  
  * limitations under the License.
 16  
  */
 17  
 
 18  
 package org.apache.commons.pool.impl;
 19  
 
 20  
 import org.apache.commons.pool.ObjectPool;
 21  
 import org.apache.commons.pool.ObjectPoolFactory;
 22  
 import org.apache.commons.pool.PoolableObjectFactory;
 23  
 
 24  
 /**
 25  
  * A factory for creating {@link GenericObjectPool} instances.
 26  
  *
 27  
  * @see GenericObjectPool
 28  
  * @see ObjectPoolFactory
 29  
  *
 30  
  * @author Rodney Waldhoff
 31  
  * @version $Revision: 965326 $ $Date: 2010-07-18 16:49:04 -0700 (Sun, 18 Jul 2010) $
 32  
  * @since Pool 1.0
 33  
  */
 34  
 public class GenericObjectPoolFactory implements ObjectPoolFactory {
 35  
     /**
 36  
      * Create a new GenericObjectPoolFactory.
 37  
      *
 38  
      * @param factory the PoolableObjectFactory used by created pools.
 39  
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory)
 40  
      */
 41  
     public GenericObjectPoolFactory(PoolableObjectFactory factory) {
 42  0
         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);
 43  0
     }
 44  
 
 45  
     /**
 46  
      * Create a new GenericObjectPoolFactory.
 47  
      *
 48  
      * @param factory the PoolableObjectFactory used by created pools.
 49  
      * @param config a non-<code>null</code> GenericObjectPool.Config describing the configuration.
 50  
      * @throws NullPointerException when config is <code>null</code>.
 51  
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, GenericObjectPool.Config)
 52  
      */
 53  
     public GenericObjectPoolFactory(PoolableObjectFactory factory, GenericObjectPool.Config config) throws NullPointerException {
 54  0
         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);
 55  0
     }
 56  
 
 57  
     /**
 58  
      * Create a new GenericObjectPoolFactory.
 59  
      *
 60  
      * @param factory the PoolableObjectFactory used by created pools.
 61  
      * @param maxActive maximum number of objects that can be borrowed from created pools at one time.
 62  
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int)
 63  
      */
 64  
     public GenericObjectPoolFactory(PoolableObjectFactory factory, int maxActive) {
 65  0
         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);
 66  0
     }
 67  
 
 68  
     /**
 69  
      * Create a new GenericObjectPoolFactory.
 70  
      *
 71  
      * @param factory the PoolableObjectFactory used by created pools.
 72  
      * @param maxActive maximum number of objects that can be borrowed from created pools at one time.
 73  
      * @param whenExhaustedAction the action to take when the pool is exhausted.
 74  
      * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
 75  
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long)
 76  
      */
 77  
     public GenericObjectPoolFactory(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait) {
 78  0
         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);
 79  0
     }
 80  
 
 81  
     /**
 82  
      * Create a new GenericObjectPoolFactory.
 83  
      *
 84  
      * @param factory the PoolableObjectFactory used by created pools.
 85  
      * @param maxActive maximum number of objects that can be borrowed from created pools at one time.
 86  
      * @param whenExhaustedAction the action to take when the pool is exhausted.
 87  
      * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
 88  
      * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
 89  
      * @param testOnReturn whether to validate objects after they are returned to the returnObject.
 90  
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, boolean, boolean)
 91  
      */
 92  
     public GenericObjectPoolFactory(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, boolean testOnBorrow, boolean testOnReturn) {
 93  0
         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);
 94  0
     }
 95  
 
 96  
     /**
 97  
      * Create a new GenericObjectPoolFactory.
 98  
      *
 99  
      * @param factory the PoolableObjectFactory used by created pools.
 100  
      * @param maxActive maximum number of objects that can be borrowed from created pools at one time.
 101  
      * @param whenExhaustedAction the action to take when the pool is exhausted.
 102  
      * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
 103  
      * @param maxIdle the maximum number of idle objects in my pool.
 104  
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int)
 105  
      */
 106  
     public GenericObjectPoolFactory(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle) {
 107  0
         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);
 108  0
     }
 109  
 
 110  
     /**
 111  
      * Create a new GenericObjectPoolFactory.
 112  
      *
 113  
      * @param factory the PoolableObjectFactory used by created pools.
 114  
      * @param maxActive maximum number of objects that can be borrowed from created pools at one time.
 115  
      * @param whenExhaustedAction the action to take when the pool is exhausted.
 116  
      * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
 117  
      * @param maxIdle the maximum number of idle objects in my pool.
 118  
      * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
 119  
      * @param testOnReturn whether to validate objects after they are returned to the returnObject.
 120  
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int, boolean, boolean)
 121  
      */
 122  
     public GenericObjectPoolFactory(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn) {
 123  0
         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);
 124  0
     }
 125  
 
 126  
     /**
 127  
      * Create a new GenericObjectPoolFactory.
 128  
      *
 129  
      * @param factory the PoolableObjectFactory used by created pools.
 130  
      * @param maxActive maximum number of objects that can be borrowed from created pools at one time.
 131  
      * @param whenExhaustedAction the action to take when the pool is exhausted.
 132  
      * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
 133  
      * @param maxIdle the maximum number of idle objects in my pool.
 134  
      * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
 135  
      * @param testOnReturn whether to validate objects after they are returned to the returnObject.
 136  
      * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction.
 137  
      * @param numTestsPerEvictionRun the number of idle objects to examine per run within the idle object eviction thread.
 138  
      * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction.
 139  
      * @param testWhileIdle whether or not to validate objects in the idle object eviction thread.
 140  
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int, boolean, boolean, long, int, long, boolean)
 141  
      */
 142  
     public GenericObjectPoolFactory(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle) {
 143  0
         this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,GenericObjectPool.DEFAULT_MIN_IDLE,testOnBorrow,testOnReturn,timeBetweenEvictionRunsMillis,numTestsPerEvictionRun,minEvictableIdleTimeMillis,testWhileIdle, GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
 144  0
     }
 145  
 
 146  
     /**
 147  
      * Create a new GenericObjectPoolFactory.
 148  
      *
 149  
      * @param factory the PoolableObjectFactory used by created pools.
 150  
      * @param maxActive maximum number of objects that can be borrowed from created pools at one time.
 151  
      * @param whenExhaustedAction the action to take when the pool is exhausted.
 152  
      * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
 153  
      * @param maxIdle the maximum number of idle objects in my pool.
 154  
      * @param minIdle the minimum number of idle objects in my pool.
 155  
      * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
 156  
      * @param testOnReturn whether to validate objects after they are returned to the returnObject.
 157  
      * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction.
 158  
      * @param numTestsPerEvictionRun the number of idle objects to examine per run within the idle object eviction thread.
 159  
      * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction.
 160  
      * @param testWhileIdle whether or not to validate objects in the idle object eviction thread.
 161  
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int, int, boolean, boolean, long, int, long, boolean)
 162  
      */
 163  
     public GenericObjectPoolFactory(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle) {
 164  0
         this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,minIdle,testOnBorrow,testOnReturn,timeBetweenEvictionRunsMillis,numTestsPerEvictionRun,minEvictableIdleTimeMillis,testWhileIdle, GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
 165  0
     }
 166  
 
 167  
     /**
 168  
      * Create a new GenericObjectPoolFactory.
 169  
      *
 170  
      * @param factory the PoolableObjectFactory used by created pools.
 171  
      * @param maxActive maximum number of objects that can be borrowed from created pools at one time.
 172  
      * @param whenExhaustedAction the action to take when the pool is exhausted.
 173  
      * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
 174  
      * @param maxIdle the maximum number of idle objects in my pool.
 175  
      * @param minIdle the minimum number of idle objects in my pool.
 176  
      * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
 177  
      * @param testOnReturn whether to validate objects after they are returned to the returnObject.
 178  
      * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction.
 179  
      * @param numTestsPerEvictionRun the number of idle objects to examine per run within the idle object eviction thread.
 180  
      * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction.
 181  
      * @param testWhileIdle whether or not to validate objects in the idle object eviction thread.
 182  
      * @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.
 183  
      * @since Pool 1.3
 184  
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int, int, boolean, boolean, long, int, long, boolean, long)
 185  
      */
 186  
     public GenericObjectPoolFactory(PoolableObjectFactory 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) {
 187  0
         this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,minIdle,testOnBorrow,testOnReturn,timeBetweenEvictionRunsMillis,numTestsPerEvictionRun,minEvictableIdleTimeMillis,testWhileIdle,softMinEvictableIdleTimeMillis, GenericObjectPool.DEFAULT_LIFO);
 188  0
     }
 189  
 
 190  
     /**
 191  
      * Create a new GenericObjectPoolFactory.
 192  
      *
 193  
      * @param factory the PoolableObjectFactory used by created pools.
 194  
      * @param maxActive maximum number of objects that can be borrowed from created pools at one time.
 195  
      * @param whenExhaustedAction the action to take when the pool is exhausted.
 196  
      * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
 197  
      * @param maxIdle the maximum number of idle objects in my pool.
 198  
      * @param minIdle the minimum number of idle objects in my pool.
 199  
      * @param testOnBorrow whether to validate objects before they are returned by the borrowObject.
 200  
      * @param testOnReturn whether to validate objects after they are returned to the returnObject.
 201  
      * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction.
 202  
      * @param numTestsPerEvictionRun the number of idle objects to examine per run within the idle object eviction thread.
 203  
      * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction.
 204  
      * @param testWhileIdle whether or not to validate objects in the idle object eviction thread.
 205  
      * @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.
 206  
      * @param lifo whether or not objects are returned in last-in-first-out order from the idle object pool.
 207  
      * @since Pool 1.4
 208  
      * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int, int, boolean, boolean, long, int, long, boolean, long, boolean)
 209  
      */
 210  0
     public GenericObjectPoolFactory(PoolableObjectFactory 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) {
 211  0
         _maxIdle = maxIdle;
 212  0
         _minIdle = minIdle;
 213  0
         _maxActive = maxActive;
 214  0
         _maxWait = maxWait;
 215  0
         _whenExhaustedAction = whenExhaustedAction;
 216  0
         _testOnBorrow = testOnBorrow;
 217  0
         _testOnReturn = testOnReturn;
 218  0
         _testWhileIdle = testWhileIdle;
 219  0
         _timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
 220  0
         _numTestsPerEvictionRun = numTestsPerEvictionRun;
 221  0
         _minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
 222  0
         _softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis;
 223  0
         _lifo = lifo;
 224  0
         _factory = factory;
 225  0
     }
 226  
 
 227  
     /**
 228  
      * {@inheritDoc}
 229  
      */
 230  
     public ObjectPool createPool() {
 231  0
         return new GenericObjectPool(_factory,_maxActive,_whenExhaustedAction,_maxWait,_maxIdle,_minIdle,_testOnBorrow,_testOnReturn,_timeBetweenEvictionRunsMillis,_numTestsPerEvictionRun,_minEvictableIdleTimeMillis,_testWhileIdle,_softMinEvictableIdleTimeMillis,_lifo);
 232  
     }
 233  
 
 234  
     
 235  
     /**
 236  
      * @return the {@link GenericObjectPool#getMaxIdle() maxIdle} setting for pools created by this factory.
 237  
      * @since 1.5.5
 238  
      */
 239  
     public int getMaxIdle() {
 240  0
         return _maxIdle;
 241  
     }
 242  
 
 243  
     /**
 244  
      * @return the {@link GenericObjectPool#getMinIdle() minIdle} setting for pools created by this factory.
 245  
      * @since 1.5.5
 246  
      */
 247  
     public int getMinIdle() {
 248  0
         return _minIdle;
 249  
     }
 250  
 
 251  
     /**
 252  
      * @return the {@link GenericObjectPool#getMaxActive() maxActive} setting for pools created by this factory.
 253  
      * @since 1.5.5
 254  
      */
 255  
     public int getMaxActive() {
 256  0
         return _maxActive;
 257  
     }
 258  
 
 259  
     /**
 260  
      * @return the {@link GenericObjectPool#getMaxWait() maxWait} setting for pools created by this factory.
 261  
      * @since 1.5.5
 262  
      */
 263  
     public long getMaxWait() {
 264  0
         return _maxWait;
 265  
     }
 266  
 
 267  
     /**
 268  
      * @return the {@link GenericObjectPool#getWhenExhaustedAction() whenExhaustedAction} setting for pools
 269  
      * created by this factory.
 270  
      * @since 1.5.5
 271  
      */
 272  
     public byte getWhenExhaustedAction() {
 273  0
         return _whenExhaustedAction;
 274  
     }
 275  
 
 276  
     /**
 277  
      * @return the {@link GenericObjectPool#getTestOnBorrow() testOnBorrow} setting for pools
 278  
      * created by this factory.
 279  
      * @since 1.5.5
 280  
      */
 281  
     public boolean getTestOnBorrow() {
 282  0
         return _testOnBorrow;
 283  
     }
 284  
 
 285  
     /**
 286  
      * @return the {@link GenericObjectPool#getTestOnReturn() testOnReturn} setting for pools
 287  
      * created by this factory.
 288  
      * @since 1.5.5
 289  
      */
 290  
     public boolean getTestOnReturn() {
 291  0
         return _testOnReturn;
 292  
     }
 293  
 
 294  
     /**
 295  
      * @return the {@link GenericObjectPool#getTestWhileIdle() testWhileIdle} setting for pools
 296  
      * created by this factory.
 297  
      * @since 1.5.5
 298  
      */
 299  
     public boolean getTestWhileIdle() {
 300  0
         return _testWhileIdle;
 301  
     }
 302  
 
 303  
     /**
 304  
      * @return the {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis() timeBetweenEvictionRunsMillis}
 305  
      * setting for pools created by this factory.
 306  
      * @since 1.5.5
 307  
      */
 308  
     public long getTimeBetweenEvictionRunsMillis() {
 309  0
         return _timeBetweenEvictionRunsMillis;
 310  
     }
 311  
 
 312  
     /**
 313  
      * @return the {@link GenericObjectPool#getNumTestsPerEvictionRun() numTestsPerEvictionRun}
 314  
      * setting for pools created by this factory.
 315  
      * @since 1.5.5
 316  
      */
 317  
     public int getNumTestsPerEvictionRun() {
 318  0
         return _numTestsPerEvictionRun;
 319  
     }
 320  
 
 321  
     /**
 322  
      * @return the {@link GenericObjectPool#getMinEvictableIdleTimeMillis() minEvictableIdleTimeMillis}
 323  
      * setting for pools created by this factory.
 324  
      * @since 1.5.5
 325  
      */
 326  
     public long getMinEvictableIdleTimeMillis() {
 327  0
         return _minEvictableIdleTimeMillis;
 328  
     }
 329  
 
 330  
     /**
 331  
      * @return the {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis() softMinEvicatableIdleTimeMillis}
 332  
      * setting for pools created by this factory.
 333  
      * @since 1.5.5
 334  
      */
 335  
     public long getSoftMinEvictableIdleTimeMillis() {
 336  0
         return _softMinEvictableIdleTimeMillis;
 337  
     }
 338  
 
 339  
     /**
 340  
      * @return the {@link GenericObjectPool#getLifo() lifo} setting for pools created by this factory.
 341  
      * @since 1.5.5
 342  
      */
 343  
     public boolean getLifo() {
 344  0
         return _lifo;
 345  
     }
 346  
 
 347  
     /**
 348  
      * @return the {@link PoolableObjectFactory} used by pools created by this factory
 349  
      */
 350  
     public PoolableObjectFactory getFactory() {
 351  0
         return _factory;
 352  
     }
 353  
   
 354  
     /**
 355  
      * The {@link GenericObjectPool#getMaxIdle() maxIdle} setting for pools created by this factory.
 356  
      * @deprecated to be removed in pool 2.0.  Use {@link #getMaxIdle()}.
 357  
      */
 358  0
     protected int _maxIdle = GenericObjectPool.DEFAULT_MAX_IDLE;
 359  
     
 360  
     /**
 361  
      * The {@link GenericObjectPool#getMinIdle() minIdle} setting for pools created by this factory.
 362  
      * @deprecated to be removed in pool 2.0.  Use {@link #getMinIdle()}.
 363  
      */
 364  0
     protected int _minIdle = GenericObjectPool.DEFAULT_MIN_IDLE;
 365  
     
 366  
     /**
 367  
      * The {@link GenericObjectPool#getMaxActive() maxActive} setting for pools created by this factory.
 368  
      * @deprecated to be removed in pool 2.0.  Use {@link #getMaxActive()}.
 369  
      */
 370  0
     protected int _maxActive = GenericObjectPool.DEFAULT_MAX_ACTIVE;
 371  
     
 372  
     /**
 373  
      * The {@link GenericObjectPool#getMaxWait() maxWait} setting for pools created by this factory.
 374  
      * @deprecated to be removed in pool 2.0.  Use {@link #getMaxWait()}.
 375  
      */
 376  0
     protected long _maxWait = GenericObjectPool.DEFAULT_MAX_WAIT;
 377  
     
 378  
     /**
 379  
      * The {@link GenericObjectPool#getWhenExhaustedAction() whenExhaustedAction} setting for pools
 380  
      * created by this factory.
 381  
      * @deprecated to be removed in pool 2.0.  Use {@link #getWhenExhaustedAction()}.
 382  
      */
 383  0
     protected byte _whenExhaustedAction = GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION;
 384  
     
 385  
     /**
 386  
      * The {@link GenericObjectPool#getTestOnBorrow() testOnBorrow} setting for pools created by this factory.
 387  
      * @deprecated to be removed in pool 2.0.  Use {@link #getTestOnBorrow()}.
 388  
      */
 389  0
     protected boolean _testOnBorrow = GenericObjectPool.DEFAULT_TEST_ON_BORROW;
 390  
     
 391  
     /**
 392  
      * The {@link GenericObjectPool#getTestOnReturn() testOnReturn} setting for pools created by this factory.
 393  
      * @deprecated to be removed in pool 2.0.  Use {@link #getTestOnReturn()}.
 394  
      */
 395  0
     protected boolean _testOnReturn = GenericObjectPool.DEFAULT_TEST_ON_RETURN;
 396  
     
 397  
     /**
 398  
      * The {@link GenericObjectPool#getTestWhileIdle() testWhileIdle} setting for pools created by this factory.
 399  
      * @deprecated to be removed in pool 2.0.  Use {@link #getTestWhileIdle()}.
 400  
      */
 401  0
     protected boolean _testWhileIdle = GenericObjectPool.DEFAULT_TEST_WHILE_IDLE;
 402  
     
 403  
     /**
 404  
      * The {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis() timeBetweenEvictionRunsMillis}
 405  
      * setting for pools created by this factory.
 406  
      * @deprecated to be removed in pool 2.0.  Use {@link #getTimeBetweenEvictionRunsMillis()}.
 407  
      */
 408  0
     protected long _timeBetweenEvictionRunsMillis = GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
 409  
     
 410  
     /**
 411  
      * The {@link GenericObjectPool#getNumTestsPerEvictionRun() numTestsPerEvictionRun} setting
 412  
      * for pools created by this factory.
 413  
      * @deprecated to be removed in pool 2.0.  Use {@link #getNumTestsPerEvictionRun()}.
 414  
      */
 415  0
     protected int _numTestsPerEvictionRun =  GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN;
 416  
     
 417  
     /**
 418  
      * The {@link GenericObjectPool#getMinEvictableIdleTimeMillis() minEvictableIdleTimeMillis}
 419  
      * setting for pools created by this factory.
 420  
      * @deprecated to be removed in pool 2.0.  Use {@link #getMinEvictableIdleTimeMillis()}.
 421  
      */
 422  0
     protected long _minEvictableIdleTimeMillis = GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
 423  
     
 424  
     /**
 425  
      * The {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis() softMinEvictableIdleTimeMillis}
 426  
      * setting for pools created by this factory.
 427  
      * @deprecated to be removed in pool 2.0.  Use {@link #getSoftMinEvictableIdleTimeMillis()}.
 428  
      */
 429  0
     protected long _softMinEvictableIdleTimeMillis = GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
 430  
     
 431  
     /**
 432  
      * The {@link GenericObjectPool#getLifo() lifo} setting for pools created by this factory.
 433  
      * @deprecated to be removed in pool 2.0.  Use {@link #getLifo()}.
 434  
      */
 435  0
     protected boolean _lifo = GenericObjectPool.DEFAULT_LIFO;
 436  
     
 437  
     /**
 438  
      * The {@link PoolableObjectFactory} used by pools created by this factory.
 439  
      * @deprecated to be removed in pool 2.0.  Use {@link #getFactory()}.
 440  
      */
 441  0
     protected PoolableObjectFactory _factory = null;
 442  
 
 443  
 }