tsafe 0.0.6 → 0.0.9

data/Gemfile.lock

@@ -9,6 +9,7 @@ GEM
       rake
       rdoc
     json (1.7.3)
+    json (1.7.3-java)
     rake (0.9.2.2)
     rdoc (3.12)
       json (~> 1.4)
@@ -22,6 +23,7 @@ GEM
     rspec-mocks (2.8.0)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.9

data/lib/tsafe.rb

@@ -4,14 +4,21 @@ require "monitor"
 module Tsafe
   #Autoloader for subclasses.
   def self.const_missing(name)
-    require "#{File.dirname(__FILE__)}/tsafe_#{name.to_s.downcase}.rb"
+    filep = "#{File.dirname(__FILE__)}/tsafe_#{name.to_s.downcase}"
+    
+    if RUBY_ENGINE == "jruby" and File.exists?("#{filep}_jruby.rb")
+      require "#{filep}_jruby.rb"
+    else
+      require filep
+    end
+    
     raise "Still not loaded: '#{name}'." if !Tsafe.const_defined?(name)
     return Tsafe.const_get(name)
   end
   
-  #JRuby can corrupt an array in a threadded env. Use this method to only get a synchronized array when running JRuby and not having to write "if RUBY_ENGINE"-stuff.
+  #JRuby can corrupt an array in a threadded env. Use this method to only get a synchronized array when running JRuby in order to not having to write "if RUBY_ENGINE"-stuff.
   def self.std_array
-    return MonArray.new if RUBY_ENGINE == "jruby"
+    return Tsafe::MonArray.new if RUBY_ENGINE == "jruby"
     return []
   end
 end

data/lib/tsafe_monarray.rb

@@ -8,5 +8,5 @@ class Tsafe::MonArray < ::Array
   @@tsafe_rwmutex_w_methods = [:<<, :collect, :collect!, :compact!, :delete, :delete_at, :delete_if, :drop, :drop_while, :fill, :flatten!, :insert, :keep_if, :map, :map!, :replace, :shuffle!, :slice!, :shift, :sort!, :sort_by!, :unshift]
   @@tsafe_rwmutex_r_methods = [:each, :each_index, :take_while]
   
-  include Tsafe::SynModule
+  include Tsafe::Mrswlock_synmodule
 end

data/lib/tsafe_monhash.rb

@@ -8,5 +8,5 @@ class Tsafe::MonHash < ::Hash
   @@tsafe_mrswlock_w_methods = [:[]=, :clear, :delete, :delete_if, :keep_if, :merge!, :rehash, :reject!, :replace, :select!, :shift, :store, :update, :values_at]
   @@tsafe_mrswlock_r_methods = [:each, :each_key, :each_pair, :each_value]
   
-  include Tsafe::Mrswlock::SynModule
+  include Tsafe::Mrswlock_synmodule
 end

data/lib/tsafe_mrswlock.rb

@@ -1,7 +1,7 @@
-#A class that allows many simultanious read-synchronizations but locks both reading and writing while calling the write-synchronzie-method.
+# A class that allows many simultanious read-synchronizations but locks both reading and writing while calling the write-synchronzie-method.
+# This version does not work in JRuby! 'const_missing'-autoloader should automatically load the JRuby-version.
+# It is not 'actually' thread-safe, but because of GIL, it wont bug up. If it was actually thread-safe, the performance would go down. So it only works with GIL.
 class Tsafe::Mrswlock
-  @@debug = false
-  
   # Sets various variables.
   def initialize
     @reads = 0
@@ -18,15 +18,9 @@ class Tsafe::Mrswlock
   def rsync
     begin
       tid = Thread.current.__id__
-      
-      while @w_mutex.locked? and @locked_by != tid
-        Thread.pass
-        print "Passed because lock.\n" if @@debug
-      end
-      
+      Thread.pass while @w_mutex.locked? and @locked_by != tid
       @reading_threads[tid] = true
       @reads += 1
-      print "Reading more than one at a time! (#{@reads})\n" if @@debug and @reads >= 2
       yield
     ensure
       @reading_threads.delete(tid)
@@ -48,12 +42,8 @@ class Tsafe::Mrswlock
         #Wait for any reads to finish that might have started while we were getting the lock.
         #Also allow write if there is only one reading thread and that reading thread is the current thread.
         while @reads > 0
