"native" key support on JRuby's cache backend

Author: kares

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