folly::Future< T > Class Template Reference

#include <FiberManagerInternal.h>

Inheritance diagram for folly::Future< T >:

Public Types
typedef T	value_type

Public Member Functions
template<class T2 = T, typename = typename std::enable_if< !isFuture<typename std::decay<T2>::type>::value && !isSemiFuture<typename std::decay<T2>::type>::value>::type>
	Future (T2 &&val)
template<class T2 = T>
	Future (typename std::enable_if< std::is_same< Unit, T2 >::value >::type *p=nullptr)
template<class... Args, typename std::enable_if< std::is_constructible< T, Args &&... >::value, int >::type = 0>
	Future (in_place_t, Args &&...args)
	Future (Future< T > const &)=delete
	Future (Future< T > &&) noexcept
template<class T2 , typename std::enable_if< !std::is_same< T, typename std::decay< T2 >::type >::value &&std::is_constructible< T, T2 && >::value &&std::is_convertible< T2 &&, T >::value, int >::type = 0>
	Future (Future< T2 > &&)
template<class T2 , typename std::enable_if< !std::is_same< T, typename std::decay< T2 >::type >::value &&std::is_constructible< T, T2 && >::value &&!std::is_convertible< T2 &&, T >::value, int >::type = 0>
	Future (Future< T2 > &&)
template<class T2 , typename std::enable_if< !std::is_same< T, typename std::decay< T2 >::type >::value &&std::is_constructible< T, T2 && >::value, int >::type = 0>
Future &	operator= (Future< T2 > &&)
Future &	operator= (Future const &)=delete
Future &	operator= (Future &&) noexcept
T	getVia (DrivableExecutor *e)
T	getVia (TimedDrivableExecutor *e, Duration dur)
Try< T > &	getTryVia (DrivableExecutor *e)
Try< T > &	getTryVia (TimedDrivableExecutor *e, Duration dur)
template<class F = T>
std::enable_if< isFuture< F >::value, Future< typename isFuture< T >::Inner > >::type	unwrap ()&&
Future< T >	via (Executor *executor, int8_t priority=Executor::MID_PRI)&&
Future< T >	via (Executor::KeepAlive<> executor, int8_t priority=Executor::MID_PRI)&&
Future< T >	via (Executor *executor, int8_t priority=Executor::MID_PRI)&
Future< T >	via (Executor::KeepAlive<> executor, int8_t priority=Executor::MID_PRI)&
template<typename F , typename R = futures::detail::callableResult<T, F>>
std::enable_if< !is_invocable< F >::value &&is_invocable< F, T && >::value, typename R::Return >::type	then (F &&func)&&
template<typename F , typename R = futures::detail::callableResult<T, F>>
std::enable_if< !is_invocable< F, T && >::value &&!is_invocable< F >::value, typename R::Return >::type	then (F &&func)&&
template<typename F , typename R = futures::detail::callableResult<T, F>>
std::enable_if< is_invocable< F >::value, typename R::Return >::type	then (F &&func)&&=delete
template<typename F , typename R = futures::detail::callableResult<T, F>>
R::Return	then (F &&func)&=delete
template<typename R , typename Caller , typename... Args>
Future< typename isFuture< R >::Inner >	then (R(Caller::*func)(Args...), Caller *instance)&&
template<typename R , typename Caller , typename... Args>
Future< typename isFuture< R >::Inner >	then (R(Caller::*func)(Args...), Caller *instance)&=delete
template<class Arg >
auto	then (Executor *x, Arg &&arg)&&
template<class R , class Caller , class... Args>
auto	then (Executor *x, R(Caller::*func)(Args...), Caller *instance)&&
template<class Arg , class... Args>
auto	then (Executor *x, Arg &&arg, Args &&...args)&=delete
template<typename F >
Future< typename futures::detail::tryCallableResult< T, F >::value_type >	thenTry (F &&func)&&
template<typename R , typename... Args>
auto	thenTry (R(&func)(Args...))&&
template<typename F >
Future< typename futures::detail::valueCallableResult< T, F >::value_type >	thenValue (F &&func)&&
template<typename R , typename... Args>
auto	thenValue (R(&func)(Args...))&&
template<class ExceptionType , class F >
Future< T >	thenError (F &&func)&&
template<class ExceptionType , class R , class... Args>
Future< T >	thenError (R(&func)(Args...))&&
template<class F >
Future< T >	thenError (F &&func)&&
template<class R , class... Args>
Future< T >	thenError (R(&func)(Args...))&&
Future< Unit >	then ()&&
Future< Unit >	then ()&=delete
Future< Unit >	unit ()&&
template<class F >
std::enable_if< !is_invocable< F, exception_wrapper >::value &&!futures::detail::Extract< F >::ReturnsFuture::value, Future< T > >::type	onError (F &&func)&&
template<class F >
std::enable_if< !is_invocable< F, exception_wrapper >::value &&futures::detail::Extract< F >::ReturnsFuture::value, Future< T > >::type	onError (F &&func)&&
template<class F >
std::enable_if< is_invocable< F, exception_wrapper >::value &&futures::detail::Extract< F >::ReturnsFuture::value, Future< T > >::type	onError (F &&func)&&
template<class F >
std::enable_if< is_invocable< F, exception_wrapper >::value &&!futures::detail::Extract< F >::ReturnsFuture::value, Future< T > >::type	onError (F &&func)&&
template<class F >
Future< T >	onError (F &&func)&
template<class F >
Future< T >	ensure (F &&func)&&
template<class F >
Future< T >	onTimeout (Duration, F &&func, Timekeeper *=nullptr)&&
Future< T >	within (Duration dur, Timekeeper *tk=nullptr)&&
template<class E >
Future< T >	within (Duration dur, E exception, Timekeeper *tk=nullptr)&&
Future< T >	delayed (Duration, Timekeeper *=nullptr)&&
Future< T >	delayedUnsafe (Duration, Timekeeper *=nullptr)
T	get ()&&
T	get ()&=delete
T	get (Duration dur)&&
T	get (Duration dur)&=delete
Try< T > &	getTry ()
Future< T > &	wait ()&
Future< T > &&	wait ()&&
Future< T > &	wait (Duration dur)&
Future< T > &&	wait (Duration dur)&&
Future< T > &	waitVia (DrivableExecutor *e)&
Future< T > &&	waitVia (DrivableExecutor *e)&&
Future< T > &	waitVia (TimedDrivableExecutor *e, Duration dur)&
Future< T > &&	waitVia (TimedDrivableExecutor *e, Duration dur)&&
Future< bool >	willEqual (Future< T > &)
template<class F >
Future< T >	filter (F &&predicate)&&
template<class I , class F >
Future< I >	reduce (I &&initial, F &&func)&&
template<class Callback , class... Callbacks>
auto	thenMulti (Callback &&fn, Callbacks &&...fns)&&
template<class Callback >
auto	thenMulti (Callback &&fn)&&
template<class Callback >
auto	thenMulti (Callback &&fn)&
template<class Callback , class... Callbacks>
auto	thenMultiWithExecutor (Executor *x, Callback &&fn, Callbacks &&...fns)&&
template<class Callback >
auto	thenMultiWithExecutor (Executor *x, Callback &&fn)&&
SemiFuture< T >	semi ()&&
template<class T2 , typename std::enable_if< !std::is_same< T, typename std::decay< T2 >::type >::value &&std::is_constructible< T, T2 && >::value, int >::type >
Future< T > &	operator= (Future< T2 > &&other)

