flexirecord 0.0.2

data/lib/thread_resource_pool.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+
+require 'monitor'
+
+
+# Copyright (c) 2007 FlexiGuided GmbH, Berlin
+#
+# Author: Jan Behrens
+#
+# Website: http://www.flexiguided.de/publications.flexirecord.en.html
+#
+# -----
+#
+# ThreadResourcePool's are pools of resources to be exclusively used by each thread of an application. They are abstract classes, and can't be used directly. You have to create sub-classes, which implement the following three methods:
+# - generate_resource
+# - reset_resource
+# - destroy_resource
+
+class ThreadResourcePool
+
+  include MonitorMixin
+
+  private
+
+    # Creates a new pool with a given cache-size. If no cache-size is given, then a size of 1 is assumed.
+    def initialize(size=nil)
+      super()
+      @size = size ? size.to_int : 1
+      @free_resources = []
+      @resources_in_use = {}
+      nil
+    end
+
+    # Sets (or deletes, when being passed nil) the resource being associated with the current thread.
+    def current_resource=(value)
+      if value.nil?
+        @resources_in_use.delete(Thread.current)
+      else
+        @resources_in_use[Thread.current] = value
+      end
+      nil
+    end
+
+    # Returns a new resource to use for the current thread. It is taken from the cache, or, if the cache is empty, by calling the generate_resource method, which has to be implemented by a child class of TheadResourcePool.
+    def get_new_resource
+      synchronize do
+        if @free_resources.empty?
+          return self.generate_resource()
+        else
+          return @free_resources.shift
+        end
+      end
+    end
+
+    # Puts a used resource back to the cache (or destroys it, if the cache is full). Before it is put back to the resource cache, the reset_resource method is called, which has to be implemented by a child class of ThreadResourcePool. Only if that method returns true (or any non nil/false value) the resource is used again, otherwise it is destroyed. Destruction has to be implemented as the method destroy_resource in a child class of ThreadResourcePool.
+    def put_resource_back(resource)
+      synchronize do
+        if @free_resources.length <= @size
+          if self.reset_resource(resource)
+            @free_resources << resource
+          else
+            self.destroy_resource(resource)
+          end
+        else
+          self.destroy_resource(resource)
+        end
+      end
+      nil
+    end
+
+    # Returns a new resource to use.
+    # This method is to be implemented by a sub-class.
+    def generate_resource
+      raise "ThreadResourcePool#generate_resource has to be implemented (overwritten) by a sub-class."
+    end
+
+    # Resets a resource to be re-used by another thread. Returns true on success or false if the resource is to be destroyed.
+    # This method is to be implemented by a sub-class.
+    def reset_resource
+      raise "ThreadResourcePool#reset_resource has to be implemented (overwritten) by a sub-class."
+    end
+
+    # Destroys a resource.
+    # This method is to be implemented by a sub-class.
+    def destroy_resource
+      raise "ThreadResourcePool#destroy_resource has to be implemented (overwritten) by a sub-class."
+    end
+
+  public
+
+    # Returns the resource being associated with the current thread, or nil there is none existing.
+    def current_resource
+      @resources_in_use[Thread.current]
+    end
+
+    # Checks if the current thread has already an associated resource, and either yields that resource or a newly generated or cached resource to the given block. If the thread had no resource associated at the time of call, the resource will be put back to the cache or destroyed when the block ends.
+    def use_resource
+      resource = self.current_resource
+      unless resource.nil?
+        return yield(resource)
+      end
+      begin
+        begin
+          resource = self.current_resource = get_new_resource
+          return yield(resource)
+        ensure
+          self.current_resource = nil
+        end
+      ensure
+        # if thread is terminated by force here, 'current_resource' has already been set to nil
+        self.current_resource = nil
+        put_resource_back(resource) unless resource.nil?
+      end
+    end
+
+  public  # end
+
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: flexirecord
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+date: 2007-02-07 00:00:00 +00:00
+summary: Object-Oriented Database Access Library
+require_paths: 
+- lib/
+email: jan.behrens@flexiguided.de
+homepage: http://www.flexiguided.de/publications.flexirecord.en.html
+rubyforge_project: 
+description: 
+autorequire: flexirecord
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Jan Behrens
+files: 
+- ./LICENSE
+- lib/thread_resource_pool.rb
+- lib/flexirecord.rb
+- lib/flexirecord-demo.rb
+- ./flexirecord-demo.sql
+test_files: []
+
+rdoc_options: 
+- -a
+- --title
+- FlexiRecord Documentation
+- --main
+- FlexiRecord
+- --line-numbers
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+