-          if @reading_threads.key?(tid)
-            raise ThreadError, "Deadlock: Writing is not allowed while reading."
-          end
-          
+          raise ThreadError, "Deadlock: Writing is not allowed while reading." if @reading_threads.key?(tid)
           Thread.pass
-          print "Passed because reading.\n" if @@debug
         end
         
         yield
@@ -62,68 +52,4 @@ class Tsafe::Mrswlock
       end
     end
   end
-  
-  #This module can be included in order to painlessly make a thread-safe multi-reader-single-writer thread-safe copy of a class.
-  #===Examples
-  #  class Tsafe::MonHash < ::Hash
-  #    @@tsafe_mrswlock_w_methods = [:[]=, :clear, :delete, :delete_if, :keep_if, :merge!, :rehash, :reject!, :replace, :select!, :shift, :store, :update, :values_at]
-  #    @@tsafe_mrswlock_r_methods = [:each, :each_key, :each_pair, :each_value]
-  #    include Tsafe::Mrswlock::SynModule
-  #  end
-  module SynModule
-    def self.included(base)
-      base.to_s.split("::").inject(Object, :const_get).class_eval do
-        #Yields the given block within the read-lock.
-        #===Examples
-        # obj._tsafe_rsync do
-        #   #do something within read-lock.
-        # end
-        def _tsafe_rsync(&block)
-          @tsafe_mrswlock.rsync(&block)
-        end
-        
-        #Yields the given block within the write-lock (and read-lock).
-        #===Examples
-        # obj._tsafe_wsync do
-        #   #do something within write-lock.
-        # end
-        def _tsafe_wsync(&block)
-          @tsafe_mrswlock.rsync(&block)
-        end
-        
-        #Rename initialize.
-        alias_method(:initialize_mrswlock, :initialize)
-        
-        #Make another initialize-method that spawns the lock and then calls the original initialize.
-        define_method(:initialize) do |*args, &block|
-          @tsafe_mrswlock = Tsafe::Mrswlock.new
-          return initialize_mrswlock(*args, &block)
-        end
-        
-        #Makes reader methods go through reader-lock.
-        base.class_variable_get(:@@tsafe_mrswlock_r_methods).each do |mname|
-          newmname = "tsafe_mrswlock_#{mname}".to_sym
-          alias_method(newmname, mname)
-          
-          define_method(mname) do |*args, &block|
-            @tsafe_mrswlock.rsync do
-              return self.__send__(newmname, *args, &block)
-            end
-          end
-        end
-        
-        #Makes writer methods go through writer-lock.
-        base.class_variable_get(:@@tsafe_mrswlock_w_methods).each do |mname|
-          newmname = "tsafe_mrswlock_#{mname}".to_sym
-          alias_method(newmname, mname)
-          
-          define_method(mname) do |*args, &block|
-            @tsafe_mrswlock.wsync do
-              return self.__send__(newmname, *args, &block)
-            end
-          end
-        end
-      end
-    end
-  end
 end

data/lib/tsafe_mrswlock_jruby.rb

@@ -0,0 +1,45 @@
+require "java"
+
+# A class that allows many simultanious read-synchronizations but locks both reading and writing while calling the write-synchronzie-method.
+# This is the JRuby-version and will not work under anything else. It uses 'java.util.concurrent.locks.ReentrantReadWriteLock' instead of doing the locking in Ruby.
+class Tsafe::Mrswlock
+  # Sets various variables.
+  def initialize
+    @lock = java.util.concurrent.locks.ReentrantReadWriteLock.new
+    
+    #This hash holds thread-IDs for threads that are reading.
+    @reading_threads = {}
+  end
+  
+  # Runs the given block through the read-synchronization.
+  def rsync
+    @lock.read_lock.lock
+    tid = Thread.current.__id__
+    @reading_threads[tid] = true
+    
+    begin
+      yield
+    ensure
+      @reading_threads.delete(tid)
+      @lock.read_lock.unlock
+    end
+  end
+  
+  #Runs the given block through the write-synchronization (locks both reading and writing).
+  #===Examples
+  #  lock.wsync do
+  #    #do something within lock.
+  #  end
+  def wsync
+    tid = Thread.current.__id__
+    raise ThreadError, "Deadlock: Writing is not allowed while reading." if @reading_threads.key?(tid)
+    
+    begin
+      @wlock_by = tid
+      @lock.write_lock.lock
+      yield
+    ensure
+      @lock.write_lock.unlock
+    end
+  end
+end

