Class AsyncFoldLeft


  • public class AsyncFoldLeft
    extends Object

    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.
     });
     
    • Constructor Detail

      • AsyncFoldLeft

        public AsyncFoldLeft()
    • Method Detail

      • run

        @Deprecated
        public static <T,​R> void run​(List<T> list,
                                           R zero,
                                           AsyncFoldLeft.Operation<T,​R> operation,
                                           Promise<R> promise)

        Processes the given list of elements.

        The initial result zero is returned if the list is empty.

        For each element the operation function is invoked.

        Type Parameters:
        T - the type of element
        R - the type of the result
        Parameters:
        list - the elements to process
        zero - the initial result
        operation - the operation to invoke for each element
        promise - the promise to notify of the final result
      • run

        public static <T,​R> void run​(Collection<T> collection,
                                           R zero,
                                           AsyncFoldLeft.Operation<T,​R> operation,
                                           Promise<R> promise)

        Processes the given collection of elements.

        The initial result zero is returned if the collection is empty.

        For each element the operation function is invoked.

        The collection should have a "stable" iterator, i.e. it should not be affected if the collection is modified concurrently by another thread, or by the same thread in th operation during the iteration.

        Type Parameters:
        T - the type of element
        R - the type of the result
        Parameters:
        collection - the elements to process
        zero - the initial result
        operation - the operation to invoke for each element
        promise - the promise to notify of the final result