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.ObjectPool;
021    import org.apache.commons.pool.ObjectPoolFactory;
022    import org.apache.commons.pool.PoolableObjectFactory;
023    
024    /**
025     * A factory for creating {@link StackObjectPool} instances.
026     *
027     * @see StackObjectPool
028     * @see StackKeyedObjectPoolFactory
029     *
030     * @author Rodney Waldhoff
031     * @version $Revision: 960705 $ $Date: 2010-07-05 14:19:10 -0700 (Mon, 05 Jul 2010) $
032     * @since Pool 1.0
033     */
034    public class StackObjectPoolFactory implements ObjectPoolFactory {
035        /**
036         * Create a new StackObjectPoolFactory.
037         *
038         * @see StackObjectPool#StackObjectPool()
039         * @deprecated to be removed in pool 2.0 - use {@link #StackObjectPoolFactory(PoolableObjectFactory)}
040         */
041        public StackObjectPoolFactory() {
042            this((PoolableObjectFactory)null,StackObjectPool.DEFAULT_MAX_SLEEPING,StackObjectPool.DEFAULT_INIT_SLEEPING_CAPACITY);
043        }
044    
045        /**
046         * Create a new StackObjectPoolFactory.
047         *
048         * @param maxIdle cap on the number of "sleeping" instances in the pool.
049         * @see StackObjectPool#StackObjectPool(int)
050         * @deprecated to be removed in pool 2.0 - use {@link #StackObjectPoolFactory(PoolableObjectFactory, int)}
051         */
052        public StackObjectPoolFactory(int maxIdle) {
053            this((PoolableObjectFactory)null,maxIdle,StackObjectPool.DEFAULT_INIT_SLEEPING_CAPACITY);
054        }
055    
056        /**
057         * Create a new StackObjectPoolFactory.
058         *
059         * @param maxIdle cap on the number of "sleeping" instances in the pool.
060         * @param initIdleCapacity - initial size of the pool (this specifies the size of the container,
061         * it does not cause the pool to be pre-populated.)
062         * @see StackObjectPool#StackObjectPool(int, int)
063         * @deprecated to be removed in pool 2.0 - use {@link #StackObjectPoolFactory(PoolableObjectFactory, int, int)}
064         */
065        public StackObjectPoolFactory(int maxIdle, int initIdleCapacity) {
066            this((PoolableObjectFactory)null,maxIdle,initIdleCapacity);
067        }
068    
069        /**
070         * Create a new StackObjectPoolFactory.
071         *
072         * @param factory the PoolableObjectFactory used by created pools.
073         * @see StackObjectPool#StackObjectPool(PoolableObjectFactory)
074         */
075        public StackObjectPoolFactory(PoolableObjectFactory factory) {
076            this(factory,StackObjectPool.DEFAULT_MAX_SLEEPING,StackObjectPool.DEFAULT_INIT_SLEEPING_CAPACITY);
077        }
078    
079        /**
080         * Create a new StackObjectPoolFactory.
081         *
082         * @param factory the PoolableObjectFactory used by created pools.
083         * @param maxIdle cap on the number of "sleeping" instances in the pool.
084         */
085        public StackObjectPoolFactory(PoolableObjectFactory factory, int maxIdle) {
086            this(factory,maxIdle,StackObjectPool.DEFAULT_INIT_SLEEPING_CAPACITY);
087        }
088    
089        /**
090         * Create a new StackObjectPoolFactory.
091         *
092         * @param factory the PoolableObjectFactory used by created pools.
093         * @param maxIdle cap on the number of "sleeping" instances in the pool.
094         * @param initIdleCapacity - initial size of the pool (this specifies the size of the container,
095         * it does not cause the pool to be pre-populated.)
096         */
097        public StackObjectPoolFactory(PoolableObjectFactory factory, int maxIdle, int initIdleCapacity) {
098            _factory = factory;
099            _maxSleeping = maxIdle;
100            _initCapacity = initIdleCapacity;
101        }
102    
103        /**
104         * Create a StackObjectPool.
105         * 
106         * @return a new StackObjectPool with the configured factory, maxIdle and initial capacity settings
107         */
108        public ObjectPool createPool() {
109            return new StackObjectPool(_factory,_maxSleeping,_initCapacity);
110        }
111    
112        /**
113         * The PoolableObjectFactory used by created pools.
114         * @deprecated to be made private in pool 2.0
115         */
116        protected PoolableObjectFactory _factory = null;
117        
118        /**
119         * The maximum number of idle instances in created pools.
120         * @deprecated to be made private in pool 2.0
121         */
122        protected int _maxSleeping = StackObjectPool.DEFAULT_MAX_SLEEPING;
123        
124        /**
125         * The initial size of created pools.
126         * @deprecated to be made private in pool 2.0
127         */
128        protected int _initCapacity = StackObjectPool.DEFAULT_INIT_SLEEPING_CAPACITY;
129    
130        /**
131         * Returns the factory used by created pools.
132         * 
133         * @return the PoolableObjectFactory used by created pools
134         * @since 1.5.5
135         */
136        public PoolableObjectFactory getFactory() {
137            return _factory;
138        }
139    
140        /**
141         * Returns the maxIdle setting for created pools.
142         * 
143         * @return the maximum number of idle instances in created pools
144         * @since 1.5.5
145         */
146        public int getMaxSleeping() {
147            return _maxSleeping;
148        }
149    
150        /**
151         * Returns the initial capacity of created pools.
152         * 
153         * @return size of created containers (created pools are not pre-populated)
154         * @since 1.5.5
155         */
156        public int getInitCapacity() {
157            return _initCapacity;
158        }
159    
160    }