# File lib/extlib/pooling.rb, line 129
129:       def initialize(max_size, resource, args)
130:         raise ArgumentError.new("+max_size+ should be a Fixnum but was #{max_size.inspect}") unless Fixnum === max_size
131:         raise ArgumentError.new("+resource+ should be a Class but was #{resource.inspect}") unless Class === resource
132: 
133:         @max_size = max_size
134:         @resource = resource
135:         @args = args
136: 
137:         @available = []
138:         @used      = {}
139:         Extlib::Pooling.append_pool(self)
140:       end

     # File lib/extlib/pooling.rb, line 191
191:       def delete(instance)
192:         lock.synchronize do
193:           instance.instance_variable_set(:@__pool, nil)
194:           @used.delete(instance.object_id)
195:           wait.signal
196:         end
197:         nil
198:       end

     # File lib/extlib/pooling.rb, line 213
213:       def dispose
214:         flush!
215:         @resource.__pools.delete(@args)
216:         !Extlib::Pooling.pools.delete?(self).nil?
217:       end

     # File lib/extlib/pooling.rb, line 219
219:       def expired?
220:         @available.each do |instance|
221:           if Extlib.exiting || instance.instance_variable_get(:@__allocated_in_pool) + Extlib::Pooling.scavenger_interval <= (Time.now + 0.02)
222:             instance.dispose
223:             @available.delete(instance)
224:           end
225:         end
226:         size == 0
227:       end

     # File lib/extlib/pooling.rb, line 209
209:       def flush!
210:         @available.pop.dispose until @available.empty?
211:       end

     # File lib/extlib/pooling.rb, line 205
205:       def inspect
206:         "#<Extlib::Pooling::Pool<#{@resource.name}> available=#{@available.size} used=#{@used.size} size=#{@max_size}>"
207:       end

     # File lib/extlib/pooling.rb, line 142
142:       def lock
143:         @resource.__pool_lock
144:       end

     # File lib/extlib/pooling.rb, line 154
154:       def new
155:         instance = nil
156:         begin
157:           lock.synchronize do
158:             if @available.size > 0
159:               instance = @available.pop
160:               @used[instance.object_id] = instance
161:             elsif @used.size < @max_size
162:               instance = @resource.__new(*@args)
163:               raise InvalidResourceError.new("#{@resource} constructor created a nil object") if instance.nil?
164:               raise InvalidResourceError.new("#{instance} is already part of the pool") if @used.include? instance
165:               instance.instance_variable_set(:@__pool, self)
166:               instance.instance_variable_set(:@__allocated_in_pool, Time.now)
167:               @used[instance.object_id] = instance
168:             else
169:               # Wait for another thread to release an instance.
170:               # If we exhaust the pool and don't release the active instance,
171:               # we'll wait here forever, so it's *very* important to always
172:               # release your services and *never* exhaust the pool within
173:               # a single thread.
174:               wait.wait(lock)
175:             end
176:           end
177:         end until instance
178:         instance
179:       end

     # File lib/extlib/pooling.rb, line 181
181:       def release(instance)
182:         lock.synchronize do
183:           instance.instance_variable_set(:@__allocated_in_pool, Time.now)
184:           @used.delete(instance.object_id)
185:           @available.push(instance)
186:           wait.signal
187:         end
188:         nil
189:       end

     # File lib/extlib/pooling.rb, line 150
150:       def scavenge_interval
151:         @resource.scavenge_interval
152:       end

     # File lib/extlib/pooling.rb, line 200
200:       def size
201:         @used.size + @available.size
202:       end

     # File lib/extlib/pooling.rb, line 146
146:       def wait
147:         @resource.__pool_wait
148:       end