Merge pull request #37 from kares/cache-key

cache.key support

Author: headius

.gitignore

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

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

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

@@ -178,11 +178,17 @@ public RubyBoolean replace_pair(IRubyObject key, IRubyObject oldValue, IRubyObje
             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);

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

@@ -25,4 +25,7 @@ public interface BiFun<A,B,T> { T apply(A a, B b); }
     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);
 }

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

@@ -2430,8 +2430,8 @@ else if (f.casHash(fh, fh | LOCKED)) {
     @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 @@ else if ((t = it.tab) == null && // force parent tab initialization
          * 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 @@ else if ((m = map) != null && (t = tab = m.table) != null)
                     }                           // 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 boolean containsValue(Object value) {
         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

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

@@ -2422,8 +2422,8 @@ else if (f.casHash(fh, fh | LOCKED)) {
     @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 @@ else if ((t = it.tab) == null && // force parent tab initialization
          * 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 @@ else if ((m = map) != null && (t = tab = m.table) != null)
                     }                           // 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 boolean containsValue(Object value) {
         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

lib/thread_safe/cache.rb

@@ -95,6 +95,12 @@ def each_value
       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

test/test_cache.rb

@@ -371,14 +371,24 @@ def test_get_and_set
   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
       assert_equal true,  @cache.key?(:a)
     end
   end
 
-  def test_value
+  def test_value?
     with_or_without_default_proc do
       assert_equal false, @cache.value?(1)
       @cache[:a] = 1