Static Public Member Functions
static Future< T >	makeEmpty ()

Protected Types
using	Core = futures::detail::Core< T >

Protected Member Functions
	Future (Core *obj)
	Future (futures::detail::EmptyConstruct) noexcept

Private Types
using	Base = futures::detail::FutureBase< T >
Private Types inherited from folly::futures::detail::FutureBase< T >
typedef T	value_type
using	Core = futures::detail::Core< T >

Friends
class	Promise< T >
template<class >
class	futures::detail::FutureBase
template<class >
class	Future
template<class >
class	SemiFuture
template<class >
class	FutureSplitter
template<class T2 >
Future< T2 >	makeFuture (Try< T2 >)
template<class F >
Future< Unit >	times (int n, F &&thunk)
template<class F >
Future< Unit >	when (bool p, F &&thunk)
template<class P , class F >
Future< Unit >	whileDo (P &&predicate, F &&thunk)
template<class FT >
void	futures::detail::convertFuture (SemiFuture< FT > &&sf, Future< FT > &f)

Additional Inherited Members
Private Member Functions inherited from folly::futures::detail::FutureBase< T >
template<class T2 = T, typename = typename std::enable_if< !isFuture<typename std::decay<T2>::type>::value && !isSemiFuture<typename std::decay<T2>::type>::value>::type>
	FutureBase (T2 &&val)
template<class T2 = T>
	FutureBase (typename std::enable_if< std::is_same< Unit, T2 >::value >::type *)
template<class... Args, typename std::enable_if< std::is_constructible< T, Args &&... >::value, int >::type = 0>
	FutureBase (in_place_t, Args &&...args)
	FutureBase (FutureBase< T > const &)=delete
	FutureBase (SemiFuture< T > &&) noexcept
	FutureBase (Future< T > &&) noexcept
	FutureBase (Future< T > const &)=delete
	FutureBase (SemiFuture< T > const &)=delete
	~FutureBase ()
bool	valid () const noexcept
T &	value ()&
T const &	value () const &
T &&	value ()&&
T const &&	value () const &&
Try< T > &	result ()&
Try< T > const &	result () const &
Try< T > &&	result ()&&
Try< T > const &&	result () const &&
bool	isReady () const
bool	hasValue () const
bool	hasException () const
Optional< Try< T > >	poll ()
template<class F >
void	setCallback_ (F &&func)
template<class F >
void	setCallback_ (F &&func, std::shared_ptr< folly::RequestContext > context)
void	raise (exception_wrapper interrupt)
template<class E >
void	raise (E &&exception)
void	cancel ()
int8_t	getPriority () const
Core &	getCore ()
Core const &	getCore () const
Try< T > &	getCoreTryChecked ()
Try< T > const &	getCoreTryChecked () const
	FutureBase (Core *obj)
	FutureBase (futures::detail::EmptyConstruct) noexcept
void	detach ()
void	throwIfInvalid () const
void	throwIfContinued () const
void	assign (FutureBase< T > &&other) noexcept
Executor *	getExecutor () const
void	setExecutor (Executor *x, int8_t priority=Executor::MID_PRI)
void	setExecutor (Executor::KeepAlive<> x, int8_t priority=Executor::MID_PRI)
template<typename F , typename R >
std::enable_if<!R::ReturnsFuture::value, typename R::Return >::type	thenImplementation (F &&func, R)
template<typename F , typename R >
std::enable_if< R::ReturnsFuture::value, typename R::Return >::type	thenImplementation (F &&func, R)
template<typename E >
SemiFuture< T >	withinImplementation (Duration dur, E e, Timekeeper *tk)&&
Static Private Member Functions inherited from folly::futures::detail::FutureBase< T >
template<typename Self >
static decltype(auto)	getCoreImpl (Self &self)
template<typename Self >
static decltype(auto)	getCoreTryChecked (Self &self)
Private Attributes inherited from folly::futures::detail::FutureBase< T >
Core *	core_

Detailed Description

template<class T>
class folly::Future< T >

The interface (along with SemiFuture) for the consumer-side of a producer/consumer pair.

Future vs. SemiFuture:

• The consumer-side should generally start with a SemiFuture, not a Future.
• Example, when a library creates and returns a future, it should usually return a SemiFuture, not a Future.
• Reason: so the thread policy for continuations (.thenValue, etc.) can be specified by the library's caller (using .via()).
• A SemiFuture is converted to a Future using .via().
• Use makePromiseContract() when creating both a Promise and an associated SemiFuture/Future.

When practical, prefer SemiFuture/Future's nonblocking style/pattern:

• the nonblocking style uses continuations, e.g., .thenValue, etc.; the continuations are deferred until the result is available.
• the blocking style blocks until complete, e.g., .wait(), .get(), etc.
• the two styles cannot be mixed within the same future; use one or the other.

SemiFuture/Future also provide a back-channel so an interrupt can be sent from consumer to producer; see SemiFuture/Future's raise() and Promise's setInterruptHandler().

The consumer-side SemiFuture/Future objects should generally be accessed via a single thread. That thread is referred to as the 'consumer thread.'

Definition at line 46 of file FiberManagerInternal.h.

Member Typedef Documentation

template<class T>

using folly::Future< T >::Base = futures::detail::FutureBase<T>

private

Definition at line 962 of file Future.h.

template<class T>

using folly::futures::detail::FutureBase< T >::Core = futures::detail::Core<T>

protected

Definition at line 359 of file Future.h.

template<class T>

typedef T folly::futures::detail::FutureBase< T >::value_type

Definition at line 117 of file Future.h.

Constructor & Destructor Documentation

template<class T>

template<class T2 = T, typename = typename std::enable_if< !isFuture<typename std::decay<T2>::type>::value && !isSemiFuture<typename std::decay<T2>::type>::value>::type>

folly::Future< T >::Future ( T2 &&  val )

inline

Construct a Future from a value (perfect forwarding)

