Remove nona-pi methods from Promises

Author: vsilaev

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

@@ -23,6 +23,8 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 
+import net.tascalate.concurrent.decorators.AbstractCompletionStageDecorator;
+
 class ExecutorBoundCompletionStage<T> implements CompletionStage<T> {
     private final CompletionStage<T> delegate;
     private final Executor defaultExecutor;
@@ -216,19 +218,19 @@ public CompletionStage<T> exceptionallyAsync(Function<Throwable, ? extends T> fn
     }
 
     public CompletionStage<T> exceptionallyAsync(Function<Throwable, ? extends T> fn, Executor executor) {
-        return wrap(Promises.exceptionallyApplyAsync(delegate, fn, executor));
+        return wrap(AbstractCompletionStageDecorator.exceptionallyAsync(delegate, fn, executor));
     }
 
     public CompletionStage<T> exceptionallyCompose(Function<Throwable, ? extends CompletionStage<T>> fn) {
-        return wrap(Promises.exceptionallyCompose(delegate, fn));
+        return wrap(AbstractCompletionStageDecorator.exceptionallyCompose(delegate, fn));
     }
 
     public CompletionStage<T> exceptionallyComposeAsync(Function<Throwable, ? extends CompletionStage<T>> fn) {
         return exceptionallyComposeAsync(fn, defaultExecutor);
     }
 
     public CompletionStage<T> exceptionallyComposeAsync(Function<Throwable, ? extends CompletionStage<T>> fn, Executor executor) {
-        return wrap(Promises.exceptionallyComposeAsync(delegate, fn, executor));
+        return wrap(AbstractCompletionStageDecorator.exceptionallyComposeAsync(delegate, fn, executor));
     }
 
     public CompletionStage<T> whenComplete(BiConsumer<? super T, ? super Throwable> action) {

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

@@ -477,46 +477,6 @@ public static <T> Promise<List<T>> atLeast(int minResultsCount, int maxErrorsCou
         }
     }
 
-    public static <T> CompletionStage<T> exceptionallyApplyAsync(CompletionStage<T> delegate, 
-                                                                 Function<Throwable, ? extends T> fn) {
-        return delegate.handle((r, ex) -> ex == null ? 
-                               delegate : 
-                               delegate.<T>handleAsync((r1, ex1) -> fn.apply(ex1)))
-                       .thenCompose(Function.identity());        
-    }
-    
-    public static <T> CompletionStage<T> exceptionallyApplyAsync(CompletionStage<T> delegate, 
-                                                                 Function<Throwable, ? extends T> fn, Executor executor) {
-        return delegate.handle((r, ex) -> ex == null ? 
-                               delegate : 
-                               delegate.<T>handleAsync((r1, ex1) -> fn.apply(ex1), executor))
-                       .thenCompose(Function.identity());        
-    }
-    
-    public static <T> CompletionStage<T> exceptionallyCompose(CompletionStage<T> delegate, 
-                                                              Function<Throwable, ? extends CompletionStage<T>> fn) {
-        return delegate.handle((r, ex) -> ex == null ? delegate : fn.apply(ex))
-                       .thenCompose(Function.identity());
-    }
-    
-    public static <T> CompletionStage<T> exceptionallyComposeAsync(CompletionStage<T> delegate, 
-                                                                   Function<Throwable, ? extends CompletionStage<T>> fn) {
-        return delegate.handle((r, ex) -> ex == null ? 
-                               delegate : 
-                               delegate.handleAsync((r1, ex1) -> fn.apply(ex1))
-                                       .thenCompose(Function.identity()))
-                       .thenCompose(Function.identity());
-    }
-    
-    public static <T> CompletionStage<T> exceptionallyComposeAsync(CompletionStage<T> delegate, 
-                                                                   Function<Throwable, ? extends CompletionStage<T>> fn, Executor executor) {
-        return delegate.handle((r, ex) -> ex == null ? 
-                               delegate : 
-                               delegate.handleAsync((r1, ex1) -> fn.apply(ex1), executor)
-                                       .thenCompose(Function.identity()))
-                       .thenCompose(Function.identity());
-    }
-    
     public static Promise<Void> retry(Runnable codeBlock, Executor executor, 
                                       RetryPolicy<? super Void> retryPolicy) {
 

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

@@ -24,7 +24,6 @@
 import java.util.function.Function;
 
 import net.tascalate.concurrent.Promise;
-import net.tascalate.concurrent.Promises;
 
 /**
  * Helper class to create a concrete {@link Promise} subclass via delegation
@@ -187,23 +186,23 @@ public Promise<T> exceptionally(Function<Throwable, ? extends T> fn) {
     }
 
     public Promise<T> exceptionallyAsync(Function<Throwable, ? extends T> fn) {
-        return wrap(Promises.exceptionallyApplyAsync(delegate, fn));
+        return wrap(exceptionallyAsync(delegate, fn));
     }
 
     public Promise<T> exceptionallyAsync(Function<Throwable, ? extends T> fn, Executor executor) {
-        return wrap(Promises.exceptionallyApplyAsync(delegate, fn, executor));
+        return wrap(exceptionallyAsync(delegate, fn, executor));
     }
 
     public Promise<T> exceptionallyCompose(Function<Throwable, ? extends CompletionStage<T>> fn) {
-        return wrap(Promises.exceptionallyCompose(delegate, fn));
+        return wrap(exceptionallyCompose(delegate, fn));
     }
 
     public Promise<T> exceptionallyComposeAsync(Function<Throwable, ? extends CompletionStage<T>> fn) {
-        return wrap(Promises.exceptionallyComposeAsync(delegate, fn));
+        return wrap(exceptionallyComposeAsync(delegate, fn));
     }
 
     public Promise<T> exceptionallyComposeAsync(Function<Throwable, ? extends CompletionStage<T>> fn, Executor executor) {
-        return wrap(Promises.exceptionallyComposeAsync(delegate, fn, executor));
+        return wrap(exceptionallyComposeAsync(delegate, fn, executor));
     }
 
     public Promise<T> whenComplete(BiConsumer<? super T, ? super Throwable> action) {
@@ -233,5 +232,46 @@ public <U> Promise<U> handleAsync(BiFunction<? super T, Throwable, ? extends U>
     public CompletableFuture<T> toCompletableFuture() {
         return delegate.toCompletableFuture();
     }
+    
+    
+    public static <T> CompletionStage<T> exceptionallyAsync(CompletionStage<T> delegate, 
+                                                            Function<Throwable, ? extends T> fn) {
+        return delegate.handle((r, ex) -> ex == null ? 
+                               delegate : 
+                               delegate.<T>handleAsync((r1, ex1) -> fn.apply(ex1)))
+                       .thenCompose(Function.identity());        
+    }
+    
+    public static <T> CompletionStage<T> exceptionallyAsync(CompletionStage<T> delegate, 
+                                                            Function<Throwable, ? extends T> fn, Executor executor) {
+        return delegate.handle((r, ex) -> ex == null ? 
+                               delegate : 
+                               delegate.<T>handleAsync((r1, ex1) -> fn.apply(ex1), executor))
+                       .thenCompose(Function.identity());        
+    }
+    
+    public static <T> CompletionStage<T> exceptionallyCompose(CompletionStage<T> delegate, 
+                                                              Function<Throwable, ? extends CompletionStage<T>> fn) {
+        return delegate.handle((r, ex) -> ex == null ? delegate : fn.apply(ex))
+                       .thenCompose(Function.identity());
+    }
+    
+    public static <T> CompletionStage<T> exceptionallyComposeAsync(CompletionStage<T> delegate, 
+                                                                   Function<Throwable, ? extends CompletionStage<T>> fn) {
+        return delegate.handle((r, ex) -> ex == null ? 
+                               delegate : 
+                               delegate.handleAsync((r1, ex1) -> fn.apply(ex1))
+                                       .thenCompose(Function.identity()))
+                       .thenCompose(Function.identity());
+    }
+    
+    public static <T> CompletionStage<T> exceptionallyComposeAsync(CompletionStage<T> delegate, 
+                                                                   Function<Throwable, ? extends CompletionStage<T>> fn, Executor executor) {
+        return delegate.handle((r, ex) -> ex == null ? 
+                               delegate : 
+                               delegate.handleAsync((r1, ex1) -> fn.apply(ex1), executor)
+                                       .thenCompose(Function.identity()))
+                       .thenCompose(Function.identity());
+    }
 
 }