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 }