Fix errors in decorators (unimplemented methods; wrong wrapping); Implementing raw() for onCancel result

Author: vsilaev

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

@@ -77,9 +77,9 @@
  *   a type of the successfully resolved promise value    
  */
 public class ConfigurableDependentPromise<T> implements DependentPromise<T> {
-    final protected Promise<T> delegate;
-    final protected CompletionStage<?>[] cancellableOrigins;
-    final private Set<PromiseOrigin> defaultEnlistOptions;
+    protected final Promise<T> delegate;
+    protected final CompletionStage<?>[] cancellableOrigins;
+    protected final Set<PromiseOrigin> defaultEnlistOptions;
 
     protected ConfigurableDependentPromise(Promise<T> delegate, 
                                            Set<PromiseOrigin> defaultEnlistOptions, 
@@ -130,17 +130,7 @@ private static <U> DependentPromise<U> doWrap(Promise<U> original,
 
     @Override
     public DependentPromise<T> onCancel(Runnable code) {
-        return new ConfigurableDependentPromise<T>(this, defaultEnlistOptions, null) {
-            @Override
-            public boolean cancel(boolean mayInterruptIfRunning) {
-                if (super.cancel(mayInterruptIfRunning)) {
-                    code.run();
-                    return true;
-                } else {
-                    return false;
-                }
-            }
-        };
+        return new ExtraCancellationPromise<>(this, defaultEnlistOptions, code);
     }
 
     // All delay overloads delegate to these methods
@@ -839,7 +829,6 @@ private static boolean identicalSets(Set<?> a, Set<?> b) {
         return a.containsAll(b) && b.containsAll(a);
     }
 
-    
     static class UndecoratedCancellationPromise<T> extends AbstractPromiseDecorator<T, Promise<T>> {
         private final CompletionStage<?>[] dependent;
         UndecoratedCancellationPromise(Promise<T> original, CompletionStage<?>[] dependent) {
@@ -869,4 +858,32 @@ protected <U> Promise<U> wrap(CompletionStage<U> original) {
             return (Promise<U>)original;
         }
     }
+    
+    static class ExtraCancellationPromise<T> extends ConfigurableDependentPromise<T> {
+        private final Runnable code;
+        public ExtraCancellationPromise(Promise<T> origin, Set<PromiseOrigin> enlistOptions, Runnable code) {
+            super(origin, enlistOptions, null);
+            this.code = code;
+        }
+        
+        @Override
+        public boolean cancel(boolean mayInterruptIfRunning) {
+            if (super.cancel(mayInterruptIfRunning)) {
+                code.run();
+                return true;
+            } else {
+                return false;
+            }
+        }
+        
+        @Override
+        public Promise<T> raw() {
+            Promise<T> undecorated = super.raw();
+            if (delegate == undecorated) {
+                return this;
+            } else {
+                return new ExtraCancellationPromise<>(undecorated, defaultEnlistOptions, code);
+            }
+        }
+    }
 }

src/main/java/net/tascalate/concurrent/decorators/AbstractDependentPromiseDecorator.java

@@ -43,7 +43,7 @@ protected AbstractDependentPromiseDecorator(DependentPromise<T> delegate) {
 
     @Override
     public DependentPromise<T> dependent() {
-        DependentPromise<T> result = delegate.dependent();
+        DependentPromise<T> result = super.dependent();
         if (result == delegate) {
             return this;
         } else {
@@ -53,7 +53,7 @@ public DependentPromise<T> dependent() {
 
     @Override
     public DependentPromise<T> dependent(Set<PromiseOrigin> defaultEnlistOptions) {
-        DependentPromise<T> result = delegate.dependent(defaultEnlistOptions);
+        DependentPromise<T> result = super.dependent(defaultEnlistOptions);
         if (result == delegate) {
             return this;
         } else {

src/main/java/net/tascalate/concurrent/decorators/AbstractPromiseDecorator.java

@@ -70,12 +70,12 @@ public Promise<T> raw() {
 
     @Override
     public DependentPromise<T> dependent() {
-        throw new UnsupportedOperationException("Method must be re-implemented");
+        return delegate.dependent();
     }
 
     @Override
     public DependentPromise<T> dependent(Set<PromiseOrigin> defaultEnlistOptions) {
-        throw new UnsupportedOperationException("Method must be re-implemented");
+        return delegate.dependent(defaultEnlistOptions);
     }
 
     @Override

src/main/java/net/tascalate/concurrent/decorators/ExecutorBoundDependentPromise.java

@@ -39,22 +39,12 @@ protected <U> DependentPromise<U> wrap(CompletionStage<U> original) {
         return new ExecutorBoundDependentPromise<>((DependentPromise<U>)original, defaultExecutor);
     }
 
-    @Override
-    public DependentPromise<T> dependent() {
-        return new ExecutorBoundDependentPromise<>(super.dependent(), defaultExecutor);
-    }
-    
-    @Override
-    public DependentPromise<T> dependent(Set<PromiseOrigin> defaultEnlistOptions) {
-        return new ExecutorBoundDependentPromise<>(super.dependent(defaultEnlistOptions), defaultExecutor);
-    }
-    
     @Override
     public DependentPromise<T> defaultAsyncOn(Executor executor) {
         if (executor == defaultExecutor) {
             return this;
         } else {
-            return new ExecutorBoundDependentPromise<>(delegate, executor);
+            return super.defaultAsyncOn(executor);
         }
     }
 

src/main/java/net/tascalate/concurrent/decorators/ExecutorBoundPromise.java

@@ -56,7 +56,7 @@ public Promise<T> defaultAsyncOn(Executor executor) {
         if (executor == defaultExecutor) {
             return this;
         } else {
-            return new ExecutorBoundPromise<>(delegate, executor);
+            return super.defaultAsyncOn(executor);
         }
     }