Get rid of LinkedCompletion class and replace it in terms of Promise.onCancel

Author: vsilaev

pom.xml

@@ -6,7 +6,7 @@
 
 	<groupId>net.tascalate</groupId>
 	<artifactId>net.tascalate.concurrent</artifactId>
-	<version>0.8.3</version>
+	<version>0.8.4</version>
 	<packaging>jar</packaging>  
 
 	<name>Tascalate Concurrent</name>

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

@@ -15,7 +15,6 @@
  */
 package net.tascalate.concurrent;
 
-import static net.tascalate.concurrent.LinkedCompletion.FutureCompletion;
 import static net.tascalate.concurrent.SharedFunctions.cancelPromise;
 import static net.tascalate.concurrent.SharedFunctions.selectFirst;
 import static net.tascalate.concurrent.SharedFunctions.updateReference;
@@ -779,15 +778,24 @@ public CompletableFuture<T> toCompletableFuture(boolean enlistOrigin) {
         if (!enlistOrigin) {
             return delegate.toCompletableFuture();
         } else {
-            FutureCompletion<T> result = new FutureCompletion<T>().dependsOn(this);
+            CompletablePromise<T> result = new CompletablePromise<T>() {
+                @Override 
+                public boolean cancel(boolean mayInterruptIfRunning) {
+                    if (ConfigurableDependentPromise.this.cancel(mayInterruptIfRunning)) {
+                        return super.cancel(mayInterruptIfRunning);
+                    } else {
+                        return false;
+                    }
+                }
+            };
             whenComplete((r, e) -> {
                if (null != e) {
-                   result.completeExceptionally(e);
+                   result.onFailure(e);
                } else {
-                   result.complete(r);
+                   result.onSuccess(r);
                }
             });
-            return result;
+            return result.toCompletableFuture();
         }
     }
 

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

@@ -15,7 +15,6 @@
  */
 package net.tascalate.concurrent;
 
-import static net.tascalate.concurrent.LinkedCompletion.StageCompletion;
 import static net.tascalate.concurrent.SharedFunctions.cancelPromise;
 import static net.tascalate.concurrent.SharedFunctions.selectFirst;
 import static net.tascalate.concurrent.SharedFunctions.unwrapCompletionException;
@@ -694,15 +693,15 @@ private static <T> Promise<T> applyExecutionTimeout(Promise<T> singleInvocationP
     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<T>().dependsOn(original);
+        CompletablePromise<T> result = new CompletablePromise<>();
         original.whenComplete((r, e) -> {
            if (null == e) {
-               result.complete( resultMapper.apply(r) );
+               result.onSuccess( resultMapper.apply(r) );
            } else {
-               result.completeExceptionally( errorMapper.apply(e) );
+               result.onFailure( errorMapper.apply(e) );
            }
         });
-        return result.toPromise();
+        return result.onCancel(() -> cancelPromise(original, true));
     }
 
     private static <T> T extractFirstNonNull(Collection<? extends T> collection) {

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

@@ -15,8 +15,6 @@
  */
 package net.tascalate.concurrent;
 
-import static net.tascalate.concurrent.LinkedCompletion.FutureCompletion;
-
 import java.time.Duration;
 import java.time.temporal.ChronoUnit;
 import java.util.Objects;
@@ -44,11 +42,11 @@ private Timeouts() {}
      */
     static Promise<Duration> delay(Duration duration) {
         TimeMeasurment tm = new TimeMeasurment(duration);
-        FutureCompletion<Duration> result = new FutureCompletion<>();
+        CompletablePromise<Duration> result = new CompletablePromise<>();
         Future<?> timeout = scheduler.schedule( 
-            () -> result.complete(duration), tm.amount, tm.unit 
+            () -> result.onSuccess(duration), tm.amount, tm.unit 
         );
-        return result.dependsOn(timeout).toPromise();
+        return result.onCancel(() -> timeout.cancel(true));
     }
 
     /**
@@ -81,12 +79,12 @@ static <T> Promise<T> delayed(T value, Duration duration) {
      */
     static <T> Promise<T> failAfter(Duration duration) {
         TimeMeasurment tm = new TimeMeasurment(duration);
-        FutureCompletion<T> result = new FutureCompletion<>();
+        CompletablePromise<T> result = new CompletablePromise<>();
         Future<?> timeout = scheduler.schedule(
-            () -> result.completeExceptionally(new TimeoutException("Timeout after " + duration)), 
+            () -> result.onFailure(new TimeoutException("Timeout after " + duration)), 
             tm.amount, tm.unit
         );
-        return result.dependsOn(timeout).toPromise();
+        return result.onCancel(() -> timeout.cancel(true));
     }
 
     /**