Refactoring Promises.dependent to instance method Promise.dependent

Author: vsilaev

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

@@ -228,7 +228,8 @@ public DependentPromise<T> onTimeout(Supplier<T> supplier, Duration duration, bo
 
         // timeout converted to supplier
         Promise<Supplier<T>> onTimeout = Promises
-            .dependent(Promises.delay(duration))
+            .delay(duration)
+            .dependent()
             .thenApply(d -> supplier, true);
 
         DependentPromise<T> result = this
@@ -241,6 +242,11 @@ public DependentPromise<T> onTimeout(Supplier<T> supplier, Duration duration, bo
         return result;
     }
 
+    @Override
+    public DependentPromise<T> dependent() {
+    	return this;
+    }
+    
     public <U> DependentPromise<U> thenApply(Function<? super T, ? extends U> fn) {
         return thenApply(fn, false);
     }

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

@@ -75,7 +75,7 @@ default Promise<T> orTimeout(Duration duration) {
     default Promise<T> orTimeout(Duration duration, boolean cancelOnTimeout) {
         Promise<T> onTimeout = Promises.failAfter(duration);
         // Use *async to execute on default "this" executor
-        Promise<T> result = Promises.dependent(this)
+        Promise<T> result = dependent()
             .applyToEitherAsync(onTimeout, Function.identity(), PromiseOrigin.PARAM_ONLY);
 
         result.whenComplete(Promises.timeoutsCleanup(this, onTimeout, cancelOnTimeout));
@@ -115,10 +115,11 @@ default Promise<T> onTimeout(Supplier<T> supplier, Duration duration, boolean ca
 
         // timeout converted to supplier
         Promise<Supplier<T>> onTimeout = Promises
-            .dependent(Promises.delay(duration))
+        	.delay(duration)
+        	.dependent()
             .thenApply(d -> supplier, true);
 
-        Promise<T> result = Promises.dependent(this)
+        Promise<T> result = dependent()
             // resolved value converted to supplier
             .thenApply(valueToSupplier, false)
             // Use *async to execute on default "this" executor
@@ -128,6 +129,15 @@ default Promise<T> onTimeout(Supplier<T> supplier, Duration duration, boolean ca
         return result;
     }
 
+    /**
+     * Converts this {@link Promise} to a {@link DependentPromise}
+     * @return
+     * created DependentPromise
+     */
+    default DependentPromise<T> dependent() {
+    	return DependentPromise.from(this);
+    }
+    
     public <U> Promise<U> thenApply(Function<? super T, ? extends U> fn);
 
     public <U> Promise<U> thenApplyAsync(Function<? super T, ? extends U> fn);

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

@@ -111,34 +111,9 @@ static <T, R> Promise<R> from(CompletionStage<T> stage,
         return result;
     }
 
-    /**
-     * Converts {@link CompletionStage} to a {@link DependentPromise}
-     * @param stage
-     * original CompletionStage
-     * @param <T>
-     * a type of the successfully resolved promise value  
-     * @return
-     * created DependentPromise
-     */
-    public static <T> DependentPromise<T> dependent(CompletionStage<T> stage) {
-        return dependent(from(stage));
-    }
-
-    /**
-     * Converts {@link Promise} to a {@link DependentPromise}
-     * @param stage
-     * original Promise
-     * @param <T>
-     * a type of the successfully resolved promise value 
-     * @return
-     * created DependentPromise
-     */
-    public static <T> DependentPromise<T> dependent(Promise<T> stage) {
-        return DependentPromise.from(stage);
-    }
-    
     public static <T> Promise<T> task(CompletionStage<T> stage, Executor executor) {
-        return dependent(CompletableTask.asyncOn(executor))
+        return CompletableTask.asyncOn(executor)
+               .dependent()
                .thenCombineAsync(stage, (u, v) -> v, PromiseOrigin.PARAM_ONLY);
     }
 
@@ -532,15 +507,15 @@ public static Promise<Void> poll(Runnable codeBlock, Executor executor, RetryPol
                 () -> { codeBlock.run(); return Optional.of(new Object()); }, 
                 executor, retryPolicy
             );
-            return dependent(wrappedResult).thenApply(v -> null, true);  
+            return wrappedResult.dependent().thenApply(v -> null, true);  
     }
 
     public static <T> Promise<T> poll(Callable<? extends T> codeBlock, Executor executor, RetryPolicy retryPolicy) {
         Promise<ObjectRef<T>> wrappedResult = pollOptional(
             () -> Optional.of(new ObjectRef<T>( codeBlock.call() )), 
             executor, retryPolicy
         );
-        return dependent(wrappedResult).thenApply(ObjectRef::dereference, true);
+        return wrappedResult.dependent().thenApply(ObjectRef::dereference, true);
     }
 
     public static <T> Promise<T> pollOptional(Callable<Optional<? extends T>> codeBlock, Executor executor, RetryPolicy retryPolicy) {