Class AggregateFuture<InputT,OutputT>

Type Parameters:
InputT - the type of the individual inputs
OutputT - the type of the output (i.e. this) future
All Implemented Interfaces:
AbstractFuture.Trusted<OutputT>, ListenableFuture<OutputT>, Future<OutputT>
Direct Known Subclasses:
CollectionFuture, CombinedFuture

abstract class AggregateFuture<InputT,OutputT> extends AggregateFutureState<OutputT>
A future whose value is derived from a collection of input futures.
  • Field Details

    • logger

      private static final LazyLogger logger
    • futures

      @CheckForNull private ImmutableCollection<? extends ListenableFuture<? extends InputT>> futures
      The input futures. After init(), this field is read only by afterDone() (to propagate cancellation) and AbstractFuture.toString(). To access the futures' values, AggregateFuture attaches listeners that hold references to one or more inputs. And in the case of CombinedFuture, the user-supplied callback usually has its own references to inputs.
    • allMustSucceed

      private final boolean allMustSucceed
    • collectsValues

      private final boolean collectsValues
  • Constructor Details

  • Method Details

    • afterDone

      protected final void afterDone()
      Description copied from class: AbstractFuture
      Callback method that is called exactly once after the future is completed.

      If AbstractFuture.interruptTask() is also run during completion, AbstractFuture.afterDone() runs after it.

      The default implementation of this method in AbstractFuture does nothing. This is intended for very lightweight cleanup work, for example, timing statistics or clearing fields. If your task does anything heavier consider, just using a listener with an executor.

      Overrides:
      afterDone in class AbstractFuture<OutputT>
    • pendingToString

      @CheckForNull protected final String pendingToString()
      Description copied from class: AbstractFuture
      Provide a human-readable explanation of why this future has not yet completed.
      Overrides:
      pendingToString in class AbstractFuture<OutputT>
      Returns:
      null if an explanation cannot be provided (e.g. because the future is done).
    • init

      final void init()
      Must be called at the end of each subclass's constructor. This method performs the "real" initialization; we can't put this in the constructor because, in the case where futures are already complete, we would not initialize the subclass before calling collectValueFromNonCancelledFuture(int, java.util.concurrent.Future<? extends InputT>). As this is called after the subclass is constructed, we're guaranteed to have properly initialized the subclass.
    • processAllMustSucceedDoneFuture

      private void processAllMustSucceedDoneFuture(int index, ListenableFuture<? extends InputT> future)
    • handleException

      private void handleException(Throwable throwable)
      Fails this future with the given Throwable if allMustSucceed is true. Also, logs the throwable if it is an Error or if allMustSucceed is true, the throwable did not cause this future to fail, and it is the first time we've seen that particular Throwable.
    • log

      private static void log(Throwable throwable)
    • addInitialException

      final void addInitialException(Set<Throwable> seen)
      Description copied from class: AggregateFutureState
      Populates seen with the exception that was passed to setException.
      Specified by:
      addInitialException in class AggregateFutureState<OutputT>
    • collectValueFromNonCancelledFuture

      private void collectValueFromNonCancelledFuture(int index, Future<? extends InputT> future)
      Collects the result (success or failure) of one input future. The input must not have been cancelled. For details on when this is called, see collectOneValue(int, InputT).
    • decrementCountAndMaybeComplete

      private void decrementCountAndMaybeComplete(@CheckForNull ImmutableCollection<? extends Future<? extends InputT>> futuresIfNeedToCollectAtCompletion)
    • processCompleted

      private void processCompleted(@CheckForNull ImmutableCollection<? extends Future<? extends InputT>> futuresIfNeedToCollectAtCompletion)
    • releaseResources

      void releaseResources(AggregateFuture.ReleaseResourcesReason reason)
      Clears fields that are no longer needed after this future has completed -- or at least all its inputs have completed (more precisely, after handleAllCompleted() has been called). Often called multiple times (that is, both when the inputs complete and when the output completes).

      This is similar to our proposed afterCommit method but not quite the same. See the description of CL 265462958.

    • collectOneValue

      abstract void collectOneValue(int index, InputT returnValue)
      If allMustSucceed is true, called as each future completes; otherwise, if collectsValues is true, called for each future when all futures complete.
    • handleAllCompleted

      abstract void handleAllCompleted()
    • addCausalChain

      private static boolean addCausalChain(Set<Throwable> seen, Throwable param)
      Adds the chain to the seen set, and returns whether all the chain was new to us.