    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017
    018    package org.apache.commons.pool.impl;
    019
    020    import org.apache.commons.pool.KeyedObjectPool;
    021    import org.apache.commons.pool.KeyedObjectPoolFactory;
    022    import org.apache.commons.pool.KeyedPoolableObjectFactory;
    023
    024    /**
    025     * A factory for creating {@link GenericKeyedObjectPool} instances.
    026     *
    027     * @see GenericKeyedObjectPool
    028     * @see KeyedObjectPoolFactory
    029     *
    030     * @author Rodney Waldhoff
    031     * @author Dirk Verbeeck
    032     * @version $Revision: 965263 $ $Date: 2010-07-18 10:23:39 -0700 (Sun, 18 Jul 2010) $
    033     * @since Pool 1.0
    034     */
    035    public class GenericKeyedObjectPoolFactory implements KeyedObjectPoolFactory {
    036        /**
    037         * Create a new GenericKeyedObjectPoolFactory.
    038         *
    039         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    040         * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory)
    041         */
    042        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory) {
    043            this(factory,GenericKeyedObjectPool.DEFAULT_MAX_ACTIVE,GenericKeyedObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION,GenericKeyedObjectPool.DEFAULT_MAX_WAIT,GenericKeyedObjectPool.DEFAULT_MAX_IDLE,GenericKeyedObjectPool.DEFAULT_TEST_ON_BORROW,GenericKeyedObjectPool.DEFAULT_TEST_ON_RETURN,GenericKeyedObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericKeyedObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericKeyedObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericKeyedObjectPool.DEFAULT_TEST_WHILE_IDLE);
    044        }
    045
    046        /**
    047         * Create a new GenericKeyedObjectPoolFactory.
    048         *
    049         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    050         * @param config a non-null GenericKeyedObjectPool.Config describing the configuration.
    051         * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, GenericKeyedObjectPool.Config)
    052         * @throws NullPointerException when config is <code>null</code>.
    053         */
    054        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory, GenericKeyedObjectPool.Config config) throws NullPointerException {
    055            this(factory,config.maxActive,config.whenExhaustedAction,config.maxWait,config.maxIdle,config.maxTotal,config.minIdle,config.testOnBorrow,config.testOnReturn,config.timeBetweenEvictionRunsMillis,config.numTestsPerEvictionRun,config.minEvictableIdleTimeMillis,config.testWhileIdle,config.lifo);
    056        }
    057
    058        /**
    059         * Create a new GenericKeyedObjectPoolFactory.
    060         *
    061         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    062         * @param maxActive the maximum number of objects that can be borrowed from pools at one time.
    063         * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int)
    064         */
    065        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory, int maxActive) {
    066            this(factory,maxActive,GenericKeyedObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION,GenericKeyedObjectPool.DEFAULT_MAX_WAIT,GenericKeyedObjectPool.DEFAULT_MAX_IDLE, GenericKeyedObjectPool.DEFAULT_MAX_TOTAL,GenericKeyedObjectPool.DEFAULT_TEST_ON_BORROW,GenericKeyedObjectPool.DEFAULT_TEST_ON_RETURN,GenericKeyedObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericKeyedObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericKeyedObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericKeyedObjectPool.DEFAULT_TEST_WHILE_IDLE);
    067        }
    068
    069        /**
    070         * Create a new GenericKeyedObjectPoolFactory.
    071         *
    072         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    073         * @param maxActive the maximum number of objects that can be borrowed from pools at one time.
    074         * @param whenExhaustedAction the action to take when the pool is exhausted.
    075         * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
    076         * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long)
    077         */
    078        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait) {
    079            this(factory,maxActive,whenExhaustedAction,maxWait,GenericKeyedObjectPool.DEFAULT_MAX_IDLE, GenericKeyedObjectPool.DEFAULT_MAX_TOTAL,GenericKeyedObjectPool.DEFAULT_TEST_ON_BORROW,GenericKeyedObjectPool.DEFAULT_TEST_ON_RETURN,GenericKeyedObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericKeyedObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericKeyedObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericKeyedObjectPool.DEFAULT_TEST_WHILE_IDLE);
    080        }
    081
    082        /**
    083         * Create a new GenericKeyedObjectPoolFactory.
    084         *
    085         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    086         * @param maxActive the maximum number of objects that can be borrowed from pools at one time.
    087         * @param whenExhaustedAction the action to take when the pool is exhausted.
    088         * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
    089         * @param testOnBorrow whether to validate objects before they are returned by borrowObject.
    090         * @param testOnReturn whether to validate objects after they are returned to returnObject.
    091         * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long, boolean, boolean)
    092         */
    093        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, boolean testOnBorrow, boolean testOnReturn) {
    094            this(factory,maxActive,whenExhaustedAction,maxWait,GenericKeyedObjectPool.DEFAULT_MAX_IDLE, GenericKeyedObjectPool.DEFAULT_MAX_TOTAL,testOnBorrow,testOnReturn,GenericKeyedObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericKeyedObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericKeyedObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericKeyedObjectPool.DEFAULT_TEST_WHILE_IDLE);
    095        }
    096
    097        /**
    098         * Create a new GenericKeyedObjectPoolFactory.
    099         *
    100         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    101         * @param maxActive the maximum number of objects that can be borrowed from pools at one time.
    102         * @param whenExhaustedAction the action to take when the pool is exhausted.
    103         * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
    104         * @param maxIdle the maximum number of idle objects in the pools.
    105         * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long, int)
    106         */
    107        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle) {
    108            this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle, GenericKeyedObjectPool.DEFAULT_MAX_TOTAL,GenericKeyedObjectPool.DEFAULT_TEST_ON_BORROW,GenericKeyedObjectPool.DEFAULT_TEST_ON_RETURN,GenericKeyedObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericKeyedObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericKeyedObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericKeyedObjectPool.DEFAULT_TEST_WHILE_IDLE);
    109        }
    110
    111        /**
    112         * Create a new GenericKeyedObjectPoolFactory.
    113         *
    114         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    115         * @param maxActive the maximum number of objects that can be borrowed from pools at one time.
    116         * @param whenExhaustedAction the action to take when the pool is exhausted.
    117         * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
    118         * @param maxIdle the maximum number of idle objects in the pools.
    119         * @param maxTotal the maximum number of objects that can exists at one time.
    120         */
    121        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int maxTotal) {
    122            this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle, maxTotal, GenericKeyedObjectPool.DEFAULT_TEST_ON_BORROW,GenericKeyedObjectPool.DEFAULT_TEST_ON_RETURN,GenericKeyedObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericKeyedObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericKeyedObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericKeyedObjectPool.DEFAULT_TEST_WHILE_IDLE);
    123        }
    124
    125        /**
    126         * Create a new GenericKeyedObjectPoolFactory.
    127         *
    128         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    129         * @param maxActive the maximum number of objects that can be borrowed from pools at one time.
    130         * @param whenExhaustedAction the action to take when the pool is exhausted.
    131         * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
    132         * @param maxIdle the maximum number of idle objects in the pools.
    133         * @param testOnBorrow whether to validate objects before they are returned by borrowObject.
    134         * @param testOnReturn whether to validate objects after they are returned to returnObject.
    135         * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long, int, boolean, boolean)
    136         */
    137        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn) {
    138            this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle, GenericKeyedObjectPool.DEFAULT_MAX_TOTAL,testOnBorrow,testOnReturn,GenericKeyedObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericKeyedObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericKeyedObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericKeyedObjectPool.DEFAULT_TEST_WHILE_IDLE);
    139        }
    140
    141        /**
    142         * Create a new GenericKeyedObjectPoolFactory.
    143         *
    144         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    145         * @param maxActive the maximum number of objects that can be borrowed from pools at one time.
    146         * @param whenExhaustedAction the action to take when the pool is exhausted.
    147         * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
    148         * @param maxIdle the maximum number of idle objects in the pools.
    149         * @param testOnBorrow whether to validate objects before they are returned by borrowObject.
    150         * @param testOnReturn whether to validate objects after they are returned to returnObject.
    151         * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction.
    152         * @param numTestsPerEvictionRun the number of idle objects to examine per run of the evictor.
    153         * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction.
    154         * @param testWhileIdle whether to validate objects in the idle object eviction thread.
    155         * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long, int, boolean, boolean, long, int, long, boolean)
    156         */
    157        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle) {
    158            this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle, GenericKeyedObjectPool.DEFAULT_MAX_TOTAL, testOnBorrow, testOnReturn, timeBetweenEvictionRunsMillis, numTestsPerEvictionRun, minEvictableIdleTimeMillis, testWhileIdle);
    159        }
    160
    161        /**
    162         * Create a new GenericKeyedObjectPoolFactory.
    163         *
    164         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    165         * @param maxActive the maximum number of objects that can be borrowed from pools at one time.
    166         * @param whenExhaustedAction the action to take when the pool is exhausted.
    167         * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
    168         * @param maxIdle the maximum number of idle objects in the pools.
    169         * @param maxTotal the maximum number of objects that can exists at one time.
    170         * @param testOnBorrow whether to validate objects before they are returned by borrowObject.
    171         * @param testOnReturn whether to validate objects after they are returned to returnObject.
    172         * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction.
    173         * @param numTestsPerEvictionRun the number of idle objects to examine per run of the evictor.
    174         * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction.
    175         * @param testWhileIdle whether to validate objects in the idle object eviction thread.
    176         * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long, int, int, boolean, boolean, long, int, long, boolean)
    177         */
    178        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int maxTotal, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle) {
    179            this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle, maxTotal, GenericKeyedObjectPool.DEFAULT_MIN_IDLE , testOnBorrow, testOnReturn, timeBetweenEvictionRunsMillis, numTestsPerEvictionRun, minEvictableIdleTimeMillis, testWhileIdle);
    180        }
    181
    182        /**
    183         * Create a new GenericKeyedObjectPoolFactory.
    184         *
    185         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    186         * @param maxActive the maximum number of objects that can be borrowed from pools at one time.
    187         * @param whenExhaustedAction the action to take when the pool is exhausted.
    188         * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
    189         * @param maxIdle the maximum number of idle objects in the pools.
    190         * @param maxTotal the maximum number of objects that can exists at one time.
    191         * @param minIdle the minimum number of idle objects to have in the pool at any one time.
    192         * @param testOnBorrow whether to validate objects before they are returned by borrowObject.
    193         * @param testOnReturn whether to validate objects after they are returned to returnObject.
    194         * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction.
    195         * @param numTestsPerEvictionRun the number of idle objects to examine per run of the evictor.
    196         * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction.
    197         * @param testWhileIdle whether to validate objects in the idle object eviction thread.
    198         * @since Pool 1.3
    199         * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long, int, int, int, boolean, boolean, long, int, long, boolean)
    200         */
    201        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int maxTotal, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle) {
    202            this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle, maxTotal, minIdle, testOnBorrow, testOnReturn, timeBetweenEvictionRunsMillis, numTestsPerEvictionRun, minEvictableIdleTimeMillis, testWhileIdle, GenericKeyedObjectPool.DEFAULT_LIFO);
    203        }
    204
    205        /**
    206         * Create a new GenericKeyedObjectPoolFactory.
    207         *
    208         * @param factory the KeyedPoolableObjectFactory to used by created pools.
    209         * @param maxActive the maximum number of objects that can be borrowed from pools at one time.
    210         * @param whenExhaustedAction the action to take when the pool is exhausted.
    211         * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted.
    212         * @param maxIdle the maximum number of idle objects in the pools.
    213         * @param maxTotal the maximum number of objects that can exists at one time.
    214         * @param minIdle the minimum number of idle objects to have in the pool at any one time.
    215         * @param testOnBorrow whether to validate objects before they are returned by borrowObject.
    216         * @param testOnReturn whether to validate objects after they are returned to returnObject.
    217         * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction.
    218         * @param numTestsPerEvictionRun the number of idle objects to examine per run of the evictor.
    219         * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction.
    220         * @param testWhileIdle whether to validate objects in the idle object eviction thread.
    221         * @param lifo whether or not objects are returned in last-in-first-out order from the idle object pool.
    222         * @since Pool 1.4
    223         * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long, int, int, int, boolean, boolean, long, int, long, boolean, boolean)
    224         */
    225        public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int maxTotal, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle, boolean lifo) {
    226            _maxIdle = maxIdle;
    227            _maxActive = maxActive;
    228            _maxTotal = maxTotal;
    229            _minIdle = minIdle;
    230            _maxWait = maxWait;
    231            _whenExhaustedAction = whenExhaustedAction;
    232            _testOnBorrow = testOnBorrow;
    233            _testOnReturn = testOnReturn;
    234            _testWhileIdle = testWhileIdle;
    235            _timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    236            _numTestsPerEvictionRun = numTestsPerEvictionRun;
    237            _minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    238            _factory = factory;
    239            _lifo = lifo;
    240        }
    241
    242        /**
    243         * Create a new GenericKeyedObjectPool with the currently configured properties.
    244         *
    245         * @return GenericKeyedObjectPool with {@link GenericKeyedObjectPool.Config Configuration} determined by
    246         * current property settings
    247         */
    248        public KeyedObjectPool createPool() {
    249            return new GenericKeyedObjectPool(_factory,_maxActive,_whenExhaustedAction,_maxWait,_maxIdle,_maxTotal,_minIdle,_testOnBorrow,_testOnReturn,_timeBetweenEvictionRunsMillis,_numTestsPerEvictionRun,_minEvictableIdleTimeMillis,_testWhileIdle,_lifo);
    250        }
    251
    252        /**
    253         * @return the {@link GenericKeyedObjectPool#getMaxIdle() maxIdle} setting for pools created by this factory.
    254         * @since 1.5.5
    255         */
    256        public int getMaxIdle() {
    257            return _maxIdle;
    258        }
    259
    260        /**
    261         * @return the {@link GenericKeyedObjectPool#getMaxActive() maxActive} setting for pools created by this factory.
    262         * @since 1.5.5
    263         */
    264        public int getMaxActive() {
    265            return _maxActive;
    266        }
    267
    268        /**
    269         * @return the {@link GenericKeyedObjectPool#getMaxTotal() maxTotal} setting for pools created by this factory.
    270         * @since 1.5.5
    271         */
    272        public int getMaxTotal() {
    273            return _maxTotal;
    274        }
    275
    276        /**
    277         * @return the {@link GenericKeyedObjectPool#getMinIdle() minIdle} setting for pools created by this factory.
    278         * @since 1.5.5
    279         */
    280        public int getMinIdle() {
    281            return _minIdle;
    282        }
    283
    284        /**
    285         * @return the {@link GenericKeyedObjectPool#getMaxWait() maxWait} setting for pools created by this factory.
    286         * @since 1.5.5
    287         */
    288        public long getMaxWait() {
    289            return _maxWait;
    290        }
    291
    292        /**
    293         * @return the {@link GenericKeyedObjectPool#getWhenExhaustedAction() whenExhaustedAction} setting for pools created by this factory.
    294         * @since 1.5.5
    295         */
    296        public byte getWhenExhaustedAction() {
    297            return _whenExhaustedAction;
    298        }
    299
    300        /**
    301         * @return the {@link GenericKeyedObjectPool#getTestOnBorrow() testOnBorrow} setting for pools created by this factory.
    302         * @since 1.5.5
    303         */
    304        public boolean getTestOnBorrow() {
    305            return _testOnBorrow;
    306        }
    307
    308        /**
    309         * @return the {@link GenericKeyedObjectPool#getTestOnReturn() testOnReturn} setting for pools created by this factory.
    310         * @since 1.5.5
    311         */
    312        public boolean getTestOnReturn() {
    313            return _testOnReturn;
    314        }
    315
    316        /**
    317         * @return the {@link GenericKeyedObjectPool#getTestWhileIdle() testWhileIdle} setting for pools created by this factory.
    318         * @since 1.5.5
    319         */
    320        public boolean getTestWhileIdle() {
    321            return _testWhileIdle;
    322        }
    323
    324        /**
    325         * @return the {@link GenericKeyedObjectPool#getTimeBetweenEvictionRunsMillis() timeBetweenEvictionRunsMillis}
    326         * setting for pools created by this factory.
    327         * @since 1.5.5
    328         */
    329        public long getTimeBetweenEvictionRunsMillis() {
    330            return _timeBetweenEvictionRunsMillis;
    331        }
    332
    333        /**
    334         * @return the {@link GenericKeyedObjectPool#getNumTestsPerEvictionRun() numTestsPerEvictionRun}
    335         * setting for pools created by this factory.
    336         * @since 1.5.5
    337         */
    338        public int getNumTestsPerEvictionRun() {
    339            return _numTestsPerEvictionRun;
    340        }
    341
    342        /**
    343         * @return the {@link GenericKeyedObjectPool#getMinEvictableIdleTimeMillis() minEvictableIdleTimeMillis}
    344         * setting for pools created by this factory.
    345         * @since 1.5.5
    346         */
    347        public long getMinEvictableIdleTimeMillis() {
    348            return _minEvictableIdleTimeMillis;
    349        }
    350
    351        /**
    352         * @return the {@link KeyedPoolableObjectFactory} used by pools created by this factory.
    353         * @since 1.5.5
    354         */
    355        public KeyedPoolableObjectFactory getFactory() {
    356            return _factory;
    357        }
    358
    359        /**
    360         * @return the {@link GenericKeyedObjectPool#getLifo() lifo} setting for pools created by this factory.
    361         * @since 1.5.5
    362         */
    363        public boolean getLifo() {
    364            return _lifo;
    365        }
    366
    367        //--- protected attributes - deprecated, use getters to access these properties
    368
    369        /**
    370         * The {@link GenericKeyedObjectPool#getMaxIdle() maxIdle} setting for pools created by this factory.
    371         * @deprecated to be removed in pool 2.0. Use {@link #getMaxIdle()}.
    372         */
    373        protected int _maxIdle = GenericKeyedObjectPool.DEFAULT_MAX_IDLE;
    374
    375        /**
    376         * The {@link GenericKeyedObjectPool#getMaxActive() maxActive} setting for pools created by this factory.
    377         * @deprecated to be removed in pool 2.0. Use {@link #getMaxActive()}.
    378         */
    379        protected int _maxActive = GenericKeyedObjectPool.DEFAULT_MAX_ACTIVE;
    380
    381        /**
    382         * The {@link GenericKeyedObjectPool#getMaxTotal() maxTotal} setting for pools created by this factory.
    383         * @deprecated to be removed in pool 2.0. Use {@link #getMaxTotal()}.
    384         */
    385        protected int _maxTotal = GenericKeyedObjectPool.DEFAULT_MAX_TOTAL;
    386
    387        /**
    388         * The {@link GenericKeyedObjectPool#getMinIdle() minIdle} setting for pools created by this factory.
    389         * @deprecated to be removed in pool 2.0. Use {@link #getMinIdle()}.
    390         */
    391        protected int _minIdle = GenericKeyedObjectPool.DEFAULT_MIN_IDLE;
    392
    393        /**
    394         * The {@link GenericKeyedObjectPool#getMaxWait() maxWait} setting for pools created by this factory.
    395         * @deprecated to be removed in pool 2.0. Use {@link #getMaxWait()}.
    396         */
    397        protected long _maxWait = GenericKeyedObjectPool.DEFAULT_MAX_WAIT;
    398
    399        /**
    400         * The {@link GenericKeyedObjectPool#getWhenExhaustedAction() whenExhaustedAction} setting for pools created by this factory.
    401         * @deprecated to be removed in pool 2.0. Use {@link #getWhenExhaustedAction()}.
    402         */
    403        protected byte _whenExhaustedAction = GenericKeyedObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION;
    404
    405        /**
    406         * The {@link GenericKeyedObjectPool#getTestOnBorrow() testOnBorrow} setting for pools created by this factory.
    407         * @deprecated to be removed in pool 2.0. Use {@link #getTestOnBorrow()}.
    408         */
    409        protected boolean _testOnBorrow = GenericKeyedObjectPool.DEFAULT_TEST_ON_BORROW;
    410
    411        /**
    412         * The {@link GenericKeyedObjectPool#getTestOnReturn() testOnReturn} setting for pools created by this factory.
    413         * @deprecated to be removed in pool 2.0. Use {@link #getTestOnReturn()}.
    414         */
    415        protected boolean _testOnReturn = GenericKeyedObjectPool.DEFAULT_TEST_ON_RETURN;
    416
    417        /**
    418         * The {@link GenericKeyedObjectPool#getTestWhileIdle() testWhileIdle} setting for pools created by this factory.
    419         * @deprecated to be removed in pool 2.0. Use {@link #getTestWhileIdle()}.
    420         */
    421        protected boolean _testWhileIdle = GenericKeyedObjectPool.DEFAULT_TEST_WHILE_IDLE;
    422
    423        /**
    424         * The {@link GenericKeyedObjectPool#getTimeBetweenEvictionRunsMillis() timeBetweenEvictionRunsMillis} setting for
    425         * pools created by this factory.
    426         * @deprecated to be removed in pool 2.0. Use {@link #getTimeBetweenEvictionRunsMillis()}.
    427         */
    428        protected long _timeBetweenEvictionRunsMillis = GenericKeyedObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
    429
    430        /**
    431         * The {@link GenericKeyedObjectPool#getNumTestsPerEvictionRun() numTestsPerEvictionRun} setting for
    432         * pools created by this factory.
    433         * @deprecated to be removed in pool 2.0. Use {@link #getNumTestsPerEvictionRun()}.
    434         */
    435        protected int _numTestsPerEvictionRun =  GenericKeyedObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN;
    436
    437        /**
    438         * The {@link GenericKeyedObjectPool#getMinEvictableIdleTimeMillis() minEvictableIdleTimeMillis} setting for
    439         * pools created by this factory.
    440         * @deprecated to be removed in pool 2.0. Use {@link #getMinEvictableIdleTimeMillis()}.
    441         */
    442        protected long _minEvictableIdleTimeMillis = GenericKeyedObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
    443
    444        /**
    445         * The {@link KeyedPoolableObjectFactory} used by pools created by this factory.
    446         * @deprecated to be removed in pool 2.0. Use {@link #getFactory()}.
    447         */
    448        protected KeyedPoolableObjectFactory _factory = null;
    449
    450        /**
    451         * The {@link GenericKeyedObjectPool#getLifo() lifo} setting for pools created by this factory.
    452         * @deprecated to be removed in pool 2.0. Use {@link #getLifo()}.
    453         */
    454        protected boolean _lifo = GenericKeyedObjectPool.DEFAULT_LIFO;
    455
    456    }