Postconditions:

• valid() == true
• isReady() == true
• hasValue() == true
• value(), get(), result() will return the forwarded T

Definition at line 981 of file Future.h.

: Base(std::forward<T2>(val)) {}

template<class T>

template<class T2 = T>

folly::Future< T >::Future ( typename std::enable_if< std::is_same< Unit, T2 >::value >::type *  p = nullptr )

inline

Construct a (logical) Future-of-void.

Postconditions:

• valid() == true
• isReady() == true
• hasValue() == true

Definition at line 991 of file Future.h.

      : Base(p) {}

template<class T>

template<class... Args, typename std::enable_if< std::is_constructible< T, Args &&... >::value, int >::type = 0>

folly::Future< T >::Future ( in_place_t  , Args &&...  args  )

inlineexplicit

Construct a Future from a T constructed from args

Postconditions:

• valid() == true
• isReady() == true
• hasValue() == true
• hasException() == false
• value(), get(), result() will return the newly constructed T

Definition at line 1008 of file Future.h.

      : Base(in_place, std::forward<Args>(args)...) {}

template<class T>

folly::Future< T >::Future ( Future< T > const &  )

delete

template<class T>

folly::Future< T >::Future ( Future< T > &&  other )

noexcept

Definition at line 956 of file Future-inl.h.

    : futures::detail::FutureBase<T>(std::move(other)) {}

template<class T >

template<class T2, typename std::enable_if< !std::is_same< T, typename std::decay< T2 >::type >::value &&std::is_constructible< T, T2 && >::value &&!std::is_convertible< T2 &&, T >::value, int >::type >

folly::Future< T >::Future

(

Future< T2 > &&

other

)

Definition at line 973 of file Future-inl.h.

References folly::Future< T >::Future, folly::gen::move, folly::T, folly::Future< T >::thenValue(), type, value, and folly::futures::detail::FutureBase< T >::value().

    : Future(
          std::move(other).thenValue([](T2&& v) { return T(std::move(v)); })) {}

template<class T>

template<class T2 , typename std::enable_if< !std::is_same< T, typename std::decay< T2 >::type >::value &&std::is_constructible< T, T2 && >::value &&!std::is_convertible< T2 &&, T >::value, int >::type = 0>

folly::Future< T >::Future ( Future< T2 > &&  )

explicit

template<class T>

folly::Future< T >::Future ( Core *  obj )

inlineexplicitprotected

Definition at line 1944 of file Future.h.

: Base(obj) {}

template<class T>

folly::Future< T >::Future ( futures::detail::EmptyConstruct  )

inlineexplicitprotectednoexcept

Definition at line 1946 of file Future.h.

      : Base(futures::detail::EmptyConstruct{}) {}

Member Function Documentation

template<class T >

Future< T > folly::Future< T >::delayed	(	Duration	dur,
		Timekeeper *	tk = nullptr
	)

Delay the completion of this Future for at least this duration from now. The optional Timekeeper is as with futures::sleep().

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == false
• RESULT.valid() == true

Definition at line 1986 of file Future-inl.h.

References folly::collectAllSemiFuture(), folly::futures::detail::FutureBase< T >::getExecutor(), folly::InlineExecutor::instance(), folly::gen::move, and folly::futures::sleep().

                                                            {
  auto e = this->getExecutor();
  return collectAllSemiFuture(*this, futures::sleep(dur, tk))
      .via(e ? e : &InlineExecutor::instance())
      .thenValue([](std::tuple<Try<T>, Try<Unit>>&& tup) {
        return makeFuture<T>(std::get<0>(std::move(tup)));
      });
}

template<class T >

Future< T > folly::Future< T >::delayedUnsafe	(	Duration	dur,
		Timekeeper *	tk = nullptr
	)

Delay the completion of this Future for at least this duration from now. The optional Timekeeper is as with futures::sleep(). NOTE: Deprecated WARNING: Returned future may complete on Timekeeper thread.

Definition at line 1996 of file Future-inl.h.

References folly::gen::move.

                                                               {
  return std::move(*this).semi().delayed(dur, tk).toUnsafeFuture();
}

template<class T >

template<class F >

Future< T > folly::Future< T >::ensure

(

F &&

func

)

func is like std::function<void()> and is executed unconditionally, and the value/exception is passed through to the resulting Future. func shouldn't throw, but if it does it will be captured and propagated, and discard any value/exception that this Future has obtained.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1203 of file Future-inl.h.

References folly::gen::move, and folly::pushmi::detail::t.

                                       {
  return std::move(*this).thenTry(
      [funcw = std::forward<F>(func)](Try<T>&& t) mutable {
        std::forward<F>(funcw)();
        return makeFuture(std::move(t));
      });
}

template<class T >

template<class F >

Future< T > folly::Future< T >::filter

(

F &&

predicate

)

predicate behaves like std::function<bool(T const&)> If the predicate does not obtain with the value, the result is a folly::FuturePredicateDoesNotObtain exception

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 2319 of file Future-inl.h.

References folly::gen::move, folly::T, and val.

                                            {
  return std::move(*this).thenValue([p = std::forward<F>(predicate)](T val) {
    T const& valConstRef = val;
    if (!p(valConstRef)) {
      throw_exception<FuturePredicateDoesNotObtain>();
    }
    return val;
  });
}

template<class T >

T folly::Future< T >::get

(

)

Blocks until the future is fulfilled. Returns the value (moved-out), or throws the exception. The future must not already have a continuation.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == false

Definition at line 2245 of file Future-inl.h.

References folly::copy(), folly::gen::move, and folly::Future< T >::wait().

                    {
  wait();
  return copy(std::move(*this)).value();
}

template<class T>

T folly::Future< T >::get ( )

delete

template<class T >

T folly::Future< T >::get

(

Duration

dur

)

Blocks until the future is fulfilled, or until dur elapses. Returns the value (moved-out), or throws the exception (which might be a FutureTimeout exception).

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == false

Definition at line 2251 of file Future-inl.h.

References folly::copy(), folly::gen::move, and folly::Future< T >::wait().

                                {
  wait(dur);
  auto future = copy(std::move(*this));
  if (!future.isReady()) {
    throw_exception<FutureTimeout>();
  }
  return std::move(future).value();
}

template<class T>

T folly::Future< T >::get ( Duration  dur )

delete

template<class T >

Try< T > & folly::Future< T >::getTry

(

)

A reference to the Try of the value

Preconditions:

• valid() == true (else throws FutureInvalid)
• isReady() == true (else throws FutureNotReady)

Definition at line 2261 of file Future-inl.h.

References folly::futures::detail::FutureBase< T >::result().

Referenced by folly::SemiFuture< T >::getTry().

                          {
  return result();
}

