thread_safe 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca3399bd6ea44fe01680773e7b50bd0e7ba83180
-  data.tar.gz: 5538a41397738daa6a068386fb75c957b68554f9
+  metadata.gz: becd0122b50b5237811fa86271f7d33724680011
+  data.tar.gz: 3111e146b92de7b07e7b052b3dd126aaad1aca2c
 SHA512:
-  metadata.gz: 4de26c2ec5e34448f165a1e7eb6893025d969c41be6f5bbbe02e158c31151871de7c71d9cf5ee8f9d7effc48c871a74b178c030fede73061a6f9c9273a220f9c
-  data.tar.gz: 2f0bddce90244d49e4d0443ffe9d739f8f1732021875e5707c9224add8aac54cce31472accb0fc8471273c12c755cc56e797f5b0087160ba203e8caf3f72387c
+  metadata.gz: ae11d6069603a1f4a6ae9ce62347629b22b2841c4008f248fd05b5c5fc2449913fbc0554919f4615e0abd55fdb903a42eee1520fbc723e17618e7b6419933559
+  data.tar.gz: 8c80390a923556d2627d89af464e51ddae6ac9b5c44a485c6c6c0ad804b01aeed631680a7ab23c63e46293d8649978eceb5dd40cc6218d1f101597baf50b6ee1

data/.gitignore

@@ -19,3 +19,4 @@ test/version_tmp
 tmp
 .DS_Store
 *.swp
+test/package.jar

data/README.md

@@ -28,14 +28,22 @@ sh = ThreadSafe::Hash.new # supports standard Hash.new forms
 ```
 
 `ThreadSafe::Cache` also exists, as a hash-like object, and should have
-much better performance characteristics under concurrency than
+much better performance characteristics esp. under high concurrency than
 `ThreadSafe::Hash`. However, `ThreadSafe::Cache` is not strictly semantically
-equivalent to ruby Hash -- for instance, it does not neccesarily ordered by
-insertion time as Hash is. For most uses it should do fine though, and we
-recommend you consider `ThreadSafe::Cache` instead of `ThreadSafe::Hash` for your
-concurrency-safe hash needs. 
+equivalent to a ruby `Hash` -- for instance, it does not necessarily retain
+ordering by insertion time as `Hash` does. For most uses it should do fine
+though, and we recommend you consider `ThreadSafe::Cache` instead of
+`ThreadSafe::Hash` for your concurrency-safe hash needs. It understands some
+options when created (depending on your ruby platform) that control some of the
+internals - when unsure just leave them out:
 
 
+```ruby
+require 'thread_safe'
+
+cache = ThreadSafe::Cache.new
+```
+
 ## Contributing
 
 1. Fork it

data/ext/org/jruby/ext/thread_safe/JRubyCacheBackendLibrary.java

@@ -178,11 +178,17 @@ public class JRubyCacheBackendLibrary implements Library {
             return getRuntime().newBoolean(map.replace(key, oldValue, newValue));
         }
 
-        @JRubyMethod(name = {"key?"}, required = 1)
+        @JRubyMethod(name = "key?", required = 1)
         public RubyBoolean has_key_p(IRubyObject key) {
             return map.containsKey(key) ? getRuntime().getTrue() : getRuntime().getFalse();
         }
 
+        @JRubyMethod
+        public IRubyObject key(IRubyObject value) {
+            final IRubyObject key = map.findKey(value);
+            return key == null ? getRuntime().getNil() : key;
+        }
+
         @JRubyMethod
         public IRubyObject replace_if_exists(IRubyObject key, IRubyObject value) {
             IRubyObject result = map.replace(key, value);

data/ext/org/jruby/ext/thread_safe/jsr166e/ConcurrentHashMap.java

@@ -25,4 +25,7 @@ public interface ConcurrentHashMap<K, V> {
     public Set<Map.Entry<K,V>> entrySet();
     public int size();
     public V getValueOrDefault(Object key, V defaultValue);
+
+    public boolean containsValue(V value);
+    public K findKey(V value);
 }

data/ext/org/jruby/ext/thread_safe/jsr166e/ConcurrentHashMapV8.java

@@ -2430,8 +2430,8 @@ public class ConcurrentHashMapV8<K, V>
     @SuppressWarnings("serial") static class Traverser<K,V,R> {
         final ConcurrentHashMapV8<K, V> map;
         Node next;           // the next entry to use
-        Object nextKey;      // cached key field of next
-        Object nextVal;      // cached val field of next
+        K nextKey;           // cached key field of next
+        V nextVal;           // cached val field of next
         Node[] tab;          // current table; updated if resized
         int index;           // index of bin to use next
         int baseIndex;       // current index of initial table
@@ -2461,9 +2461,9 @@ public class ConcurrentHashMapV8<K, V>
          * Advances next; returns nextVal or null if terminated.
          * See above for explanation.
          */
-        final Object advance() {
+        final V advance() {
             Node e = next;
-            Object ev = null;
+            V ev = null;
             outer: do {
                 if (e != null)                  // advance past used/skipped node
                     e = e.next;
@@ -2489,8 +2489,8 @@ public class ConcurrentHashMapV8<K, V>
                     }                           // visit upper slots if present
                     index = (i += baseSize) < n ? i : (baseIndex = b + 1);
                 }
-                nextKey = e.key;
-            } while ((ev = e.val) == null);    // skip deleted or special nodes
+                nextKey = (K) e.key;
+            } while ((ev = (V) e.val) == null);    // skip deleted or special nodes
             next = e;
             return nextVal = ev;
         }
@@ -2730,6 +2730,18 @@ public class ConcurrentHashMapV8<K, V>
         return false;
     }
 
+    public K findKey(Object value) {
+        if (value == null)
+            throw new NullPointerException();
+        Object v;
+        Traverser<K,V,Object> it = new Traverser<K,V,Object>(this);
+        while ((v = it.advance()) != null) {
+            if (v == value || value.equals(v))
+                return it.nextKey;
+        }
+        return null;
+    }
+
     /**
      * Legacy method testing if some key maps into the specified value
      * in this table.  This method is identical in functionality to

data/ext/org/jruby/ext/thread_safe/jsr166e/nounsafe/ConcurrentHashMapV8.java

@@ -2422,8 +2422,8 @@ public class ConcurrentHashMapV8<K, V>
     @SuppressWarnings("serial") static class Traverser<K,V,R> {
         final ConcurrentHashMapV8<K, V> map;
         Node next;           // the next entry to use
-        Object nextKey;      // cached key field of next
-        Object nextVal;      // cached val field of next
+        K nextKey;      // cached key field of next
+        V nextVal;      // cached val field of next
         AtomicReferenceArray<Node> tab;          // current table; updated if resized
         int index;           // index of bin to use next
         int baseIndex;       // current index of initial table
@@ -2453,9 +2453,9 @@ public class ConcurrentHashMapV8<K, V>
          * Advances next; returns nextVal or null if terminated.
          * See above for explanation.
          */
-        final Object advance() {
+        final V advance() {
             Node e = next;
-            Object ev = null;
+            V ev = null;
             outer: do {
                 if (e != null)                  // advance past used/skipped node
                     e = e.next;
@@ -2481,8 +2481,8 @@ public class ConcurrentHashMapV8<K, V>
                     }                           // visit upper slots if present
                     index = (i += baseSize) < n ? i : (baseIndex = b + 1);
                 }
-                nextKey = e.key;
-            } while ((ev = e.val) == null);    // skip deleted or special nodes
+                nextKey = (K) e.key;
+            } while ((ev = (V) e.val) == null);    // skip deleted or special nodes
             next = e;
             return nextVal = ev;
         }
@@ -2722,6 +2722,18 @@ public class ConcurrentHashMapV8<K, V>
         return false;
     }
 
+    public K findKey(Object value) {
+        if (value == null)
+            throw new NullPointerException();
+        Object v;
+        Traverser<K,V,Object> it = new Traverser<K,V,Object>(this);
+        while ((v = it.advance()) != null) {
+            if (v == value || value.equals(v))
+                return it.nextKey;
+        }
+        return null;
+    }
+
     /**
      * Legacy method testing if some key maps into the specified value
      * in this table.  This method is identical in functionality to

data/lib/thread_safe/cache.rb

@@ -95,6 +95,12 @@ module ThreadSafe
       each_pair {|k, v| yield v}
     end unless method_defined?(:each_value)
 
+    def key(value)
+      each_pair {|k, v| return k if v == value}
+      nil
+    end unless method_defined?(:key)
+    alias_method :index, :key if RUBY_VERSION < '1.9'
+
     def empty?
       each_pair {|k, v| return false}
       true

data/lib/thread_safe/version.rb

@@ -1,3 +1,21 @@
+module ThreadSafe
+  VERSION = "0.3.1"
+end
+
+# NOTE: <= 0.2.0 used Threadsafe::VERSION
+# @private
 module Threadsafe
-  VERSION = "0.2.0"
+
+  # @private
+  def self.const_missing(name)
+    name = name.to_sym
+    if ThreadSafe.const_defined?(name)
+      warn "[DEPRECATION] `Threadsafe::#{name}' is deprecated, use `ThreadSafe::#{name}' instead."
+      ThreadSafe.const_get(name)
+    else
+      warn "[DEPRECATION] the `Threadsafe' module is deprecated, please use `ThreadSafe` instead."
+      super
+    end
+  end
+
 end

