Refctoring of internal LinkedCompletion usages

Author: vsilaev

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

@@ -16,6 +16,7 @@
 package net.tascalate.concurrent;
 
 import static net.tascalate.concurrent.SharedFunctions.cancelPromise;
+import static net.tascalate.concurrent.LinkedCompletion.FutureCompletion;
 
 import java.time.Duration;
 import java.util.Arrays;
@@ -642,7 +643,7 @@ public Promise<T> raw() {
     }
 
     protected Promise<T> cancellablePromiseOf(Promise<T> original) {
-        return new MultitargetCancellablePromise<>(original, cancellableOrigins);
+        return new UndecoratedCancellationPromise<>(original, cancellableOrigins);
     }
 
     @Override
@@ -654,17 +655,7 @@ public CompletableFuture<T> toCompletableFuture(boolean enlistOrigin) {
         if (!enlistOrigin) {
             return delegate.toCompletableFuture();
         } else {
-            CompletableFuture<T> result = new CompletableFuture<T>() {
-                @Override
-                public boolean cancel(boolean mayInterruptIfRunning) {
-                    if (super.cancel(mayInterruptIfRunning)) {
-                        ConfigurableDependentPromise.this.cancel(mayInterruptIfRunning);
-                        return true;
-                    } else {
-                        return false;
-                    }
-                }
-            };
+            FutureCompletion<T> result = new FutureCompletion<T>().dependsOn(this);
             whenComplete((r, e) -> {
                if (null != e) {
                    result.completeExceptionally(e);
@@ -715,9 +706,9 @@ private static boolean identicalSets(Set<?> a, Set<?> b) {
     }
 
 
-    static class MultitargetCancellablePromise<T> extends AbstractPromiseDecorator<T, Promise<T>> {
+    static class UndecoratedCancellationPromise<T> extends AbstractPromiseDecorator<T, Promise<T>> {
         private final CompletionStage<?>[] dependent;
-        MultitargetCancellablePromise(Promise<T> original, CompletionStage<?>[] dependent) {
+        UndecoratedCancellationPromise(Promise<T> original, CompletionStage<?>[] dependent) {
             super(original);
             this.dependent = dependent;
         }
@@ -740,6 +731,7 @@ public Promise<T> raw() {
 
         @Override
         protected <U> Promise<U> wrap(CompletionStage<U> original) {
+            // No wrapping by definition
             return (Promise<U>)original;
         }
     }

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

@@ -51,6 +51,11 @@ static final class FutureCompletion<T> extends LinkedCompletion<T, Future<?>> {
         boolean cancelDependency(boolean mayInterruptIfRunning) {
             return dependency.cancel(mayInterruptIfRunning);
         }
+        
+        @Override
+        FutureCompletion<T> dependsOn(Future<?> dependency) {
+            return (FutureCompletion<T>)super.dependsOn(dependency);
+        }
     };
 
 
@@ -59,6 +64,11 @@ static final class StageCompletion<T> extends LinkedCompletion<T, CompletionStag
         boolean cancelDependency(boolean mayInterruptIfRunning) {
             return cancelPromise(dependency, mayInterruptIfRunning);
         }
+        
+        @Override
+        StageCompletion<T> dependsOn(CompletionStage<?> dependency) {
+            return (StageCompletion<T>)super.dependsOn(dependency);
+        }
     };
 }
 

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

@@ -560,15 +560,15 @@ private static <T> void pollOnce(Callable<Optional<? extends T>> codeBlock,
     private static <T, U> Promise<T> transform(CompletionStage<U> original, 
                                                Function<? super U, ? extends T> resultMapper, 
                                                Function<? super Throwable, ? extends Throwable> errorMapper) {
-        StageCompletion<T> result = new StageCompletion<>();
+        StageCompletion<T> result = new StageCompletion<T>().dependsOn(original);
         original.whenComplete((r, e) -> {
            if (null == e) {
                result.complete( resultMapper.apply(r) );
            } else {
                result.completeExceptionally( errorMapper.apply(e) );
            }
         });
-        return result.dependsOn(original).toPromise();
+        return result.toPromise();
     }
 
     private static <T> T extractFirstNonNull(Collection<? extends T> collection) {

src/test/java/net/tascalate/concurrent/DependentPromiseTests.java

@@ -15,10 +15,13 @@
  */
 package net.tascalate.concurrent;
 
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicInteger;
+
 import org.junit.After;
-import static org.junit.Assert.*;
 import org.junit.Before;
 import org.junit.Test;