template<class T >

Try< T > & folly::Future< T >::getTryVia

(

DrivableExecutor *

e

)

Call e->drive() repeatedly until the future is fulfilled. Examples of DrivableExecutor include EventBase and ManualExecutor. Returns a reference to the Try of the value.

Definition at line 2280 of file Future-inl.h.

References folly::Future< T >::waitVia().

                                                {
  return waitVia(e).getTry();
}

template<class T >

Try< T > & folly::Future< T >::getTryVia	(	TimedDrivableExecutor *	e,
		Duration	dur
	)

getTryVia but will wait only until dur elapses. Returns the Try of the value (moved-out) or may throw a FutureTimeout exception.

Definition at line 2285 of file Future-inl.h.

References folly::futures::detail::FutureBase< T >::isReady(), folly::futures::detail::FutureBase< T >::result(), and folly::Future< T >::waitVia().

                                                                   {
  waitVia(e, dur);
  if (!this->isReady()) {
    throw_exception<FutureTimeout>();
  }
  return result();
}

template<class T >

T folly::Future< T >::getVia

(

DrivableExecutor *

e

)

Call e->drive() repeatedly until the future is fulfilled.

Examples of DrivableExecutor include EventBase and ManualExecutor.

Returns the fulfilled value (moved-out) or throws the fulfilled exception.

Definition at line 2266 of file Future-inl.h.

References folly::gen::move, folly::futures::detail::FutureBase< T >::value(), and folly::Future< T >::waitVia().

                                       {
  return std::move(waitVia(e).value());
}

template<class T >

T folly::Future< T >::getVia	(	TimedDrivableExecutor *	e,
		Duration	dur
	)

Call e->drive() repeatedly until the future is fulfilled, or dur elapses.

Returns the fulfilled value (moved-out), throws the fulfilled exception, or on timeout throws FutureTimeout.

Definition at line 2271 of file Future-inl.h.

References folly::futures::detail::FutureBase< T >::isReady(), folly::gen::move, folly::futures::detail::FutureBase< T >::value(), and folly::Future< T >::waitVia().

                                                          {
  waitVia(e, dur);
  if (!this->isReady()) {
    throw_exception<FutureTimeout>();
  }
  return std::move(value());
}

template<class T >

Future< T > folly::Future< T >::makeEmpty ( )

static

Creates/returns an invalid Future, that is, one with no shared state.

Postcondition:

• RESULT.valid() == false

Definition at line 951 of file Future-inl.h.

Referenced by TEST().

                               {
  return Future<T>(futures::detail::EmptyConstruct{});
}

template<class T >

template<class F >

std::enable_if< is_invocable< F, exception_wrapper >::value &&!futures::detail::Extract< F >::ReturnsFuture::value, Future< T > >::type folly::Future< T >::onError

(

F &&

func

)

Set an error continuation for this Future. The continuation should take an argument of the type that you want to catch, and should return a value of the same type as this Future, or a Future of that type (see overload below).

Example:

