Processes asynchronously a sequence of elements, producing a result that is the reduction of the results produced by the processing of each element.
This class implements the asynchronous version of the following synchronous
for
loop, but where the processing of each element may be asynchronous.
R result;
for (T element : list) {
(result, proceed) = operation.apply(result, element);
if (!proceed) {
break;
}
}
Using this class, the loop above becomes:
R zero;
AsyncFoldLeft.run(list, zero, (result, element, loop) -> {
CompletableFuture<R> future = processAsync(element);
future.whenComplete((r, x) -> {
if (x == null) {
R reduced = reduce(result, r);
if (shouldIterate(r)) {
loop.proceed(reduced);
} else {
loop.leave(reduced);
}
} else {
loop.fail(x);
}
})
}, Promise.complete((r, x) -> {
// Process final result or failure.
});
-
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionstatic interface
Controls the iteration over a sequence of elements, allowing to continue the iteration (with a result), break out of the iteration (with a result), or fail the iteration (with an exception).static interface
The operation to invoke for each element. -
Method Summary
Modifier and TypeMethodDescriptionstatic <T,
R> void reverseRun
(List<T> list, R zero, AsyncFoldLeft.Operation<T, R> operation, Promise<R> promise) Processes, in reverse order, the given sequence of elements.static <T,
R> void run
(Iterable<T> iterable, R zero, AsyncFoldLeft.Operation<T, R> operation, Promise<R> promise) Processes the given sequence of elements.static <T,
R> void run
(T[] array, R zero, AsyncFoldLeft.Operation<T, R> operation, Promise<R> promise) Processes the given array of elements.
-
Method Details
-
run
public static <T,R> void run(T[] array, R zero, AsyncFoldLeft.Operation<T, R> operation, Promise<R> promise) Processes the given array of elements.
- Type Parameters:
T
- the type of elementR
- the type of the result- Parameters:
array
- the elements to processzero
- the initial resultoperation
- the operation to invoke for each elementpromise
- the promise to notify of the final result- See Also:
-
run
public static <T,R> void run(Iterable<T> iterable, R zero, AsyncFoldLeft.Operation<T, R> operation, Promise<R> promise) Processes the given sequence of elements.
The initial result
zero
is returned if the sequence is empty.For each element the
operation
function is invoked.The sequence should have a "stable" iterator, i.e. it should not be affected if the sequence is modified during the iteration, either concurrently by another thread, or by the same thread in the
operation
function.- Type Parameters:
T
- the type of elementR
- the type of the result- Parameters:
iterable
- the elements to processzero
- the initial resultoperation
- the operation to invoke for each elementpromise
- the promise to notify of the final result
-
reverseRun
public static <T,R> void reverseRun(List<T> list, R zero, AsyncFoldLeft.Operation<T, R> operation, Promise<R> promise) Processes, in reverse order, the given sequence of elements.
- Type Parameters:
T
- the type of elementR
- the type of the result- Parameters:
list
- the elements to processzero
- the initial resultoperation
- the operation to invoke for each elementpromise
- the promise to notify of the final result- See Also:
-