Simplify cancel methods cache

Author: vsilaev

src/main/java/net/tascalate/concurrent/core/Cache.java

@@ -23,11 +23,11 @@
 import java.util.function.Function;
 
 
-public final class Cache<K, V> {
+final class Cache<K, V> {
     private final Map<Reference<K>, V> entries = new ConcurrentHashMap<>();
     private final ReferenceQueue<K> queue = new ReferenceQueue<K>();
 
-    public V get(K key, Function<? super K, ? extends V> valueFactory) {
+    V get(K key, Function<? super K, ? extends V> valueFactory) {
         expungeStaleEntries();
         return entries.computeIfAbsent(new KeyReference<>(key), __ -> valueFactory.apply(key));
     }

src/main/java/net/tascalate/concurrent/core/CancelMethodsCache.java

@@ -27,6 +27,7 @@
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.CompletionStage;
 import java.util.function.Function;
+import java.util.function.Supplier;
 import java.util.stream.Stream;
 
 public final class CancelMethodsCache {
@@ -60,58 +61,41 @@ public static Cancellation cancellationOf(Class<?> stageClass) {
 
     private static ExceptionalCancellation cancelInterruptibleMethodOf(Class<?> clazz) {
         try {
-            Method m = clazz.getMethod("cancel", boolean.class);
-            Method mf = firstUnreflectableMethod(m);
-            if (null != mf) {
-                try {
-                    MethodHandle mh = MethodHandles.publicLookup()
-                                                   .unreflect(mf)
-                                                   .asType(MethodType.methodType(boolean.class, CompletionStage.class, boolean.class));            
-                    return (p, b) -> (boolean)mh.invokeExact(p, b);
-                } catch (IllegalAccessException ex) {
-                    // will try reflective
-                }
+            Method m = firstUnreflectableMethod( clazz.getMethod("cancel", boolean.class) );
+            if (null == m) {
+                return null;
             }
-            return (p, b) -> (Boolean)m.invoke(p, b);
+            MethodHandle mh = unreflect(m).asType(MethodType.methodType(boolean.class, CompletionStage.class, boolean.class));            
+            return (p, b) -> (boolean)mh.invokeExact(p, b);
+            //return (p, b) -> (Boolean)m.invoke(p, b);
         } catch (ReflectiveOperationException | SecurityException ex) {
             return null;
         }
     }
 
     private static ExceptionalCancellation cancelMethodOf(Class<?> clazz) {
         try {
-            Method m = clazz.getMethod("cancel");
-            Method mf = firstUnreflectableMethod(m);
-            if (null != mf) {
-                try {
-                    MethodHandle mh = MethodHandles.publicLookup()
-                                                   .unreflect(mf)
-                                                   .asType(MethodType.methodType(boolean.class, CompletionStage.class));
-                    return (p, b) -> (boolean)mh.invokeExact(p);
-                } catch (IllegalAccessException ex) {
-                    // will try reflective
-                } 
+            Method m = firstUnreflectableMethod( clazz.getMethod("cancel") );
+            if (null == m) {
+                return null;
             }
-            return (p, b) -> (Boolean)m.invoke(p);
+            MethodHandle mh = unreflect(m).asType(MethodType.methodType(boolean.class, CompletionStage.class));
+            return (p, b) -> (boolean)mh.invokeExact(p);
+            //return (p, b) -> (Boolean)m.invoke(p);
         } catch (ReflectiveOperationException | SecurityException ex) {
             return null;
         }
     }
 
     private static ExceptionalCancellation completeExceptionallyMethodOf(Class<?> clazz) {
         try {
-            Method m = clazz.getMethod("completeExceptionally", Throwable.class);
-            Method mf = firstUnreflectableMethod(m);
-            if (null != mf) {
-                try {
-                    MethodHandle mh = MethodHandles.publicLookup()
-                                                   .unreflect(mf)
-                                                   .asType(MethodType.methodType(boolean.class, CompletionStage.class, CancellationException.class));
-                    return (p, b) -> (boolean)mh.invokeExact(p, new CancellationException());
-                } catch (IllegalAccessException ex) {
-                }
+            Method m = firstUnreflectableMethod( clazz.getMethod("completeExceptionally", Throwable.class) );
+            if (null == m) {
+                return null;
             }
-            return (p, b) -> (Boolean)m.invoke(p, new CancellationException());
+            MethodHandle mh = unreflect(m).asType(MethodType.methodType(boolean.class, CompletionStage.class, CancellationException.class));
+            return (p, b) -> (boolean)mh.invokeExact(p, new CancellationException());
+            //return (p, b) -> (Boolean)m.invoke(p, new CancellationException());
         } catch (ReflectiveOperationException | SecurityException ex) {
             return null;
         }
@@ -139,15 +123,19 @@ private static Method firstUnreflectableMethod(Class<?> clazz, Method m, Set<Cla
             }
         }
         return
-        Stream.concat(Stream.of(clazz.getSuperclass()), Stream.of(clazz.getInterfaces()))
-              .filter(Objects::nonNull)
+        Stream.concat( Stream.of(clazz.getSuperclass()), Stream.of(clazz.getInterfaces()) )
+              .filter(c -> c != null && !visited.contains(c))
               .map(superClazz -> firstUnreflectableMethod(superClazz, m, visited))
               .filter(Objects::nonNull)
               .findFirst()
               .orElse(null)
         ;
     }
 
+    private static MethodHandle unreflect(Method m) throws IllegalAccessException {
+        return MethodHandles.publicLookup().unreflect(m);
+    }
+    
     @FunctionalInterface
     static interface ExceptionalCancellation {
         boolean apply(CompletionStage<?> p, boolean b) throws Throwable;