makeFuture() .thenValue([] { throw std::runtime_error("oh no!"); return 42; }) .thenError<std::runtime_error>([] (std::runtime_error& e) { LOG(INFO) << "std::runtime_error: " << e.what(); return -1; // or makeFuture<int>(-1) });

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1131 of file Future-inl.h.

References folly::Promise< T >::core_, folly::futures::detail::FutureBase< T >::getCore(), folly::Promise< T >::getSemiFuture(), folly::InlineExecutor::instance(), folly::futures::detail::makeCoreCallbackState(), folly::gen::move, folly::futures::detail::FutureBase< T >::setCallback_(), folly::futures::detail::Core< T >::setInterruptHandlerNoLock(), folly::pushmi::detail::t, folly::T, type, and folly::futures::detail::FutureBase< T >::value().

Referenced by folly::Future< T >::onTimeout().

                              {
  typedef std::remove_reference_t<
      typename futures::detail::Extract<F>::FirstArg>
      Exn;
  static_assert(
      std::is_same<typename futures::detail::Extract<F>::RawReturn, T>::value,
      "Return type of onError callback must be T or Future<T>");

  Promise<T> p;
  p.core_->setInterruptHandlerNoLock(this->getCore().getInterruptHandler());
  auto sf = p.getSemiFuture();

  this->setCallback_(
      [state = futures::detail::makeCoreCallbackState(
           std::move(p), std::forward<F>(func))](Try<T>&& t) mutable {
        if (auto e = t.template tryGetExceptionObject<Exn>()) {
          state.setTry(makeTryWith([&] { return state.invoke(*e); }));
        } else {
          state.setTry(std::move(t));
        }
      });

  // Allow for applying to future with null executor while this is still
  // possible.
  // TODO(T26801487): Should have an executor
  return std::move(sf).via(&InlineExecutor::instance());
}

template<class T>

template<class F >

std::enable_if< !is_invocable<F, exception_wrapper>::value && futures::detail::Extract<F>::ReturnsFuture::value, Future<T> >::type folly::Future< T >::onError

(

F &&

func

)

Overload of onError where the error continuation returns a Future<T>

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

template<class T>

template<class F >

std::enable_if< is_invocable<F, exception_wrapper>::value && futures::detail::Extract<F>::ReturnsFuture::value, Future<T> >::type folly::Future< T >::onError

(

F &&

func

)

Overload of onError that takes exception_wrapper and returns Future<T>

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

template<class T>

template<class F >

std::enable_if< is_invocable<F, exception_wrapper>::value && !futures::detail::Extract<F>::ReturnsFuture::value, Future<T> >::type folly::Future< T >::onError

(

F &&

func

)

Overload of onError that takes exception_wrapper and returns T

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

template<class T>

template<class F >

Future<T> folly::Future< T >::onError ( F &&  func )

inline

Definition at line 1525 of file Future.h.

                                {
    return std::move(*this).onError(std::forward<F>(func));
  }

template<class T >

template<class F >

Future< T > folly::Future< T >::onTimeout	(	Duration	dur,
		F &&	func,
		Timekeeper *	tk = nullptr
	)

Like onError, but for timeouts. example:

Future<int> f = makeFuture<int>(42) .delayed(long_time) .onTimeout(short_time, [] { return -1; });

or perhaps

Future<int> f = makeFuture<int>(42) .delayed(long_time) .onTimeout(short_time, [] { return makeFuture<int>(some_exception); });

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1213 of file Future-inl.h.

References folly::Try< T >::exception(), folly::Promise< T >::getSemiFuture(), folly::Try< T >::hasException(), folly::InlineExecutor::instance(), folly::futures::detail::makeCoreCallbackState(), folly::makeTryWith(), folly::gen::move, folly::Future< T >::onError(), folly::futures::detail::FutureBase< T >::setCallback_(), folly::Promise< T >::setTry(), folly::pushmi::detail::t, type, and folly::futures::detail::FutureBase< T >::value().

                                                                        {
  return std::move(*this).within(dur, tk).template thenError<FutureTimeout>(
      [funcw = std::forward<F>(func)](auto const&) mutable {
        return std::forward<F>(funcw)();
      });
}

template<class T>

template<class T2 , typename std::enable_if< !std::is_same< T, typename std::decay< T2 >::type >::value &&std::is_constructible< T, T2 && >::value, int >::type >

Future<T>& folly::Future< T >::operator=

(

Future< T2 > &&

other

)

Definition at line 996 of file Future-inl.h.

References folly::gen::move, folly::Future< T >::operator=(), folly::T, folly::Future< T >::thenValue(), type, and value.

                                                  {
  return operator=(
      std::move(other).thenValue([](T2&& v) { return T(std::move(v)); }));
}

template<class T>

template<class T2 , typename std::enable_if< !std::is_same< T, typename std::decay< T2 >::type >::value &&std::is_constructible< T, T2 && >::value, int >::type = 0>

Future& folly::Future< T >::operator=

(

Future< T2 > &&

)

Referenced by folly::Future< T >::operator=().

template<class T>

Future& folly::Future< T >::operator= ( Future< T > const &  )

delete

template<class T >

Future< T > & folly::Future< T >::operator= ( Future< T > &&  other )

noexcept

Definition at line 960 of file Future-inl.h.

References folly::futures::detail::FutureBase< T >::assign(), folly::gen::move, type, value, and folly::futures::detail::FutureBase< T >::value().

                                                          {
  this->assign(std::move(other));
  return *this;
}

template<class T >

template<class I , class F >

Future< I > folly::Future< T >::reduce	(	I &&	initial,
		F &&	func
	)

Like reduce, but works on a Future<std::vector<T / Try<T>>>, for example the result of collect or collectAll

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1865 of file Future-inl.h.

References folly::gen::move, and folly::T.

                                                    {
  return std::move(*this).thenValue(
      [minitial = std::forward<I>(initial),
       mfunc = std::forward<F>(func)](T&& vals) mutable {
        auto ret = std::move(minitial);
        for (auto& val : vals) {
          ret = mfunc(std::move(ret), std::move(val));
        }
        return ret;
      });
}

template<class T>

SemiFuture<T> folly::Future< T >::semi ( )

inline

Moves-out *this, creating/returning a corresponding SemiFuture. Result will behave like *this except result won't have an Executor.

Postconditions:

• RESULT.valid() == the original value of this->valid()
• RESULT will not have an Executor regardless of whether *this had one

Definition at line 1912 of file Future.h.

                          {
    return SemiFuture<T>{std::move(*this)};
  }

template<class T>

template<typename F , typename R = futures::detail::callableResult<T, F>>

std::enable_if< !is_invocable<F>::value && is_invocable<F, T&&>::value, typename R::Return>::type folly::Future< T >::then ( F &&  func )

inline

When this Future has completed, execute func which is a function that can be called with either T&& or Try<T>&&.

Func shall return either another Future or a value.

A Future for the return type of func is returned.

Future<string> f2 = f1.thenTry([](Try<T>&&) { return string("foo"); });

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true NOTE: All three of these variations are deprecated and deprecation attributes will be added in the near future. Please prefer thenValue, thenTry or thenError rather than then and onError as they avoid ambiguity when using polymorphic lambdas.

Definition at line 1166 of file Future.h.

                    {
    return std::move(*this).thenValue(std::forward<F>(func));
  }

template<class T>

template<typename F , typename R = futures::detail::callableResult<T, F>>

std::enable_if< !is_invocable<F, T&&>::value && !is_invocable<F>::value, typename R::Return>::type folly::Future< T >::then ( F &&  func )

inline

Definition at line 1174 of file Future.h.

                    {
    return std::move(*this).thenTry(std::forward<F>(func));
  }

template<class T>

template<typename F , typename R = futures::detail::callableResult<T, F>>

std::enable_if<is_invocable<F>::value, typename R::Return>::type folly::Future< T >::then ( F &&  func )

delete

template<class T>

template<typename F , typename R = futures::detail::callableResult<T, F>>

R::Return folly::Future< T >::then ( F &&  func )

delete

template<typename T >

template<typename R , typename Caller , typename... Args>

Future< typename isFuture< R >::Inner > folly::Future< T >::then	(	R(Caller::*)(Args...)	func,
		Caller *	instance
	)

Variant where func is an member function

struct Worker { R doWork(Try<T>); }

Worker *w; Future<R> f2 = f1.thenTry(&Worker::doWork, w);

This is just sugar for

f1.thenTry(std::bind(&Worker::doWork, w));

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1053 of file Future-inl.h.

References testing::Args(), folly::gen::move, folly::pushmi::detail::t, and type.

                         {
  typedef typename std::remove_cv<typename std::remove_reference<
      typename futures::detail::ArgType<Args...>::FirstArg>::type>::type
      FirstArg;

  return std::move(*this).thenTry([instance, func](Try<T>&& t) {
    return (instance->*func)(t.template get<isTry<FirstArg>::value, Args>()...);
  });
}

template<class T>

template<typename R , typename Caller , typename... Args>

Future<typename isFuture<R>::Inner> folly::Future< T >::then ( R(Caller::*)(Args...)  func, Caller *  instance  )

delete

template<class T>

template<class Arg >

auto folly::Future< T >::then ( Executor *  x, Arg &&  arg  )

inline

Execute the callback via the given Executor. The executor doesn't stick.

Contrast

f.via(x).then(b).then(c)

with

f.then(x, b).then(c)

In the former both b and c execute via x. In the latter, only b executes via x, and c executes via the same executor (if any) that f had.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1247 of file Future.h.

                                       {
    auto oldX = this->getExecutor();
    this->setExecutor(x);

    // TODO(T29171940): thenImplementation here is ambiguous
    // as then used to be but that is better than keeping then in the public
    // API.
    using R = futures::detail::callableResult<T, Arg&&>;
    return std::move(*this)
        .thenImplementation(std::forward<Arg>(arg), R{})
        .via(oldX);
  }

template<class T>

template<class R , class Caller , class... Args>

auto folly::Future< T >::then ( Executor *  x, R(Caller::*)(Args...)  func, Caller *  instance  )

inline

Definition at line 1261 of file Future.h.

                                                                        {
    auto oldX = this->getExecutor();
    this->setExecutor(x);

    return std::move(*this).then(func, instance).via(oldX);
  }

template<class T>

template<class Arg , class... Args>

auto folly::Future< T >::then ( Executor *  x, Arg &&  arg, Args &&...  args  )

delete

template<class T >

Future< Unit > folly::Future< T >::then

(

)

Convenience method for ignoring the value and creating a Future<Unit>. Exceptions still propagate. This function is identical to .unit().

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1120 of file Future-inl.h.

References folly::gen::move, folly::T, and type.

                                {
  return std::move(*this).thenValue([](T&&) {});
}

template<class T>

Future<Unit> folly::Future< T >::then ( )

delete

template<class T >

template<class ExceptionType , class F >

Future< T > folly::Future< T >::thenError

(

F &&

func

)

Set an error continuation for this Future where the continuation can be called with a known exception type and returns a T, Future<T>, or SemiFuture<T>.

Example:

makeFuture() .thenTry([] { throw std::runtime_error("oh no!"); return 42; }) .thenError<std::runtime_error>([] (auto const& e) { LOG(INFO) << "std::runtime_error: " << e.what(); return -1; // or makeFuture<int>(-1) or makeSemiFuture<int>(-1) });

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == false
• RESULT.valid() == true

Definition at line 1092 of file Future-inl.h.

References folly::futures::detail::FutureBase< T >::getExecutor(), folly::InlineExecutor::instance(), folly::gen::move, and folly::Future< T >::via().

                                          {
  // Forward to onError but ensure that returned future carries the executor
  // Allow for applying to future with null executor while this is still
  // possible.
  auto* e = this->getExecutor();
  return std::move(*this)
      .onError([func = std::forward<F>(func)](ExceptionType& ex) mutable {
        return std::forward<F>(func)(ex);
      })
      .via(e ? e : &InlineExecutor::instance());
}

template<class T>

template<class ExceptionType , class R , class... Args>

Future<T> folly::Future< T >::thenError ( R(&)(Args...)  func )

inline

Definition at line 1361 of file Future.h.

                                             {
    return std::move(*this).template thenError<ExceptionType>(&func);
  }

template<class T >

template<class F >

Future< T > folly::Future< T >::thenError

(

F &&

func

)

Set an error continuation for this Future where the continuation can be called with exception_wrapper&& and returns a T, Future<T>, or SemiFuture<T>.

Example:

makeFuture() .thenTry([] { throw std::runtime_error("oh no!"); return 42; }) .thenError([] (exception_wrapper&& e) { LOG(INFO) << e.what(); return -1; // or makeFuture<int>(-1) or makeSemiFuture<int>(-1) });

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == false
• RESULT.valid() == true

Definition at line 1106 of file Future-inl.h.

References folly::futures::detail::FutureBase< T >::getExecutor(), folly::InlineExecutor::instance(), folly::gen::move, and folly::Future< T >::via().

                                          {
  // Forward to onError but ensure that returned future carries the executor
  // Allow for applying to future with null executor while this is still
  // possible.
  auto* e = this->getExecutor();
  return std::move(*this)
      .onError([func = std::forward<F>(func)](
                   folly::exception_wrapper&& ex) mutable {
        return std::forward<F>(func)(std::move(ex));
      })
      .via(e ? e : &InlineExecutor::instance());
}

template<class T>

template<class R , class... Args>

Future<T> folly::Future< T >::thenError ( R(&)(Args...)  func )

inline

Definition at line 1393 of file Future.h.

                                             {
    return std::move(*this).thenError(&func);
  }

template<class T>

template<class Callback , class... Callbacks>

auto folly::Future< T >::thenMulti ( Callback &&  fn, Callbacks &&...  fns  )

inline

Create a Future chain from a sequence of continuations. i.e.

f.then(a).then(b).then(c)

where f is a Future and the result of the chain is a Future<D> becomes

std::move(f).thenMulti(a, b, c);

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1825 of file Future.h.

                                                       {
    // thenMulti with two callbacks is just then(a).thenMulti(b, ...)

    // TODO(T29171940): Switch to thenImplementation here. It is ambiguous
    // as then used to be but that is better than keeping then in the public
    // API.
    using R = futures::detail::callableResult<T, decltype(fn)>;
    return std::move(*this)
        .thenImplementation(std::forward<Callback>(fn), R{})
        .thenMulti(std::forward<Callbacks>(fns)...);
  }

template<class T>

template<class Callback >

auto folly::Future< T >::thenMulti ( Callback &&  fn )

inline

Create a Future chain from a sequence of callbacks.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1849 of file Future.h.

                                   {
    // thenMulti with one callback is just a then

    // TODO(T29171940): Switch to thenImplementation here. It is ambiguous
    // as then used to be but that is better than keeping then in the public
    // API.
    using R = futures::detail::callableResult<T, decltype(fn)>;
    return std::move(*this).thenImplementation(std::forward<Callback>(fn), R{});
  }

template<class T>

template<class Callback >

auto folly::Future< T >::thenMulti ( Callback &&  fn )

inline

Definition at line 1860 of file Future.h.

                                  {
    return std::move(*this).thenMulti(std::forward<Callback>(fn));
  }

template<class T>

template<class Callback , class... Callbacks>

auto folly::Future< T >::thenMultiWithExecutor ( Executor *  x, Callback &&  fn, Callbacks &&...  fns  )

inline

Create a Future chain from a sequence of callbacks. i.e.

f.via(executor).then(a).then(b).then(c).via(oldExecutor)

where f is a Future and the result of the chain is a Future<D> becomes

std::move(f).thenMultiWithExecutor(executor, a, b, c);

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1884 of file Future.h.

                                                                           {
    // thenMultiExecutor with two callbacks is
    // via(x).then(a).thenMulti(b, ...).via(oldX)
    auto oldX = this->getExecutor();
    this->setExecutor(x);
    // TODO(T29171940): Switch to thenImplementation here. It is ambiguous
    // as then used to be but that is better than keeping then in the public
    // API.
    using R = futures::detail::callableResult<T, decltype(fn)>;
    return std::move(*this)
        .thenImplementation(std::forward<Callback>(fn), R{})
        .thenMulti(std::forward<Callbacks>(fns)...)
        .via(oldX);
  }

template<class T>

template<class Callback >

auto folly::Future< T >::thenMultiWithExecutor ( Executor *  x, Callback &&  fn  )

inline

Definition at line 1900 of file Future.h.

                                                            {
    // thenMulti with one callback is just a then with an executor
    return std::move(*this).then(x, std::forward<Callback>(fn));
  }

template<class T >

template<typename F >

Future< typename futures::detail::tryCallableResult< T, F >::value_type > folly::Future< T >::thenTry

(

F &&

func

)

When this Future has completed, execute func which is a function that can be called with Try<T>&& (often a lambda with parameter type auto&& or auto).

Func shall return either another Future or a value.

A Future for the return type of func is returned.

Future<string> f2 = std::move(f1).thenTry([](auto&& t) { ... return string("foo"); });

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == false
• RESULT.valid() == true

Definition at line 1068 of file Future-inl.h.

References f, folly::gen::move, folly::pushmi::detail::t, and folly::futures::detail::FutureBase< T >::thenImplementation().

                              {
  auto lambdaFunc = [f = std::forward<F>(func)](folly::Try<T>&& t) mutable {
    return std::forward<F>(f)(std::move(t));
  };
  using R = futures::detail::tryCallableResult<T, decltype(lambdaFunc)>;
  return this->thenImplementation(std::move(lambdaFunc), R{});
}

template<class T>

template<typename R , typename... Args>

auto folly::Future< T >::thenTry ( R(&)(Args...)  func )

inline

Definition at line 1299 of file Future.h.

                                      {
    return std::move(*this).thenTry(&func);
  }

template<class T >

template<typename F >

Future< typename futures::detail::valueCallableResult< T, F >::value_type > folly::Future< T >::thenValue

(

F &&

func

)

When this Future has completed, execute func which is a function that can be called with T&& (often a lambda with parameter type auto&& or auto).

Func shall return either another Future or a value.

A Future for the return type of func is returned.

Future<string> f2 = f1.thenValue([](auto&& v) { ... return string("foo"); });

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == false
• RESULT.valid() == true

Definition at line 1079 of file Future-inl.h.

References f, folly::gen::move, folly::pushmi::detail::t, and folly::futures::detail::FutureBase< T >::thenImplementation().

Referenced by folly::Future< T >::Future(), and folly::Future< T >::operator=().

                                {
  auto lambdaFunc = [f = std::forward<F>(func)](folly::Try<T>&& t) mutable {
    return std::forward<F>(f)(
        t.template get<
            false,
            typename futures::detail::valueCallableResult<T, F>::FirstArg>());
  };
  using R = futures::detail::tryCallableResult<T, decltype(lambdaFunc)>;
  return this->thenImplementation(std::move(lambdaFunc), R{});
}

template<class T>

template<typename R , typename... Args>

auto folly::Future< T >::thenValue ( R(&)(Args...)  func )

inline

Definition at line 1329 of file Future.h.

                                        {
    return std::move(*this).thenValue(&func);
  }

template<class T>

Future<Unit> folly::Future< T >::unit ( )

inline

Convenience method for ignoring the value and creating a Future<Unit>. Exceptions still propagate. This function is identical to parameterless .then().

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1431 of file Future.h.

                         {
    return std::move(*this).then();
  }

template<class T >

template<class F >

std::enable_if< isFuture< F >::value, Future< typename isFuture< T >::Inner > >::type folly::Future< T >::unwrap

(

)

Unwraps the case of a Future<Future<T>> instance, and returns a simple Future<T> instance.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1007 of file Future-inl.h.

References folly::gen::move.

                         {
  return std::move(*this).thenValue(
      [](Future<typename isFuture<T>::Inner> internal_future) {
        return internal_future;
      });
}

template<class T >

Future< T > folly::Future< T >::via	(	Executor *	executor,
		int8_t	priority = Executor::MID_PRI
	)

Returns a Future which will call back on the other side of executor.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == false
• RESULT.valid() == true

Definition at line 1024 of file Future-inl.h.

References testing::Args(), folly::futures::detail::FutureBase< T >::core_, folly::pushmi::executor, f, folly::getKeepAliveToken(), folly::Promise< T >::getSemiFuture(), int8_t, folly::gen::move, folly::Promise< T >::setTry(), folly::pushmi::detail::t, folly::futures::detail::FutureBase< T >::thenImplementation(), and folly::futures::detail::FutureBase< T >::throwIfInvalid().

Referenced by fizz::sm::getCertificateRequest(), folly::Future< T >::thenError(), folly::via(), and folly::window().

                                                               {
  return std::move(*this).via(getKeepAliveToken(executor), priority);
}

template<class T >

Future< T > folly::Future< T >::via	(	Executor::KeepAlive<>	executor,
		int8_t	priority = Executor::MID_PRI
	)

Definition at line 1015 of file Future-inl.h.

References folly::futures::detail::FutureBase< T >::core_, folly::pushmi::executor, folly::gen::move, and folly::futures::detail::FutureBase< T >::setExecutor().

                                                                         {
  this->setExecutor(std::move(executor), priority);

  auto newFuture = Future<T>(this->core_);
  this->core_ = nullptr;
  return newFuture;
}

template<class T>

Future<T> folly::Future< T >::via	(	Executor *	executor,
		int8_t	priority = Executor::MID_PRI
	)

Returns a Future which will call back on the other side of executor.

When practical, use the rvalue-qualified overload instead - it's faster.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == true
• RESULT.valid() == true
• when this gets fulfilled, it automatically fulfills RESULT

template<class T>

Future<T> folly::Future< T >::via	(	Executor::KeepAlive<>	executor,
		int8_t	priority = Executor::MID_PRI
	)

template<class T >

Future< T > && folly::Future< T >::wait

(

)

Blocks until this Future is complete.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == true
• &RESULT == this
• isReady() == true

Definition at line 2197 of file Future-inl.h.

References folly::gen::move, and folly::futures::detail::waitImpl().

Referenced by folly::Future< T >::get(), folly::SemiFuture< T >::getTry(), TEST(), folly::SemiFuture< T >::wait(), and folly::Future< T >::wait().

                             {
  futures::detail::waitImpl(*this);
  return *this;
}

template<class T>

Future<T>&& folly::Future< T >::wait

(

)

Blocks until this Future is complete.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == true (but the calling code can trivially move-out *this by assigning or constructing the result into a distinct object).
• &RESULT == this
• isReady() == true

template<class T >

Future< T > && folly::Future< T >::wait

(

Duration

dur

)

Blocks until this Future is complete, or dur elapses.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == true (so you may call wait(...) repeatedly)
• &RESULT == this
• isReady() will be indeterminate - may or may not be true

Definition at line 2209 of file Future-inl.h.

References folly::gen::move, folly::Future< T >::wait(), and folly::futures::detail::waitImpl().

                                         {
  futures::detail::waitImpl(*this, dur);
  return *this;
}

template<class T>

Future<T>&& folly::Future< T >::wait

(

Duration

dur

)

Blocks until this Future is complete or until dur passes.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == true (but the calling code can trivially move-out *this by assigning or constructing the result into a distinct object).
• &RESULT == this
• isReady() will be indeterminate - may or may not be true

template<class T >

Future< T > && folly::Future< T >::waitVia

(

DrivableExecutor *

e

)

Call e->drive() repeatedly until the future is fulfilled. Examples of DrivableExecutor include EventBase and ManualExecutor. Returns a reference to this Future so that you can chain calls if desired. value (moved-out), or throws the exception.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == true (does not move-out *this)
• &RESULT == this

Definition at line 2221 of file Future-inl.h.

References folly::gen::move, and folly::futures::detail::waitViaImpl().

Referenced by folly::Future< T >::getTryVia(), folly::Future< T >::getVia(), and folly::Future< T >::waitVia().

                                                   {
  futures::detail::waitViaImpl(*this, e);
  return *this;
}

template<class T>

Future<T>&& folly::Future< T >::waitVia

(

DrivableExecutor *

e

)

Overload of waitVia() for rvalue Futures

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == true (but the calling code can trivially move-out *this by assigning or constructing the result into a distinct object).
• &RESULT == this

template<class T >

Future< T > && folly::Future< T >::waitVia	(	TimedDrivableExecutor *	e,
		Duration	dur
	)

As waitVia but may return early after dur passes.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == true (does not move-out *this)
• &RESULT == this

Definition at line 2233 of file Future-inl.h.

References folly::gen::move, folly::Future< T >::waitVia(), and folly::futures::detail::waitViaImpl().

                                                                      {
  futures::detail::waitViaImpl(*this, e, dur);
  return *this;
}

template<class T>

Future<T>&& folly::Future< T >::waitVia	(	TimedDrivableExecutor *	e,
		Duration	dur
	)

Overload of waitVia() for rvalue Futures As waitVia but may return early after dur passes.

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• valid() == true (but the calling code can trivially move-out *this by assigning or constructing the result into a distinct object).
• &RESULT == this

template<class T>

Future< bool > folly::Future< T >::willEqual

(

Future< T > &

f

)

If the value in this Future is equal to the given Future, when they have both completed, the value of the resulting Future<bool> will be true. It will be false otherwise (including when one or both Futures have an exception)

Definition at line 2305 of file Future-inl.h.

References folly::collectAllSemiFuture(), folly::futures::detail::TryEquals< T >::equals(), folly::futures::detail::FutureBase< T >::hasValue(), and folly::pushmi::detail::t.

                                              {
  return collectAllSemiFuture(*this, f).toUnsafeFuture().thenValue(
      [](const std::tuple<Try<T>, Try<T>>& t) {
        if (std::get<0>(t).hasValue() && std::get<1>(t).hasValue()) {
          return futures::detail::TryEquals<T>::equals(
              std::get<0>(t), std::get<1>(t));
        } else {
          return false;
        }
      });
}

template<class T >

Future< T > folly::Future< T >::within	(	Duration	dur,
		Timekeeper *	tk = nullptr
	)

Throw FutureTimeout if this Future does not complete within the given duration from now. The optional Timekeeper is as with futures::sleep().

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1966 of file Future-inl.h.

References folly::gen::move.

                                                           {
  return std::move(*this).within(dur, FutureTimeout(), tk);
}

template<class T >

template<class E >

Future< T > folly::Future< T >::within	(	Duration	dur,
		E	exception,
		Timekeeper *	tk = nullptr
	)

Throw the given exception if this Future does not complete within the given duration from now. The optional Timekeeper is as with futures::sleep().

Preconditions:

• valid() == true (else throws FutureInvalid)

Postconditions:

• Calling code should act as if valid() == false, i.e., as if *this was moved into RESULT.
• RESULT.valid() == true

Definition at line 1972 of file Future-inl.h.

References exe, folly::futures::detail::FutureBase< T >::getExecutor(), folly::InlineExecutor::instance(), folly::futures::detail::FutureBase< T >::isReady(), and folly::gen::move.

                                                                {
  if (this->isReady()) {
    return std::move(*this);
  }

  auto* exe = this->getExecutor();
  return std::move(*this)
      .withinImplementation(dur, e, tk)
      .via(exe ? exe : &InlineExecutor::instance());
}

Friends And Related Function Documentation

template<class T>

template<class >

friend class Future

friend

Definition at line 1933 of file Future.h.

Referenced by folly::Future< T >::Future().

template<class T>

template<class FT >

void futures::detail::convertFuture ( SemiFuture< FT > &&  sf, Future< FT > &  f  )

friend

template<class T>

template<class >

friend class futures::detail::FutureBase

friend

Definition at line 1931 of file Future.h.

template<class T>

template<class >

friend class FutureSplitter

friend

Definition at line 1937 of file Future.h.

template<class T>

template<class T2 >

Future<T2> makeFuture ( Try< T2 >  )

friend

Referenced by folly::Timekeeper::at(), folly::makeFuture(), folly::reduce(), folly::unorderedReduce(), folly::via(), folly::when(), and folly::whileDo().

template<class T>

friend class Promise< T >

friend

Definition at line 1929 of file Future.h.

template<class T>

template<class >

friend class SemiFuture

friend

Definition at line 1935 of file Future.h.

template<class T>

template<class F >

Future<Unit> times ( int  n, F &&  thunk  )

friend

Repeat the given future (i.e., the computation it contains) n times.

thunk behaves like std::function<Future<T2>(void)>

Definition at line 2348 of file Future-inl.h.

Referenced by folly::window().

                                           {
  return folly::whileDo(
      [n, count = std::make_unique<std::atomic<int>>(0)]() mutable {
        return count->fetch_add(1, std::memory_order_relaxed) < n;
      },
      std::forward<F>(thunk));
}

template<class T>

template<class F >

Future<Unit> when ( bool  p, F &&  thunk  )

friend

Carry out the computation contained in the given future if the predicate holds.

thunk behaves like std::function<Future<T2>(void)>

Definition at line 2330 of file Future-inl.h.

                                     {
  return p ? std::forward<F>(thunk)().unit() : makeFuture();
}

template<class T>

template<class P , class F >

Future<Unit> whileDo ( P &&  predicate, F &&  thunk  )

friend

Carry out the computation contained in the given future if while the predicate continues to hold.

thunk behaves like std::function<Future<T2>(void)>

predicate behaves like std::function<bool(void)>

Definition at line 2335 of file Future-inl.h.

Referenced by folly::whileDo().

                                               {
  if (predicate()) {
    auto future = thunk();
    return std::move(future).thenValue(
        [predicate = std::forward<P>(predicate),
         thunk = std::forward<F>(thunk)](auto&&) mutable {
          return whileDo(std::forward<P>(predicate), std::forward<F>(thunk));
        });
  }
  return makeFuture();
}

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/fibers/FiberManagerInternal.h
• proxygen/folly/folly/futures/Future.h
• proxygen/folly/folly/futures/Future-inl.h