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