ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/jsr166e/CompletableFuture.java
(Generate patch)

Comparing jsr166/src/jsr166e/CompletableFuture.java (file contents):
Revision 1.7 by jsr166, Fri Jan 18 04:23:27 2013 UTC vs.
Revision 1.14 by jsr166, Sat Feb 16 20:50:29 2013 UTC

# Line 1319 | Line 1319 | public class CompletableFuture<T> implem
1319          Object r; Throwable ex, cause;
1320          if ((r = result) == null && (r = waitingGet(true)) == null)
1321              throw new InterruptedException();
1322 <        if (r instanceof AltResult) {
1323 <            if ((ex = ((AltResult)r).ex) != null) {
1324 <                if (ex instanceof CancellationException)
1325 <                    throw (CancellationException)ex;
1326 <                if ((ex instanceof CompletionException) &&
1327 <                    (cause = ex.getCause()) != null)
1328 <                    ex = cause;
1329 <                throw new ExecutionException(ex);
1330 <            }
1331 <            return null;
1322 >        if (!(r instanceof AltResult)) {
1323 >            @SuppressWarnings("unchecked") T tr = (T) r;
1324 >            return tr;
1325          }
1326 <        @SuppressWarnings("unchecked") T tr = (T) r;
1327 <        return tr;
1326 >        if ((ex = ((AltResult)r).ex) == null)
1327 >            return null;
1328 >        if (ex instanceof CancellationException)
1329 >            throw (CancellationException)ex;
1330 >        if ((ex instanceof CompletionException) &&
1331 >            (cause = ex.getCause()) != null)
1332 >            ex = cause;
1333 >        throw new ExecutionException(ex);
1334      }
1335  
1336      /**
# Line 1356 | Line 1355 | public class CompletableFuture<T> implem
1355              throw new InterruptedException();
1356          if ((r = result) == null)
1357              r = timedAwaitDone(nanos);
1358 <        if (r instanceof AltResult) {
1359 <            if ((ex = ((AltResult)r).ex) != null) {
1360 <                if (ex instanceof CancellationException)
1362 <                    throw (CancellationException)ex;
1363 <                if ((ex instanceof CompletionException) &&
1364 <                    (cause = ex.getCause()) != null)
1365 <                    ex = cause;
1366 <                throw new ExecutionException(ex);
1367 <            }
1368 <            return null;
1358 >        if (!(r instanceof AltResult)) {
1359 >            @SuppressWarnings("unchecked") T tr = (T) r;
1360 >            return tr;
1361          }
1362 <        @SuppressWarnings("unchecked") T tr = (T) r;
1363 <        return tr;
1362 >        if ((ex = ((AltResult)r).ex) == null)
1363 >            return null;
1364 >        if (ex instanceof CancellationException)
1365 >            throw (CancellationException)ex;
1366 >        if ((ex instanceof CompletionException) &&
1367 >            (cause = ex.getCause()) != null)
1368 >            ex = cause;
1369 >        throw new ExecutionException(ex);
1370      }
1371  
1372      /**
# Line 1389 | Line 1387 | public class CompletableFuture<T> implem
1387          Object r; Throwable ex;
1388          if ((r = result) == null)
1389              r = waitingGet(false);
1390 <        if (r instanceof AltResult) {
1391 <            if ((ex = ((AltResult)r).ex) != null) {
1392 <                if (ex instanceof CancellationException)
1395 <                    throw (CancellationException)ex;
1396 <                if (ex instanceof CompletionException)
1397 <                    throw (CompletionException)ex;
1398 <                throw new CompletionException(ex);
1399 <            }
1400 <            return null;
1390 >        if (!(r instanceof AltResult)) {
1391 >            @SuppressWarnings("unchecked") T tr = (T) r;
1392 >            return tr;
1393          }
1394 <        @SuppressWarnings("unchecked") T tr = (T) r;
1395 <        return tr;
1394 >        if ((ex = ((AltResult)r).ex) == null)
1395 >            return null;
1396 >        if (ex instanceof CancellationException)
1397 >            throw (CancellationException)ex;
1398 >        if (ex instanceof CompletionException)
1399 >            throw (CompletionException)ex;
1400 >        throw new CompletionException(ex);
1401      }
1402  
1403      /**
# Line 1417 | Line 1414 | public class CompletableFuture<T> implem
1414          Object r; Throwable ex;
1415          if ((r = result) == null)
1416              return valueIfAbsent;
1417 <        if (r instanceof AltResult) {
1418 <            if ((ex = ((AltResult)r).ex) != null) {
1419 <                if (ex instanceof CancellationException)
1423 <                    throw (CancellationException)ex;
1424 <                if (ex instanceof CompletionException)
1425 <                    throw (CompletionException)ex;
1426 <                throw new CompletionException(ex);
1427 <            }
1428 <            return null;
1417 >        if (!(r instanceof AltResult)) {
1418 >            @SuppressWarnings("unchecked") T tr = (T) r;
1419 >            return tr;
1420          }
1421 <        @SuppressWarnings("unchecked") T tr = (T) r;
1422 <        return tr;
1421 >        if ((ex = ((AltResult)r).ex) == null)
1422 >            return null;
1423 >        if (ex instanceof CancellationException)
1424 >            throw (CancellationException)ex;
1425 >        if (ex instanceof CompletionException)
1426 >            throw (CompletionException)ex;
1427 >        throw new CompletionException(ex);
1428      }
1429  
1430      /**
# Line 1792 | Line 1788 | public class CompletableFuture<T> implem
1788       * @param executor the executor to use for asynchronous execution
1789       * @return the new CompletableFuture
1790       */
1795
1791      public <U,V> CompletableFuture<V> thenCombineAsync(CompletableFuture<? extends U> other,
1792                                                         BiFun<? super T,? super U,? extends V> fn,
1793                                                         Executor executor) {
# Line 2449 | Line 2444 | public class CompletableFuture<T> implem
2444       * then the returned CompletableFuture also does so, with a
2445       * CompletionException holding this exception as its cause.
2446       *
2447 <     * @param fn the function returning a new CompletableFuture.
2447 >     * @param fn the function returning a new CompletableFuture
2448       * @return the CompletableFuture, that {@code isDone()} upon
2449       * return if completed by the given function, or an exception
2450 <     * occurs.
2450 >     * occurs
2451       */
2452      public <U> CompletableFuture<U> thenCompose(Fun<? super T,
2453                                                  CompletableFuture<U>> fn) {
# Line 2559 | Line 2554 | public class CompletableFuture<T> implem
2554       *
2555       * @param fn the function to use to compute the value of the
2556       * returned CompletableFuture
2562
2557       * @return the new CompletableFuture
2558       */
2559      public <U> CompletableFuture<U> handle(BiFun<? super T, Throwable, ? extends U> fn) {
# Line 2633 | Line 2627 | public class CompletableFuture<T> implem
2627       */
2628      public boolean isCancelled() {
2629          Object r;
2630 <        return ((r = result) != null &&
2631 <                (r instanceof AltResult) &&
2638 <                (((AltResult)r).ex instanceof CancellationException));
2630 >        return ((r = result) instanceof AltResult) &&
2631 >            (((AltResult)r).ex instanceof CancellationException);
2632      }
2633  
2634      /**
2635       * Forcibly sets or resets the value subsequently returned by
2636 <     * method get() and related methods, whether or not already
2637 <     * completed. This method is designed for use only in error
2638 <     * recovery actions, and even in such situations may result in
2639 <     * ongoing dependent completions using established versus
2636 >     * method {@link #get()} and related methods, whether or not
2637 >     * already completed. This method is designed for use only in
2638 >     * error recovery actions, and even in such situations may result
2639 >     * in ongoing dependent completions using established versus
2640       * overwritten outcomes.
2641       *
2642       * @param value the completion value
# Line 2654 | Line 2647 | public class CompletableFuture<T> implem
2647      }
2648  
2649      /**
2650 <     * Forcibly causes subsequent invocations of method get() and
2651 <     * related methods to throw the given exception, whether or not
2652 <     * already completed. This method is designed for use only in
2650 >     * Forcibly causes subsequent invocations of method {@link #get()}
2651 >     * and related methods to throw the given exception, whether or
2652 >     * not already completed. This method is designed for use only in
2653       * recovery actions, and even in such situations may result in
2654       * ongoing dependent completions using established versus
2655       * overwritten outcomes.

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines