Moved CompletableFuture subclass references to a separate class, and instantiation to a factory method, in order to avoid premature loading of the class. Fixes failsafe-lib#59.

Author: jhalterman

src/main/java/net/jodah/failsafe/AsyncFailsafe.java

@@ -147,7 +147,7 @@ public FailsafeFuture<Void> runAsync(AsyncRunnable runnable) {
   @SuppressWarnings("unchecked")
   private <T> java.util.concurrent.CompletableFuture<T> call(AsyncCallableWrapper<T> callable) {
     FailsafeFuture<T> future = new FailsafeFuture<T>((FailsafeConfig<T, ?>) this);
-    java.util.concurrent.CompletableFuture<T> response = Functions.cancellableFutureOf(future);
+    java.util.concurrent.CompletableFuture<T> response = net.jodah.failsafe.internal.util.CancellableFuture.of(future);
     future.inject(response);
     call(callable, future);
     return response;

src/main/java/net/jodah/failsafe/Functions.java

@@ -1,9 +1,7 @@
 package net.jodah.failsafe;
 
 import java.util.concurrent.Callable;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Semaphore;
-import java.util.function.BiConsumer;
 
 import net.jodah.failsafe.function.AsyncCallable;
 import net.jodah.failsafe.function.AsyncRunnable;
@@ -155,7 +153,7 @@ public T call() throws Exception {
         try {
           execution.before();
           asyncFutureLock.acquire();
-          callable.call(execution).whenComplete(new BiConsumer<T, Throwable>() {
+          callable.call(execution).whenComplete(new java.util.function.BiConsumer<T, Throwable>() {
             @Override
             public void accept(T innerResult, Throwable failure) {
               try {
@@ -187,7 +185,7 @@ static <T> AsyncCallableWrapper<T> asyncOfFuture(final Callable<java.util.concur
       public T call() throws Exception {
         try {
           execution.before();
-          callable.call().whenComplete(new BiConsumer<T, Throwable>() {
+          callable.call().whenComplete(new java.util.function.BiConsumer<T, Throwable>() {
             @Override
             public void accept(T innerResult, Throwable failure) {
               // Unwrap CompletionException cause
@@ -213,7 +211,7 @@ static <T> AsyncCallableWrapper<T> asyncOfFuture(
       public T call() throws Exception {
         try {
           execution.before();
-          callable.call(execution).whenComplete(new BiConsumer<T, Throwable>() {
+          callable.call(execution).whenComplete(new java.util.function.BiConsumer<T, Throwable>() {
             @Override
             public void accept(T innerResult, Throwable failure) {
               // Unwrap CompletionException cause
@@ -264,16 +262,6 @@ public T call() throws Exception {
     };
   }
 
-  static <T> CompletableFuture<T> cancellableFutureOf(final FailsafeFuture<T> future) {
-    return new CompletableFuture<T>() {
-      @Override
-      public boolean cancel(boolean mayInterruptIfRunning) {
-        future.cancel(mayInterruptIfRunning);
-        return super.cancel(mayInterruptIfRunning);
-      }
-    };
-  }
-
   static <T, U, R> CheckedBiFunction<T, U, R> fnOf(final Callable<R> callable) {
     return new CheckedBiFunction<T, U, R>() {
       @Override

src/main/java/net/jodah/failsafe/internal/util/CancellableFuture.java

@@ -0,0 +1,31 @@
+package net.jodah.failsafe.internal.util;
+
+import net.jodah.failsafe.FailsafeFuture;
+
+/**
+ * A CompletableFuture that forwards cancellation requests to an associated FailsafeFuture.
+ * 
+ * @author Jonathan Halterman
+ * @param <T>
+ */
+public class CancellableFuture<T> extends java.util.concurrent.CompletableFuture<T> {
+  final FailsafeFuture<T> future;
+
+  private CancellableFuture(FailsafeFuture<T> future) {
+    this.future = future;
+  }
+
+  /**
+   * We use a static factory method instead of the constructor to avoid the class from being accidentally loaded on
+   * pre-Java 8 VMs when it's not available.
+   */
+  public static <T> java.util.concurrent.CompletableFuture<T> of(FailsafeFuture<T> future) {
+    return new CancellableFuture<T>(future);
+  }
+
+  @Override
+  public boolean cancel(boolean mayInterruptIfRunning) {
+    future.cancel(mayInterruptIfRunning);
+    return super.cancel(mayInterruptIfRunning);
+  }
+};