Widening argument types of Promises.all/any/anyStrict/atLeast/atLeastStrict

Author: vsilaev

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

@@ -39,10 +39,10 @@ class AggregatingPromise<T> extends CompletableFutureWrapper<List<T>> {
     final private int minResultsCount;
     final private int maxErrorsCount;
     final private boolean cancelRemaining;
-    final private List<CompletionStage<? extends T>> promises;
+    final private List<? extends CompletionStage<? extends T>> promises;
 
     AggregatingPromise(final int minResultsCount, final int maxErrorsCount, final boolean cancelRemaining,
-                       final List<CompletionStage<? extends T>> promises) {
+                       final List<? extends CompletionStage<? extends T>> promises) {
 
         if (null == promises || promises.isEmpty()) {
             throw new IllegalArgumentException("There are should be at least one promise specified");

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

@@ -125,7 +125,7 @@ public static <T> Promise<List<T>> all(CompletionStage<? extends T>... promises)
     }
 
 
-    public static <T> Promise<List<T>> all(List<CompletionStage<? extends T>> promises) {
+    public static <T> Promise<List<T>> all(List<? extends CompletionStage<? extends T>> promises) {
         return all(true, promises);        
     }
     /**
@@ -149,7 +149,7 @@ public static <T> Promise<List<T>> all(boolean cancelRemaining, CompletionStage<
         return all(cancelRemaining, Arrays.asList(promises));
     }
 
-    public static <T> Promise<List<T>> all(boolean cancelRemaining, List<CompletionStage<? extends T>> promises) {
+    public static <T> Promise<List<T>> all(boolean cancelRemaining, List<? extends CompletionStage<? extends T>> promises) {
         return atLeast(null != promises ? promises.size() : 0, 0, cancelRemaining, promises);
     }
     /**
@@ -171,7 +171,7 @@ public static <T> Promise<T> any(CompletionStage<? extends T>... promises) {
         return any(Arrays.asList(promises));
     }
 
-    public static <T> Promise<T> any(List<CompletionStage<? extends T>> promises) {
+    public static <T> Promise<T> any(List<? extends CompletionStage<? extends T>> promises) {
         return any(true, promises);
     }
     /**
@@ -196,7 +196,7 @@ public static <T> Promise<T> any(boolean cancelRemaining, CompletionStage<? exte
         return any(cancelRemaining, Arrays.asList(promises));
     }
 
-    public static <T> Promise<T> any(boolean cancelRemaining, List<CompletionStage<? extends T>> promises) {
+    public static <T> Promise<T> any(boolean cancelRemaining, List<? extends CompletionStage<? extends T>> promises) {
         int size = null == promises ? 0 : promises.size();
         switch (size) {
             case 0:
@@ -234,7 +234,7 @@ public static <T> Promise<T> anyStrict(CompletionStage<? extends T>... promises)
         return anyStrict(Arrays.asList(promises)); 
     }
 
-    public static <T> Promise<T> anyStrict(List<CompletionStage<? extends T>> promises) {
+    public static <T> Promise<T> anyStrict(List<? extends CompletionStage<? extends T>> promises) {
         return anyStrict(true, promises);        
     }
 
@@ -262,7 +262,7 @@ public static <T> Promise<T> anyStrict(boolean cancelRemaining, CompletionStage<
         return anyStrict(cancelRemaining, Arrays.asList(promises));
     }
 
-    public static <T> Promise<T> anyStrict(boolean cancelRemaining, List<CompletionStage<? extends T>> promises) {
+    public static <T> Promise<T> anyStrict(boolean cancelRemaining, List<? extends CompletionStage<? extends T>> promises) {
         int size = null == promises ? 0 : promises.size();
         switch (size) {
             case 0:
@@ -302,7 +302,7 @@ public static <T> Promise<List<T>> atLeast(int minResultsCount, CompletionStage<
         return atLeast(minResultsCount, Arrays.asList(promises));
     }
 
-    public static <T> Promise<List<T>> atLeast(int minResultsCount, List<CompletionStage<? extends T>> promises) {
+    public static <T> Promise<List<T>> atLeast(int minResultsCount, List<? extends CompletionStage<? extends T>> promises) {
         return atLeast(minResultsCount, true, promises);
     }
 
@@ -332,7 +332,7 @@ public static <T> Promise<List<T>> atLeast(int minResultsCount, boolean cancelRe
         return atLeast(minResultsCount, cancelRemaining, Arrays.asList(promises));
     }
 
-    public static <T> Promise<List<T>> atLeast(int minResultsCount, boolean cancelRemaining, List<CompletionStage<? extends T>> promises) {
+    public static <T> Promise<List<T>> atLeast(int minResultsCount, boolean cancelRemaining, List<? extends CompletionStage<? extends T>> promises) {
         return atLeast(minResultsCount, (promises == null ? 0 : promises.size()) - minResultsCount, cancelRemaining, promises);
     }
 
@@ -360,7 +360,7 @@ public static <T> Promise<List<T>> atLeastStrict(int minResultsCount, Completion
         return atLeastStrict(minResultsCount, Arrays.asList(promises));
     }
 
-    public static <T> Promise<List<T>> atLeastStrict(int minResultsCount, List<CompletionStage<? extends T>> promises) {
+    public static <T> Promise<List<T>> atLeastStrict(int minResultsCount, List<? extends CompletionStage<? extends T>> promises) {
         return atLeastStrict(minResultsCount, true, promises);
     }
 
@@ -391,7 +391,7 @@ public static <T> Promise<List<T>> atLeastStrict(int minResultsCount, boolean ca
         return atLeast(minResultsCount, cancelRemaining, Arrays.asList(promises));
     }    
 
-    public static <T> Promise<List<T>> atLeastStrict(int minResultsCount, boolean cancelRemaining, List<CompletionStage<? extends T>> promises) {
+    public static <T> Promise<List<T>> atLeastStrict(int minResultsCount, boolean cancelRemaining, List<? extends CompletionStage<? extends T>> promises) {
         return atLeast(minResultsCount, 0, cancelRemaining, promises);
     }
 
@@ -428,7 +428,7 @@ public static <T> Promise<List<T>> atLeast(int minResultsCount, int maxErrorsCou
     }
 
     public static <T> Promise<List<T>> atLeast(int minResultsCount, int maxErrorsCount, boolean cancelRemaining, 
-                                               List<CompletionStage<? extends T>> promises) {
+                                               List<? extends CompletionStage<? extends T>> promises) {
 
         int size = null == promises ? 0 : promises.size();
         if (minResultsCount > size) {
@@ -440,7 +440,8 @@ public static <T> Promise<List<T>> atLeast(int minResultsCount, int maxErrorsCou
         } else if (minResultsCount == 0) {
             return success(Collections.emptyList());
         } else if (size == 1) {
-            return transform(promises.get(0), Collections::singletonList, Promises::wrapMultitargetException);
+            CompletionStage<? extends T> stage = promises.get(0);
+            return transform(stage, Collections::singletonList, Promises::wrapMultitargetException);
         } else {
             return new AggregatingPromise<>(minResultsCount, maxErrorsCount, cancelRemaining, promises);
         }

src/test/java/net/tascalate/concurrent/PromisesTests.java

@@ -0,0 +1,38 @@
+package net.tascalate.concurrent;
+
+import static org.junit.Assert.assertTrue;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class PromisesTests {
+
+    @Before
+    public void setUp() {
+    }
+    
+    @After
+    public void tearDown() {
+    }
+    
+    @Test
+    public void testGenericArgs() {
+        Promise<List<Number>> p = ttt(BigDecimal.valueOf(10), Long.valueOf(11));
+        List<Number> v = p.join();
+        assertTrue("Fisrt is BigDecimal ", v.get(0) instanceof BigDecimal);
+        assertTrue("Second is Long ", v.get(1) instanceof Long);
+    }
+    
+    <T, U extends T, V extends T> Promise<List<T>> ttt(U a, V b) {
+        List<Promise<T>> promises = new ArrayList<>();
+        promises.add(Promises.success(a));
+        promises.add(Promises.success(b));
+        Promise<List<T>> all = Promises.all(promises);
+        return all;
+    }
+}