Method recover

include/process/future.hpp:1624–1666

template <typename T>
template <typename F>
Future<T> Future<T>::recover(F&& f) const
{
  std::shared_ptr<Promise<T>> promise(new Promise<T>());

  const Future<T> future = *this;

  typedef decltype(std::move(f)(future)) R;

  std::shared_ptr<lambda::CallableOnce<R(const Future<T>&)>> callable(
      new lambda::CallableOnce<R(const Future<T>&)>(std::move(f)));

  onAny([=]() {
    if (future.isDiscarded() || future.isFailed()) {
      // We reset `discard` so that if a future gets returned from
      // `f(future)` we won't immediately discard it! We still want to
      // let the future get discarded later, however, hence if it gets
      // set again in the future it'll propagate to the returned
      // future.
      synchronized (promise->f.data->lock) {
        promise->f.data->discard = false;
      }

      promise->set(std::move(*callable)(future));
    } else {
      promise->associate(future);
    }
  });

  onAbandoned([=]() {
    // See comment above for why we reset `discard` here.
    synchronized (promise->f.data->lock) {
      promise->f.data->discard = false;
    }
    promise->set(std::move(*callable)(future));
  });

  // Propagate discarding up the chain. To avoid cyclic dependencies,
  // we keep a weak future in the callback.
  promise->future().onDiscard(
      lambda::bind(&internal::discard<T>, WeakFuture<T>(*this)));

  return promise->future();
}


template <typename T>