T get(CompletionStage stage) {
43 | final Object value = map.get(stage);
44 | if (value == null) {
45 | throw new IllegalArgumentException(
46 | "Can not resolve values for futures that were not part of the combine");
47 | }
48 | if (value == NULL_PLACEHOLDER) {
49 | return null;
50 | }
51 | return (T) value;
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/main/java/com/spotify/futures/CompletableFutures.java:
--------------------------------------------------------------------------------
1 | /*-
2 | * -\-\-
3 | * completable-futures
4 | * --
5 | * Copyright (C) 2016 - 2020 Spotify AB
6 | * --
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * you may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS,
15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | * -/-/-
19 | */
20 | package com.spotify.futures;
21 |
22 | import static java.util.stream.Collectors.collectingAndThen;
23 | import static java.util.stream.Collectors.toList;
24 | import static java.util.stream.Collectors.toMap;
25 |
26 | import java.time.Duration;
27 | import java.util.ArrayList;
28 | import java.util.Arrays;
29 | import java.util.HashMap;
30 | import java.util.List;
31 | import java.util.Map;
32 | import java.util.Optional;
33 | import java.util.concurrent.CancellationException;
34 | import java.util.concurrent.CompletableFuture;
35 | import java.util.concurrent.CompletionException;
36 | import java.util.concurrent.CompletionStage;
37 | import java.util.concurrent.Executor;
38 | import java.util.concurrent.ScheduledExecutorService;
39 | import java.util.concurrent.ScheduledFuture;
40 | import java.util.concurrent.TimeUnit;
41 | import java.util.function.BiFunction;
42 | import java.util.function.Function;
43 | import java.util.function.Supplier;
44 | import java.util.stream.Collector;
45 |
46 | /**
47 | * A collection of static utility methods that extend the
48 | * {@link java.util.concurrent.CompletableFuture Java completable future} API.
49 | *
50 | * @since 0.1.0
51 | */
52 | public final class CompletableFutures {
53 |
54 | private CompletableFutures() {
55 | throw new IllegalAccessError("This class must not be instantiated.");
56 | }
57 |
58 | /**
59 | * Returns a new {@link CompletableFuture} which completes to a list of all values of its input
60 | * stages, if all succeed. The list of results is in the same order as the input stages.
61 | *
62 | * As soon as any of the given stages complete exceptionally, then the returned future also does so,
63 | * with a {@link CompletionException} holding this exception as its cause.
64 | *
65 | *
If no stages are provided, returns a future holding an empty list.
66 | *
67 | * @param stages the stages to combine
68 | * @param the common super-type of all of the input stages, that determines the monomorphic
69 | * type of the output future
70 | * @return a future that completes to a list of the results of the supplied stages
71 | * @throws NullPointerException if the stages list or any of its elements are {@code null}
72 | * @since 0.1.0
73 | */
74 | public static CompletableFuture> allAsList(
75 | List> stages) {
76 | // We use traditional for-loops instead of streams here for performance reasons,
77 | // see AllAsListBenchmark
78 |
79 | @SuppressWarnings("unchecked") // generic array creation
80 | final CompletableFuture[] all = new CompletableFuture[stages.size()];
81 | for (int i = 0; i < stages.size(); i++) {
82 | all[i] = stages.get(i).toCompletableFuture();
83 | }
84 |
85 | CompletableFuture allOf = CompletableFuture.allOf(all);
86 |
87 | for (int i = 0; i < all.length; i++) {
88 | all[i].exceptionally(throwable -> {
89 | if (!allOf.isDone()) {
90 | allOf.completeExceptionally(throwable);
91 | }
92 | return null; // intentionally unused
93 | });
94 | }
95 |
96 | return allOf
97 | .thenApply(ignored -> {
98 | final List result = new ArrayList<>(all.length);
99 | for (int i = 0; i < all.length; i++) {
100 | result.add(all[i].join());
101 | }
102 | return result;
103 | });
104 | }
105 |
106 | /**
107 | * Returns a new {@link CompletableFuture} which completes to a map of all values of its input
108 | * stages, if all succeed.
109 | *
110 | * If any of the given stages complete exceptionally, then the returned future also does so,
111 | * with a {@link CompletionException} holding this exception as its cause.
112 | *
113 | *
If no stages are provided, returns a future holding an empty map.
114 | *
115 | * @param map the map of stages to combine
116 | * @param the common super-type of the keys
117 | * @param the common super-type of all of the input value-stages, that determines the
118 | * monomorphic type of the output future
119 | * @return a future that completes to a map of the results of the supplied keys and value-stages
120 | * @throws NullPointerException if value-stages or any of its elements are {@code null}
121 | * @since 0.3.3
122 | */
123 | public static CompletableFuture> allAsMap(
124 | Map> map) {
125 |
126 | final List keys = new ArrayList<>(map.keySet());
127 | @SuppressWarnings("unchecked") // generic array creation
128 | final CompletableFuture[] values = new CompletableFuture[keys.size()];
129 | for (int i = 0; i < keys.size(); i++) {
130 | values[i] = map.get(keys.get(i)).toCompletableFuture();
131 | }
132 | return CompletableFuture.allOf(values)
133 | .thenApply(
134 | ignored -> {
135 | final Map result = new HashMap<>(values.length);
136 | for (int i = 0; i < values.length; i++) {
137 | result.put(keys.get(i), values[i].join());
138 | }
139 | return result;
140 | });
141 | }
142 |
143 | /**
144 | * Returns a new {@link CompletableFuture} which completes to a list of values of those input
145 | * stages that succeeded. The list of results is in the same order as the input stages. For failed
146 | * stages, the defaultValueMapper will be called, and the value returned from that function will
147 | * be put in the resulting list.
148 | *
149 | * If no stages are provided, returns a future holding an empty list.
150 | *
151 | * @param stages the stages to combine.
152 | * @param defaultValueMapper a function that will be called when a future completes exceptionally
153 | * to provide a default value to place in the resulting list
154 | * @param the common type of all of the input stages, that determines the type of the
155 | * output future
156 | * @return a future that completes to a list of the results of the supplied stages
157 | * @throws NullPointerException if the stages list or any of its elements are {@code null}
158 | */
159 | public static CompletableFuture> successfulAsList(
160 | List> stages,
161 | Function defaultValueMapper) {
162 | return stages.stream()
163 | .map(f -> f.exceptionally(defaultValueMapper))
164 | .collect(joinList());
165 | }
166 |
167 | /**
168 | * Returns a new {@code CompletableFuture} that is already exceptionally completed with
169 | * the given exception.
170 | *
171 | * @param throwable the exception
172 | * @param an arbitrary type for the returned future; can be anything since the future
173 | * will be exceptionally completed and thus there will never be a value of type
174 | * {@code T}
175 | * @return a future that exceptionally completed with the supplied exception
176 | * @throws NullPointerException if the supplied throwable is {@code null}
177 | * @since 0.1.0
178 | */
179 | public static CompletableFuture exceptionallyCompletedFuture(Throwable throwable) {
180 | final CompletableFuture future = new CompletableFuture<>();
181 | future.completeExceptionally(throwable);
182 | return future;
183 | }
184 |
185 | /**
186 | * Collect a stream of {@link CompletionStage}s into a single future holding a list of the
187 | * joined entities.
188 | *
189 | * Usage:
190 | *
191 | *
{@code
192 | * collection.stream()
193 | * .map(this::someAsyncFunc)
194 | * .collect(joinList())
195 | * .thenApply(this::consumeList)
196 | * }
197 | *
198 | * The generated {@link CompletableFuture} will complete to a list of all entities, in the
199 | * order they were encountered in the original stream. Similar to
200 | * {@link CompletableFuture#allOf(CompletableFuture[])}, if any of the input futures complete
201 | * exceptionally, then the returned CompletableFuture also does so, with a
202 | * {@link CompletionException} holding this exception as its cause.
203 | *
204 | * @param the common super-type of all of the input stages, that determines the monomorphic
205 | * type of the output future
206 | * @param the implementation of {@link CompletionStage} that the stream contains
207 | * @return a new {@link CompletableFuture} according to the rules outlined in the method
208 | * description
209 | * @throws NullPointerException if any future in the stream is {@code null}
210 | * @since 0.1.0
211 | */
212 | public static >
213 | Collector>> joinList() {
214 | return collectingAndThen(toList(), CompletableFutures::allAsList);
215 | }
216 |
217 | /**
218 | * Collect a stream of Objects into a single future holding a Map whose keys are the result of
219 | * applying the provided mapping function to the input elements, and whose values are the
220 | * corresponding joined entities.
221 | *
222 | * Usage:
223 | *
224 | *
{@code
225 | * collection.stream()
226 | * .collect(joinMap(this::toKey, this::someAsyncFunc))
227 | * .thenApply(this::consumeMap)
228 | * }
229 | *
230 | * The generated {@link CompletableFuture} will complete to a Map of all entities. Similar
231 | * to {@link CompletableFuture#allOf(CompletableFuture[])}, if any of the input futures
232 | * complete exceptionally, then the returned CompletableFuture also does so, with a
233 | * {@link CompletionException} holding this exception as its cause.
234 | *
235 | * @param keyMapper a mapping function to produce keys
236 | * @param valueFutureMapper a mapping function to produce futures that will eventually produce
237 | * the values
238 | * @param the type of the input elements
239 | * @param the output type of the key mapping function
240 | * @param the common super-type of the stages returned by the value future mapping function
241 | * @return a new {@link CompletableFuture} according to the rules outlined in the method
242 | * description
243 | * @throws NullPointerException if valueFutureMapper returns {@code null} for any input element
244 | * @since 0.3.4
245 | */
246 | public static Collector>> joinMap(
247 | Function keyMapper,
248 | Function> valueFutureMapper){
249 | Collector>> collector =
250 | toMap(keyMapper, valueFutureMapper);
251 | return collectingAndThen(collector, CompletableFutures::allAsMap);
252 | }
253 |
254 | /**
255 | * Checks that a stage is completed.
256 | *
257 | * @param stage the {@link CompletionStage} to check
258 | * @throws IllegalStateException if the stage is not completed
259 | * @since 0.1.0
260 | */
261 | public static void checkCompleted(CompletionStage stage) {
262 | if (!stage.toCompletableFuture().isDone()) {
263 | throw new IllegalStateException("future was not completed");
264 | }
265 | }
266 |
267 | /**
268 | * Gets the value of a completed stage.
269 | *
270 | * @param stage a completed {@link CompletionStage}
271 | * @param the type of the value that the stage completes into
272 | * @return the value of the stage if it has one
273 | * @throws IllegalStateException if the stage is not completed
274 | * @since 0.1.0
275 | */
276 | public static T getCompleted(CompletionStage stage) {
277 | CompletableFuture future = stage.toCompletableFuture();
278 | checkCompleted(future);
279 | return future.join();
280 | }
281 |
282 | /**
283 | * Gets the exception from an exceptionally completed future
284 | * @param stage an exceptionally completed {@link CompletionStage}
285 | * @param the type of the value that the stage completes into
286 | * @return the exception the stage has completed with
287 | * @throws IllegalStateException if the stage is not completed exceptionally
288 | * @throws CancellationException if the stage was cancelled
289 | * @throws UnsupportedOperationException if the {@link CompletionStage} does not
290 | * support the {@link CompletionStage#toCompletableFuture()} operation
291 | */
292 | public static Throwable getException(CompletionStage stage) {
293 | CompletableFuture future = stage.toCompletableFuture();
294 | if (!future.isCompletedExceptionally()) {
295 | throw new IllegalStateException("future was not completed exceptionally");
296 | }
297 | try {
298 | future.join();
299 | return null;
300 | } catch (CompletionException x) {
301 | return x.getCause();
302 | }
303 | }
304 |
305 | /**
306 | * Returns a new stage that, when this stage completes either normally or exceptionally, is
307 | * executed with this stage's result and exception as arguments to the supplied function.
308 | *
309 | * When this stage is complete, the given function is invoked with the result (or {@code null}
310 | * if none) and the exception (or {@code null} if none) of this stage as arguments, and the
311 | * function's result is used to complete the returned stage.
312 | *
313 | *
This differs from
314 | * {@link java.util.concurrent.CompletionStage#handle(java.util.function.BiFunction)} in that the
315 | * function should return a {@link java.util.concurrent.CompletionStage} rather than the value
316 | * directly.
317 | *
318 | * @param stage the {@link CompletionStage} to compose
319 | * @param fn the function to use to compute the value of the
320 | * returned {@link CompletionStage}
321 | * @param the type of the input stage's value.
322 | * @param the function's return type
323 | * @return the new {@link CompletionStage}
324 | * @since 0.1.0
325 | */
326 | public static CompletionStage handleCompose(
327 | CompletionStage stage,
328 | BiFunction> fn) {
329 | return dereference(stage.handle(fn));
330 | }
331 |
332 | /**
333 | * Returns a new stage that, when this stage completes
334 | * exceptionally, is executed with this stage's exception as the
335 | * argument to the supplied function. Otherwise, if this stage
336 | * completes normally, then the returned stage also completes
337 | * normally with the same value.
338 | *
339 | * This differs from
340 | * {@link java.util.concurrent.CompletionStage#exceptionally(java.util.function.Function)}
341 | * in that the function should return a {@link java.util.concurrent.CompletionStage} rather than
342 | * the value directly.
343 | *
344 | * @param stage the {@link CompletionStage} to compose
345 | * @param fn the function to use to compute the value of the
346 | * returned {@link CompletionStage} if this stage completed
347 | * exceptionally
348 | * @param the type of the input stage's value.
349 | * @return the new {@link CompletionStage}
350 | * @since 0.1.0
351 | */
352 | public static CompletionStage exceptionallyCompose(
353 | CompletionStage stage,
354 | Function> fn) {
355 | return dereference(wrap(stage).exceptionally(fn));
356 | }
357 |
358 | /**
359 | * This allows for a stage to be the return type of supplier when using supplyAsync and returns a plain stage.
360 | *
361 | * This differs from {@link
362 | * java.util.concurrent.CompletableFuture#supplyAsync(Supplier)} in that the
363 | * function should return a {@link java.util.concurrent.CompletionStage} rather than the {@link CompletionStage} of
364 | * a {@link CompletionStage} of a value when the return value of the {@link Supplier} is a {@link CompletionStage}.
365 | *
366 | * @param supplier a {@link Supplier} with a return value of {@link CompletionStage}
367 | * @param the type of the supplied stage's value
368 | * @return the new {@link CompletionStage}
369 | * @since 0.3.6
370 | */
371 | public static CompletionStage supplyAsyncCompose(Supplier> supplier) {
372 | return dereference(CompletableFuture.supplyAsync(supplier));
373 | }
374 |
375 | /**
376 | * This allows for a stage to be the return type of supplier when using supplyAsync and returns a plain stage.
377 | *
378 | * This differs from {@link
379 | * java.util.concurrent.CompletableFuture#supplyAsync(Supplier, Executor)} in that the
380 | * function should return a {@link java.util.concurrent.CompletionStage} rather than the {@link CompletionStage} of
381 | * a {@link CompletionStage} of a value when the return value of the {@link Supplier} is a {@link CompletionStage}.
382 | *
383 | * @param supplier a {@link Supplier} with a return value of {@link CompletionStage}
384 | * @param executor a {@link Executor} the executor to use for asynchronous execution
385 | * @param the type of the supplied stage's value
386 | * @return the new {@link CompletionStage}
387 | * @since 0.3.6
388 | */
389 | public static CompletionStage supplyAsyncCompose(
390 | Supplier> supplier, Executor executor) {
391 | return dereference(CompletableFuture.supplyAsync(supplier, executor));
392 | }
393 |
394 | /**
395 | * This takes a stage of a stage of a value and returns a plain stage of a value.
396 | *
397 | * @param stage a {@link CompletionStage} of a {@link CompletionStage} of a value
398 | * @param the type of the inner stage's value.
399 | * @return the {@link CompletionStage} of the value
400 | * @since 0.1.0
401 | */
402 | public static CompletionStage dereference(
403 | CompletionStage> stage) {
404 | return stage.thenCompose(Function.identity());
405 | }
406 |
407 | private static CompletionStage> wrap(CompletionStage future) {
408 | //noinspection unchecked
409 | return future.thenApply(CompletableFuture::completedFuture);
410 | }
411 |
412 | /**
413 | * Combines multiple stages by applying a function.
414 | *
415 | * @param a the first stage.
416 | * @param b the second stage.
417 | * @param function the combining function.
418 | * @param the type of the combining function's return value.
419 | * @param the type of the first stage's value.
420 | * @param the type of the second stage's value.
421 | * @return a stage that completes into the return value of the supplied function.
422 | * @since 0.1.0
423 | */
424 | public static CompletionStage combine(
425 | CompletionStage a, CompletionStage b,
426 | BiFunction function) {
427 | return a.thenCombine(b, function);
428 | }
429 |
430 | /**
431 | * Combines multiple stages by applying a function.
432 | *
433 | * @param a the first stage.
434 | * @param b the second stage.
435 | * @param c the third stage.
436 | * @param function the combining function.
437 | * @param the type of the combining function's return value.
438 | * @param the type of the first stage's value.
439 | * @param the type of the second stage's value.
440 | * @param the type of the third stage's value.
441 | * @return a stage that completes into the return value of the supplied function.
442 | * @since 0.1.0
443 | */
444 | public static CompletionStage combine(
445 | CompletionStage a, CompletionStage b, CompletionStage c,
446 | Function3 function) {
447 | final CompletableFuture af = a.toCompletableFuture();
448 | final CompletableFuture bf = b.toCompletableFuture();
449 | final CompletableFuture cf = c.toCompletableFuture();
450 |
451 | return CompletableFuture.allOf(af, bf, cf)
452 | .thenApply(ignored -> function.apply(af.join(), bf.join(), cf.join()));
453 | }
454 |
455 | /**
456 | * Combines multiple stages by applying a function.
457 | *
458 | * @param a the first stage.
459 | * @param b the second stage.
460 | * @param c the third stage.
461 | * @param d the fourth stage.
462 | * @param function the combining function.
463 | * @param the type of the combining function's return value.
464 | * @param the type of the first stage's value.
465 | * @param the type of the second stage's value.
466 | * @param the type of the third stage's value.
467 | * @param the type of the fourth stage's value.
468 | * @return a stage that completes into the return value of the supplied function.
469 | * @since 0.1.0
470 | */
471 | public static CompletionStage combine(
472 | CompletionStage a, CompletionStage b, CompletionStage c, CompletionStage d,
473 | Function4 function) {
474 | final CompletableFuture af = a.toCompletableFuture();
475 | final CompletableFuture bf = b.toCompletableFuture();
476 | final CompletableFuture cf = c.toCompletableFuture();
477 | final CompletableFuture df = d.toCompletableFuture();
478 |
479 | return CompletableFuture.allOf(af, bf, cf, df)
480 | .thenApply(ignored -> function.apply(af.join(), bf.join(), cf.join(), df.join()));
481 | }
482 |
483 | /**
484 | * Combines multiple stages by applying a function.
485 | *
486 | * @param a the first stage.
487 | * @param b the second stage.
488 | * @param c the third stage.
489 | * @param d the fourth stage.
490 | * @param e the fifth stage.
491 | * @param function the combining function.
492 | * @param the type of the combining function's return value.
493 | * @param the type of the first stage's value.
494 | * @param the type of the second stage's value.
495 | * @param the type of the third stage's value.
496 | * @param the type of the fourth stage's value.
497 | * @param the type of the fifth stage's value.
498 | * @return a stage that completes into the return value of the supplied function.
499 | * @since 0.1.0
500 | */
501 | public static CompletionStage combine(
502 | CompletionStage a, CompletionStage b, CompletionStage c,
503 | CompletionStage d, CompletionStage e,
504 | Function5 function) {
505 | final CompletableFuture af = a.toCompletableFuture();
506 | final CompletableFuture bf = b.toCompletableFuture();
507 | final CompletableFuture cf = c.toCompletableFuture();
508 | final CompletableFuture df = d.toCompletableFuture();
509 | final CompletableFuture ef = e.toCompletableFuture();
510 |
511 | return CompletableFuture.allOf(af, bf, cf, df, ef)
512 | .thenApply(ignored ->
513 | function.apply(af.join(), bf.join(), cf.join(), df.join(), ef.join()));
514 | }
515 |
516 | /**
517 | * Combines multiple stages by applying a function.
518 | *
519 | * @param a the first stage.
520 | * @param b the second stage.
521 | * @param c the third stage.
522 | * @param d the fourth stage.
523 | * @param e the fifth stage.
524 | * @param f the sixth stage.
525 | * @param function the combining function.
526 | * @param the type of the combining function's return value.
527 | * @param the type of the first stage's value.
528 | * @param the type of the second stage's value.
529 | * @param the type of the third stage's value.
530 | * @param the type of the fourth stage's value.
531 | * @param the type of the fifth stage's value.
532 | * @param the type of the sixth stage's value.
533 | * @return a stage that completes into the return value of the supplied function.
534 | * @since 0.3.2
535 | */
536 | public static CompletionStage combine(
537 | CompletionStage a, CompletionStage b, CompletionStage c,
538 | CompletionStage d, CompletionStage e, CompletionStage f,
539 | Function6 function) {
540 | final CompletableFuture af = a.toCompletableFuture();
541 | final CompletableFuture bf = b.toCompletableFuture();
542 | final CompletableFuture cf = c.toCompletableFuture();
543 | final CompletableFuture df = d.toCompletableFuture();
544 | final CompletableFuture ef = e.toCompletableFuture();
545 | final CompletableFuture ff = f.toCompletableFuture();
546 |
547 | return CompletableFuture.allOf(af, bf, cf, df, ef, ff)
548 | .thenApply(ignored ->
549 | function.apply(af.join(),
550 | bf.join(),
551 | cf.join(),
552 | df.join(),
553 | ef.join(),
554 | ff.join()));
555 | }
556 |
557 | /**
558 | * Combines multiple stages by applying a function.
559 | *
560 | * @param function the combining function.
561 | * @param stages the stages to combine
562 | * @param the type of the combining function's return value.
563 | * @return a stage that completes into the return value of the supplied function.
564 | * @since 0.4.0
565 | */
566 | public static CompletionStage combine(
567 | Function function, CompletionStage... stages) {
568 | return combine(function, Arrays.asList(stages));
569 | }
570 |
571 | /**
572 | * Combines multiple stages by applying a function.
573 | *
574 | * @param function the combining function.
575 | * @param stages the stages to combine
576 | * @param the type of the combining function's return value.
577 | * @return a stage that completes into the return value of the supplied function.
578 | * @since 0.4.0
579 | */
580 | public static CompletionStage combine(
581 | Function function, List> stages) {
582 | @SuppressWarnings("unchecked") // generic array creation
583 | final CompletableFuture[] all = new CompletableFuture[stages.size()];
584 | for (int i = 0; i < stages.size(); i++) {
585 | all[i] = stages.get(i).toCompletableFuture();
586 | }
587 | return CompletableFuture.allOf(all).thenApply(ignored -> function.apply(new CombinedFutures(stages)));
588 | }
589 |
590 | /**
591 | * Composes multiple stages into another stage using a function.
592 | *
593 | * @param a the first stage.
594 | * @param b the second stage.
595 | * @param function the combining function.
596 | * @param the type of the composed {@link CompletionStage}.
597 | * @param the type of the first stage's value.
598 | * @param the type of the second stage's value.
599 | * @return a stage that is composed from the input stages using the function.
600 | * @throws UnsupportedOperationException if any of the {@link CompletionStage}s
601 | * do not interoperate with CompletableFuture
602 | */
603 | public static CompletionStage combineFutures(
604 | CompletionStage a,
605 | CompletionStage b,
606 | BiFunction> function) {
607 | final CompletableFuture af = a.toCompletableFuture();
608 | final CompletableFuture bf = b.toCompletableFuture();
609 |
610 | return CompletableFuture.allOf(af, bf)
611 | .thenCompose(ignored -> function.apply(af.join(), bf.join()));
612 | }
613 |
614 | /**
615 | * Composes multiple stages into another stage using a function.
616 | *
617 | * @param a the first stage.
618 | * @param b the second stage.
619 | * @param c the third stage.
620 | * @param function the combining function.
621 | * @param the type of the composed {@link CompletionStage}.
622 | * @param the type of the first stage's value.
623 | * @param the type of the second stage's value.
624 | * @param the type of the third stage's value.
625 | * @return a stage that is composed from the input stages using the function.
626 | * @throws UnsupportedOperationException if any of the {@link CompletionStage}s
627 | * do not interoperate with CompletableFuture
628 | */
629 | public static CompletionStage combineFutures(
630 | CompletionStage a,
631 | CompletionStage b,
632 | CompletionStage c,
633 | Function3> function) {
634 | final CompletableFuture af = a.toCompletableFuture();
635 | final CompletableFuture bf = b.toCompletableFuture();
636 | final CompletableFuture cf = c.toCompletableFuture();
637 |
638 | return CompletableFuture.allOf(af, bf, cf)
639 | .thenCompose(ignored -> function.apply(af.join(),
640 | bf.join(),
641 | cf.join()));
642 | }
643 |
644 | /**
645 | * Composes multiple stages into another stage using a function.
646 | *
647 | * @param a the first stage.
648 | * @param b the second stage.
649 | * @param c the third stage.
650 | * @param d the fourth stage.
651 | * @param function the combining function.
652 | * @param the type of the composed {@link CompletionStage}.
653 | * @param the type of the first stage's value.
654 | * @param the type of the second stage's value.
655 | * @param the type of the third stage's value.
656 | * @param the type of the fourth stage's value.
657 | * @return a stage that is composed from the input stages using the function.
658 | * @throws UnsupportedOperationException if any of the {@link CompletionStage}s
659 | * do not interoperate with CompletableFuture
660 | */
661 | public static CompletionStage combineFutures(
662 | CompletionStage a,
663 | CompletionStage b,
664 | CompletionStage c,
665 | CompletionStage d,
666 | Function4> function) {
667 | final CompletableFuture af = a.toCompletableFuture();
668 | final CompletableFuture bf = b.toCompletableFuture();
669 | final CompletableFuture cf = c.toCompletableFuture();
670 | final CompletableFuture df = d.toCompletableFuture();
671 |
672 | return CompletableFuture.allOf(af, bf, cf, df)
673 | .thenCompose(ignored -> function.apply(af.join(), bf.join(), cf.join(), df.join()));
674 | }
675 |
676 | /**
677 | * Composes multiple stages into another stage using a function.
678 | *
679 | * @param a the first stage.
680 | * @param b the second stage.
681 | * @param c the third stage.
682 | * @param d the fourth stage.
683 | * @param e the fifth stage.
684 | * @param function the combining function.
685 | * @param the type of the composed {@link CompletionStage}.
686 | * @param the type of the first stage's value.
687 | * @param the type of the second stage's value.
688 | * @param the type of the third stage's value.
689 | * @param the type of the fourth stage's value.
690 | * @param the type of the fifth stage's value.
691 | * @return a stage that is composed from the input stages using the function.
692 | * @throws UnsupportedOperationException if any of the {@link CompletionStage}s
693 | * do not interoperate with CompletableFuture
694 | */
695 | public static CompletionStage combineFutures(
696 | CompletionStage a,
697 | CompletionStage b,
698 | CompletionStage c,
699 | CompletionStage d,
700 | CompletionStage e,
701 | Function5> function) {
702 | final CompletableFuture af = a.toCompletableFuture();
703 | final CompletableFuture bf = b.toCompletableFuture();
704 | final CompletableFuture cf = c.toCompletableFuture();
705 | final CompletableFuture df = d.toCompletableFuture();
706 | final CompletableFuture ef = e.toCompletableFuture();
707 |
708 | return CompletableFuture.allOf(af, bf, cf, df, ef)
709 | .thenCompose(ignored -> function.apply(af.join(),
710 | bf.join(),
711 | cf.join(),
712 | df.join(),
713 | ef.join()));
714 | }
715 |
716 | /**
717 | * Composes multiple stages into another stage using a function.
718 | *
719 | * @param a the first stage.
720 | * @param b the second stage.
721 | * @param c the third stage.
722 | * @param d the fourth stage.
723 | * @param e the fifth stage.
724 | * @param f the sixth stage.
725 | * @param function the combining function.
726 | * @param the type of the composed {@link CompletionStage}.
727 | * @param the type of the first stage's value.
728 | * @param the type of the second stage's value.
729 | * @param the type of the third stage's value.
730 | * @param the type of the fourth stage's value.
731 | * @param the type of the fifth stage's value.
732 | * @param the type of the sixth stage's value.
733 | * @return a stage that is composed from the input stages using the function.
734 | * @throws UnsupportedOperationException if any of the {@link CompletionStage}s
735 | * do not interoperate with CompletableFuture
736 | */
737 | public static CompletionStage combineFutures(
738 | CompletionStage a,
739 | CompletionStage b,
740 | CompletionStage c,
741 | CompletionStage