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

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

     # File lib/extlib/pooling.rb, line 209
209:       def dispose
210:         flush!
211:         @resource.__pools.delete(@args)
212:         !Extlib::Pooling::pools.delete?(self).nil?
213:       end

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

     # File lib/extlib/pooling.rb, line 205
205:       def flush!
206:         @available.pop.dispose until @available.empty?
207:       end

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

     # File lib/extlib/pooling.rb, line 138
138:       def lock
139:         @resource.__pool_lock
140:       end

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

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

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

     # File lib/extlib/pooling.rb, line 196
196:       def size
197:         @used.size + @available.size
198:       end

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