data/test/test_cache.rb

@@ -371,6 +371,16 @@ class TestCache < Test::Unit::TestCase
   end
 
   def test_key
+    with_or_without_default_proc do
+      assert_equal nil, @cache.key(1)
+      @cache[:a] = 1
+      assert_equal :a,  @cache.key(1)
+      assert_equal nil,  @cache.key(0)
+      assert_equal :a,  @cache.index(1) if RUBY_VERSION =~ /1\.8/
+    end
+  end
+
+  def test_key?
     with_or_without_default_proc do
       assert_equal false, @cache.key?(:a)
       @cache[:a] = 1
@@ -378,7 +388,7 @@ class TestCache < Test::Unit::TestCase
     end
   end
 
-  def test_value
+  def test_value?
     with_or_without_default_proc do
       assert_equal false, @cache.value?(1)
       @cache[:a] = 1

data/thread_safe.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "thread_safe"
   gem.require_paths = ["lib"]
-  gem.version       = Threadsafe::VERSION
+  gem.version       = ThreadSafe::VERSION
   gem.license       = "Apache-2.0"
 
   gem.add_dependency 'atomic', ['>= 1.1.7', '< 2']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thread_safe
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Charles Oliver Nutter
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-26 00:00:00.000000000 Z
+date: 2014-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: atomic
@@ -115,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A collection of data structures and utilities to make thread-safe programming
@@ -128,4 +128,3 @@ test_files:
 - test/test_hash.rb
 - test/test_helper.rb
 - test/test_synchronized_delegator.rb
-has_rdoc: