Starting next iteration

Author: vsilaev

pom.xml

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

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

@@ -89,7 +89,7 @@ protected void cancelOrigins(boolean mayInterruptIfRunning) {
     @Override
     public boolean cancel(boolean mayInterruptIfRunning) {
         if (task.cancel(mayInterruptIfRunning)) {
-            onError(new CancellationException());
+            failure(new CancellationException());
             cancelOrigins(mayInterruptIfRunning);
             return true;
         } else {
@@ -130,11 +130,11 @@ public boolean isCompletedExceptionally() {
         return callbackRegistry.isFailure();
     }
 
-    boolean onSuccess(T result) {
+    boolean success(T result) {
         return callbackRegistry.success(result);
     }
 
-    boolean onError(Throwable ex) {
+    boolean failure(Throwable ex) {
         return callbackRegistry.failure(ex);
     }
 
@@ -152,13 +152,13 @@ class StageTransition extends FutureTask<T>
         @Override
         protected void set(T v) {
             super.set(v);
-            onSuccess(v);
+            success(v);
         };
 
         @Override
         protected void setException(Throwable t) {
             super.setException(t);
-            onError(t);
+            failure(t);
         };
     }
 
@@ -465,9 +465,9 @@ private <R, U> Promise<U> doApplyToEitherAsync(CompletionStage<? extends R> firs
         // of Future-defined methods are functional.
         BiConsumer<R, Throwable> action = (result, failure) -> {
             if (failure == null) {
-                nextStage.onSuccess(result);
+                nextStage.success(result);
             } else {
-                nextStage.onError(forwardException(failure));
+                nextStage.failure(forwardException(failure));
             }
         };
         // only the first result is accepted by completion stage,

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

@@ -36,7 +36,7 @@
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 
-import net.tascalate.concurrent.core.Delegator;
+import net.tascalate.concurrent.core.Decorator;
 import net.tascalate.concurrent.decorators.AbstractPromiseDecorator; 
 
 /**
@@ -75,7 +75,7 @@
  * @param <T>
  *   a type of the successfully resolved promise value    
  */
-public class ConfigurableDependentPromise<T> implements DependentPromise<T>, Delegator<T> {
+public class ConfigurableDependentPromise<T> implements DependentPromise<T>, Decorator<T> {
     protected final Promise<T> delegate;
     protected final CompletionStage<?>[] cancellableOrigins;
     protected final Set<PromiseOrigin> defaultEnlistOptions;
@@ -880,10 +880,10 @@ public String toString() {
     }
 
     private static <T> CompletionStage<T> alphaOf(Promise<T> promise) {
-        if (promise instanceof Delegator) {
+        if (promise instanceof Decorator) {
             @SuppressWarnings("unchecked")
-            Delegator<T> delegator = (Delegator<T>)promise;
-            return delegator.α();
+            Decorator<T> decorator = (Decorator<T>)promise;
+            return decorator.α();
         } else {
             return promise;
         }

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

@@ -128,7 +128,7 @@ default Promise<T> delay(Duration duration, boolean delayOnError) {
         CompletableFuture<Try<? super T>> delayed = new CompletableFuture<>();
         whenComplete(Timeouts.configureDelay(this, delayed, duration, delayOnError));
         return this.dependent()
-                   .handle(Try.liftResult(), false)
+                   .handle(Try.lift(), false)
                    // Use *Async to execute on default "this" executor
                    .thenCombineAsync(delayed, selectFirst(), PromiseOrigin.ALL)
                    .thenCompose(Try::asPromise, true)
@@ -151,7 +151,7 @@ default Promise<T> orTimeout(Duration duration, boolean cancelOnTimeout) {
         Promise<Try<T>> onTimeout = Timeouts.delayed(null, duration);
         DependentPromise<T> result = 
         this.dependent()
-            .handle(Try.liftResult(), false)
+            .handle(Try.lift(), false)
             // Use *Async to execute on default "this" executor
             .applyToEitherAsync(onTimeout, v -> Try.doneOrTimeout(v, duration), PromiseOrigin.ALL)
             .thenCompose(Try::asPromise, true);
@@ -176,7 +176,7 @@ default Promise<T> onTimeout(T value, Duration duration, boolean cancelOnTimeout
         Promise<Try<T>> onTimeout = Timeouts.delayed(Try.success(value), duration);
         DependentPromise<T> result = 
         this.dependent()
-            .handle(Try.liftResult(), false)
+            .handle(Try.lift(), false)
             // Use *Async to execute on default "this" executor
             .applyToEitherAsync(onTimeout, Function.identity(), PromiseOrigin.ALL)
             .thenCompose(Try::asPromise, true);
@@ -203,7 +203,7 @@ default Promise<T> onTimeout(Supplier<? extends T> supplier, Duration duration,
 
         DependentPromise<T> result = 
         this.dependent()
-            .handle(Try.liftResult(), false)
+            .handle(Try.lift(), false)
             .thenApply(SharedFunctions::supply, true)
             // Use *Async to execute on default "this" executor
             .applyToEitherAsync(onTimeout, Supplier::get, PromiseOrigin.ALL)

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

@@ -1010,19 +1010,19 @@ public static <K, T> Promise<Map<K, T>> atLeast(int minResultsCount, int maxErro
     public static Promise<Void> retry(Runnable codeBlock, Executor executor, 
                                       RetryPolicy<? super Void> retryPolicy) {
 
-        return retry(RetryRunnable.of(codeBlock), executor, retryPolicy);
+        return retry(RetryRunnable.from(codeBlock), executor, retryPolicy);
     }
 
     public static Promise<Void> retry(RetryRunnable codeBlock, Executor executor, 
                                       RetryPolicy<? super Void> retryPolicy) {
 
-        return retry(RetryCallable.of(codeBlock), executor, retryPolicy.acceptNullResult());
+        return retry(RetryCallable.from(codeBlock), executor, retryPolicy.acceptNullResult());
     }
 
     public static <T> Promise<T> retry(Callable<T> codeBlock, Executor executor, 
                                        RetryPolicy<? super T> retryPolicy) {
 
-        return retry(RetryCallable.of(codeBlock), executor, retryPolicy);
+        return retry(RetryCallable.from(codeBlock), executor, retryPolicy);
     }
 
     public static <T extends C, C> Promise<T> retry(RetryCallable<T, C> codeBlock, Executor executor, 
@@ -1037,7 +1037,7 @@ public static <T extends C, C> Promise<T> retry(RetryCallable<T, C> codeBlock, E
     public static <T> Promise<T> retryOptional(Callable<Optional<T>> codeBlock, Executor executor, 
                                                RetryPolicy<? super T> retryPolicy) {
 
-        return retryOptional(RetryCallable.of(codeBlock), executor, retryPolicy);
+        return retryOptional(RetryCallable.from(codeBlock), executor, retryPolicy);
     }
 
     public static <T extends C, C> Promise<T> retryOptional(RetryCallable<Optional<T>, C> codeBlock, Executor executor, 
@@ -1050,7 +1050,7 @@ public static <T extends C, C> Promise<T> retryOptional(RetryCallable<Optional<T
     public static <T> Promise<T> retryFuture(Callable<? extends CompletionStage<T>> invoker, 
                                              RetryPolicy<? super T> retryPolicy) {
 
-        return retryFuture(RetryCallable.of(invoker), retryPolicy);
+        return retryFuture(RetryCallable.from(invoker), retryPolicy);
     }
 
     public static <T extends C, C> Promise<T> retryFuture(RetryCallable<? extends CompletionStage<T>, C> futureFactory, 

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

@@ -21,18 +21,18 @@
 public interface RetryCallable<V, T> {
     V call(RetryContext<T> ctx) throws Exception;
 
-    public static <V, T> RetryCallable<V, T> of(Callable<? extends V> callable) {
+    public static <V, T> RetryCallable<V, T> from(Callable<? extends V> callable) {
         return ctx -> callable.call();
     }
 
-    public static RetryCallable<Void, Void> of(RetryRunnable runnable) {
+    public static RetryCallable<Void, Void> from(RetryRunnable runnable) {
         return ctx -> { 
             runnable.run(ctx); 
             return null; 
         };
     }
 
-    public static RetryCallable<Void, Void> of(Runnable runnable) {
-        return RetryCallable.of(RetryRunnable.of(runnable));
+    public static RetryCallable<Void, Void> from(Runnable runnable) {
+        return RetryCallable.from(RetryRunnable.from(runnable));
     }
 }

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

@@ -19,7 +19,7 @@
 public interface RetryRunnable {
     void run(RetryContext<Void> ctx);
 
-    public static RetryRunnable of(Runnable runnable) {
+    public static RetryRunnable from(Runnable runnable) {
         return ctx -> runnable.run();
     }
 }

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

@@ -92,7 +92,7 @@ static <R> Try<R> failure(Throwable error) {
         return new Failure<R>(error);
     }
 
-    static <R> BiFunction<R, Throwable, Try<R>> liftResult() {
+    static <R> BiFunction<R, Throwable, Try<R>> lift() {
         return (result, error) -> null == error ? Try.success(result) : Try.failure(error);
     }
 

src/main/java/net/tascalate/concurrent/core/Delegator.java renamed to src/main/java/net/tascalate/concurrent/core/Decorator.java

@@ -17,6 +17,6 @@
 
 import java.util.concurrent.CompletionStage;
 
-public interface Delegator<T> {
+public interface Decorator<T> {
     CompletionStage<T> α();
 }

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

@@ -23,11 +23,11 @@
 import java.util.function.Function;
 
 import net.tascalate.concurrent.Promise;
-import net.tascalate.concurrent.core.Delegator;
+import net.tascalate.concurrent.core.Decorator;
 
 public abstract class AbstractPromiseLikeDecorator<T, D extends CompletionStage<T>>
     extends AbstractCompletionStageDecorator<T, D>
-    implements CompletionStage<T>, Delegator<T> {
+    implements CompletionStage<T>, Decorator<T> {
 
     protected AbstractPromiseLikeDecorator(D delegate) {
         super(delegate);
@@ -276,25 +276,25 @@ public <U> Promise<U> handleAsync(BiFunction<? super T, Throwable, ? extends U>
     @Override
     public CompletionStage<T> α() {
         CompletionStage<T> p = delegate;
-        if (p instanceof Delegator) {
-            return delegator(p).α();
+        if (p instanceof Decorator) {
+            return decorator(p).α();
         } else {
             // Default path -- unroll
             while (p instanceof AbstractCompletionStageDecorator) {
                 @SuppressWarnings("unchecked")
                 AbstractCompletionStageDecorator<T, ? extends CompletionStage<T>> ap = 
                     (AbstractCompletionStageDecorator<T, ? extends CompletionStage<T>>)p;
                 p = ap.delegate;
-                if (p instanceof Delegator) {
-                    return delegator(p).α();
+                if (p instanceof Decorator) {
+                    return decorator(p).α();
                 }
             }
             return p;
         }
     }
 
     @SuppressWarnings("unchecked")
-    private static <T> Delegator<T> delegator(CompletionStage<T> delegate) {
-        return (Delegator<T>)delegate;
+    private static <T> Decorator<T> decorator(CompletionStage<T> delegate) {
+        return (Decorator<T>)delegate;
     }
 }