data/lib/tsafe_mrswlock_synmodule.rb

@@ -0,0 +1,63 @@
+# This module can be included in order to painlessly make a thread-safe multi-reader-single-writer thread-safe copy of a class.
+#===Examples
+#  class Tsafe::MonHash < ::Hash
+#    @@tsafe_mrswlock_w_methods = [:[]=, :clear, :delete, :delete_if, :keep_if, :merge!, :rehash, :reject!, :replace, :select!, :shift, :store, :update, :values_at]
+#    @@tsafe_mrswlock_r_methods = [:each, :each_key, :each_pair, :each_value]
+#    include Tsafe::Mrswlock::SynModule
+#  end
+module Tsafe::Mrswlock_synmodule
+  def self.included(base)
+    base.to_s.split("::").inject(Object, :const_get).class_eval do
+      #Yields the given block within the read-lock.
+      #===Examples
+      # obj._tsafe_rsync do
+      #   #do something within read-lock.
+      # end
+      def _tsafe_rsync(&block)
+        @tsafe_mrswlock.rsync(&block)
+      end
+      
+      #Yields the given block within the write-lock (and read-lock).
+      #===Examples
+      # obj._tsafe_wsync do
+      #   #do something within write-lock.
+      # end
+      def _tsafe_wsync(&block)
+        @tsafe_mrswlock.rsync(&block)
+      end
+      
+      #Rename initialize.
+      alias_method(:initialize_mrswlock, :initialize)
+      
+      #Make another initialize-method that spawns the lock and then calls the original initialize.
+      define_method(:initialize) do |*args, &block|
+        @tsafe_mrswlock = Tsafe::Mrswlock.new
+        return initialize_mrswlock(*args, &block)
+      end
+      
+      #Makes reader methods go through reader-lock.
+      base.class_variable_get(:@@tsafe_mrswlock_r_methods).each do |mname|
+        newmname = "tsafe_mrswlock_#{mname}".to_sym
+        alias_method(newmname, mname)
+        
+        define_method(mname) do |*args, &block|
+          @tsafe_mrswlock.rsync do
+            return self.__send__(newmname, *args, &block)
+          end
+        end
+      end
+      
+      #Makes writer methods go through writer-lock.
+      base.class_variable_get(:@@tsafe_mrswlock_w_methods).each do |mname|
+        newmname = "tsafe_mrswlock_#{mname}".to_sym
+        alias_method(newmname, mname)
+        
+        define_method(mname) do |*args, &block|
+          @tsafe_mrswlock.wsync do
+            return self.__send__(newmname, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/tsafe.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tsafe}
-  s.version = "0.0.6"
+  s.version = "0.0.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kasper Johansen"]
-  s.date = %q{2012-07-25}
+  s.date = %q{2012-07-27}
   s.description = %q{Proxy-objects for making another object threadsafe by proxying calls through mutex and method_missing. Monitored array and hash where all methods are going through monitor. Threadsafe class for including into a class that extends another class in order to make it threadsafe.}
   s.email = %q{k@spernj.org}
   s.extra_rdoc_files = [
@@ -30,6 +30,8 @@ Gem::Specification.new do |s|
     "lib/tsafe_monhash.rb",
     "lib/tsafe_monitored.rb",
     "lib/tsafe_mrswlock.rb",
+    "lib/tsafe_mrswlock_jruby.rb",
+    "lib/tsafe_mrswlock_synmodule.rb",
     "lib/tsafe_mutexed.rb",
     "lib/tsafe_proxy.rb",
     "spec/mrswlock_spec.rb",

metadata

@@ -2,7 +2,7 @@
 name: tsafe
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.6
+  version: 0.0.9
 platform: ruby
 authors: 
 - Kasper Johansen
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-25 00:00:00 +02:00
+date: 2012-07-27 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -80,6 +80,8 @@ files:
 - lib/tsafe_monhash.rb
 - lib/tsafe_monitored.rb
 - lib/tsafe_mrswlock.rb
+- lib/tsafe_mrswlock_jruby.rb
+- lib/tsafe_mrswlock_synmodule.rb
 - lib/tsafe_mutexed.rb
 - lib/tsafe_proxy.rb
 - spec/mrswlock_spec.rb
@@ -100,7 +102,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 1466962052017061704
+      hash: 3863386299653534485
       segments: 
       - 0
       version: "0"