Simplify AbstractCompletableTask / CompletableSubTask dependencies

Author: vsilaev

src/main/java/net/tascalate/concurrent/AbstractCompletableTask.java

@@ -57,12 +57,22 @@ abstract class AbstractCompletableTask<T> extends PromiseAdapterExtended<T>
 
     private final CallbackRegistry<T> callbackRegistry = new CallbackRegistry<>();
     protected final RunnableFuture<T> task;
-    protected final Callable<T> action;
 
     protected AbstractCompletableTask(Executor defaultExecutor, Callable<T> action) {
         super(defaultExecutor);
-        this.action = action;
-        this.task = new StageTransition(action);
+        this.task = new FutureTask<T>(action) {
+            @Override
+            protected void set(T v) {
+                super.set(v);
+                success(v);
+            };
+
+            @Override
+            protected void setException(Throwable t) {
+                super.setException(t);
+                failure(t);
+            };
+        };
     }
 
     private volatile CompletionStage<?> intermediateStage;
@@ -129,25 +139,6 @@ public String toString() {
         return String.format("%s@%d[%s]", getClass().getSimpleName(), System.identityHashCode(this), task);
     }
 
-    class StageTransition extends FutureTask<T>
-                          implements CompletableFuture.AsynchronousCompletionTask {
-        StageTransition(Callable<T> callable) {
-            super(callable);
-        }
-
-        @Override
-        protected void set(T v) {
-            super.set(v);
-            success(v);
-        };
-
-        @Override
-        protected void setException(Throwable t) {
-            super.setException(t);
-            failure(t);
-        };
-    }
-
     // Override thenApplyAsync and exceptionallyAsync just to minimize amount of wrappers
     // Otherwise delegation to handleAsync (in superclass) works perfect
     @Override

src/main/java/net/tascalate/concurrent/CompletableSubTask.java

@@ -27,7 +27,7 @@
  */
 class CompletableSubTask<T> extends AbstractCompletableTask<T> {
 
-    static class DelegatingCallable<T> implements Callable<T> {
+    private static class DelegatingCallable<T> implements Callable<T> {
         private final AtomicReference<Callable<T>> delegateRef = new AtomicReference<>();
 
         void setup(Callable<T> delegate) {
@@ -48,15 +48,21 @@ public T call() throws Exception {
         }
 
     }
+    
+    private final DelegatingCallable<T> action;
 
     CompletableSubTask(Executor executor) {
-        super(executor, new DelegatingCallable<>());
+        this(executor, new DelegatingCallable<>());
+    }
+    
+    private CompletableSubTask(Executor executor, DelegatingCallable<T> action) {
+        super(executor, action);
+        this.action = action;
     }
 
     @Override
-    void fireTransition(Callable<T> code) {
-        DelegatingCallable<T> transitionCall = (DelegatingCallable<T>) action;
-        transitionCall.setup(code);
+    final void fireTransition(Callable<T> code) {
+        action.setup(code);
         task.run();
     }