folly::SemiFuture< T > Class Template Reference

#include <Future-pre.h>

Inheritance diagram for folly::SemiFuture< T >:

Public Types
typedef T	value_type

Public Member Functions
	~SemiFuture ()
template<class T2 = T, typename = typename std::enable_if< !isFuture<typename std::decay<T2>::type>::value && !isSemiFuture<typename std::decay<T2>::type>::value>::type>
	SemiFuture (T2 &&val)
template<class T2 = T>
	SemiFuture (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>
	SemiFuture (in_place_t, Args &&...args)
	SemiFuture (SemiFuture< T > const &)=delete
	SemiFuture (SemiFuture< T > &&) noexcept
	SemiFuture (Future< T > &&) noexcept
SemiFuture &	operator= (SemiFuture const &)=delete
SemiFuture &	operator= (SemiFuture &&) noexcept
SemiFuture &	operator= (Future< T > &&) noexcept
T	get ()&&
T	get ()&=delete
T	get (Duration dur)&&
T	get (Duration dur)&=delete
Try< T >	getTry ()&&
Try< T >	getTry (Duration dur)&&
SemiFuture< T > &	wait ()&
SemiFuture< T > &&	wait ()&&
bool	wait (Duration dur)&&
Future< T >	via (Executor *executor, int8_t priority=Executor::MID_PRI)&&
	Returns a Future which will call back on the other side of executor. More...
Future< T >	via (Executor::KeepAlive<> executor, int8_t priority=Executor::MID_PRI)&&
template<typename F >
SemiFuture< typename futures::detail::tryCallableResult< T, F >::value_type >	defer (F &&func)&&
template<typename R , typename... Args>
auto	defer (R(&func)(Args...))&&
template<typename F >
SemiFuture< typename futures::detail::valueCallableResult< T, F >::value_type >	deferValue (F &&func)&&
template<typename R , typename... Args>
auto	deferValue (R(&func)(Args...))&&
template<class ExceptionType , class F >
SemiFuture< T >	deferError (F &&func)&&
template<class ExceptionType , class R , class... Args>
SemiFuture< T >	deferError (R(&func)(Args...))&&
template<class F >
SemiFuture< T >	deferError (F &&func)&&
template<class R , class... Args>
SemiFuture< T >	deferError (R(&func)(Args...))&&
SemiFuture< T >	within (Duration dur, Timekeeper *tk=nullptr)&&
template<class E >
SemiFuture< T >	within (Duration dur, E e, Timekeeper *tk=nullptr)&&
SemiFuture< T >	delayed (Duration dur, Timekeeper *tk=nullptr)&&
Future< T >	toUnsafeFuture ()&&

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

Private Types
using	Base = futures::detail::FutureBase< T >
using	DeferredExecutor = futures::detail::DeferredExecutor
using	TimePoint = std::chrono::system_clock::time_point
using	Core = futures::detail::Core< T >
Private Types inherited from folly::futures::detail::FutureBase< T >
typedef T	value_type
using	Core = futures::detail::Core< T >

Private Member Functions
	SemiFuture (Core *obj)
	SemiFuture (futures::detail::EmptyConstruct) noexcept
DeferredExecutor *	getDeferredExecutor () const
folly::Executor::KeepAlive< DeferredExecutor >	stealDeferredExecutor () const
SemiFuture< T > &	wait (Duration dur)&
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
static void	releaseDeferredExecutor (Core *core)
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)

Friends
class	Promise< T >
template<class >
class	futures::detail::FutureBase
template<class >
class	SemiFuture
template<class >
class	Future
folly::Executor::KeepAlive< DeferredExecutor >	futures::detail::stealDeferredExecutor (SemiFuture &)
DeferredExecutor *	futures::detail::getDeferredExecutor (SemiFuture &)
template<class T2 >
SemiFuture< T2 >	makeSemiFuture (Try< T2 >)

Additional Inherited Members
Private Attributes inherited from folly::futures::detail::FutureBase< T >
Core *	core_

Detailed Description

template<class T>
class folly::SemiFuture< T >

The interface (along with Future) 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 26 of file Future-pre.h.

Member Typedef Documentation

template<class T>

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

private

Definition at line 490 of file Future.h.

template<class T>

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

private

Definition at line 359 of file Future.h.

template<class T>

using folly::SemiFuture< T >::DeferredExecutor = futures::detail::DeferredExecutor

private

Definition at line 491 of file Future.h.

template<class T>

using folly::SemiFuture< T >::TimePoint = std::chrono::system_clock::time_point

private

Definition at line 492 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 >

folly::SemiFuture< T >::~SemiFuture

(

)

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

References folly::futures::detail::FutureBase< T >::core_.

                           {
  releaseDeferredExecutor(this->core_);
}

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::SemiFuture< T >::SemiFuture ( T2 &&  val )

inline

Construct a SemiFuture from a value (perfect forwarding)

Postconditions:

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

Definition at line 521 of file Future.h.

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

template<class T>

template<class T2 = T>

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

inline

Construct a (logical) SemiFuture-of-void.

Postconditions:

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

Definition at line 531 of file Future.h.

References testing::Args(), folly::T, type, and folly::value().

      : Base(p) {}

template<class T>

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

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

inlineexplicit

Construct a SemiFuture 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 548 of file Future.h.

References testing::Args(), folly::pushmi::operators::defer, folly::pushmi::executor, int8_t, folly::Executor::MID_PRI, folly::pushmi::__adl::noexcept(), folly::netops::poll(), value, folly::via(), and folly::detail::distributed_mutex::wait().

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

template<class T>

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

delete

template<class T >

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

noexcept

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

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

template<class T >

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

noexcept

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

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

    : futures::detail::FutureBase<T>(std::move(other)) {
  // SemiFuture should not have an executor on construction
  if (this->core_) {
    this->setExecutor(nullptr);
  }
}

template<class T>

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

inlineexplicitprivate

Definition at line 897 of file Future.h.

: Base(obj) {}

template<class T>

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

inlineexplicitprivatenoexcept

Definition at line 899 of file Future.h.

References folly::futures::detail::getDeferredExecutor(), folly::futures::detail::stealDeferredExecutor(), and folly::detail::distributed_mutex::wait().

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

Member Function Documentation

template<class T >

template<typename F >

SemiFuture< typename futures::detail::tryCallableResult< T, F >::value_type > folly::SemiFuture< T >::defer

(

F &&

func

)

Defer work to run on the consumer of the future. Function must take a Try as a parameter. This work will be run either on an executor that the caller sets on the SemiFuture, or inline with the call to .get().

NB: This is a custom method because boost-blocking executors is a special-case for work deferral in folly. With more general boost-blocking support all executors would boost block and we would simply use some form of driveable executor here.

Preconditions:

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

Postconditions:

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

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

References folly::futures::detail::FutureBase< T >::core_, folly::futures::detail::DeferredExecutor::create(), folly::futures::detail::getDeferredExecutor(), folly::gen::move, folly::futures::detail::FutureBase< T >::setExecutor(), and folly::futures::detail::Core< T >::setExecutor().

                                {
  DeferredExecutor* deferredExecutor = getDeferredExecutor();
  if (!deferredExecutor) {
    auto newDeferredExecutor = DeferredExecutor::create();
    deferredExecutor = newDeferredExecutor.get();
    this->setExecutor(std::move(newDeferredExecutor));
  }

  auto sf = Future<T>(this->core_).thenTry(std::forward<F>(func)).semi();
  this->core_ = nullptr;
  // Carry deferred executor through chain as constructor from Future will
  // nullify it
  sf.setExecutor(deferredExecutor);
  return sf;
}

template<class T>

template<typename R , typename... Args>

auto folly::SemiFuture< T >::defer ( R(&)(Args...)  func )

inline

Definition at line 701 of file Future.h.

References testing::Args(), and folly::gen::move.

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

template<class T >

template<class ExceptionType , class F >

SemiFuture< T > folly::SemiFuture< T >::deferError

(

F &&

func

)

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

Example:

makeSemiFuture()
  .defer([] {
    throw std::runtime_error("oh no!");
    return 42;
  })
  .deferError<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 913 of file Future-inl.h.

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

                                                   {
  return std::move(*this).defer(
      [func = std::forward<F>(func)](Try<T>&& t) mutable {
        if (auto e = t.template tryGetExceptionObject<ExceptionType>()) {
          return makeSemiFutureWith(
              [&]() mutable { return std::forward<F>(func)(*e); });
        } else {
          return makeSemiFuture<T>(std::move(t));
        }
      });
}

template<class T>

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

SemiFuture<T> folly::SemiFuture< T >::deferError ( R(&)(Args...)  func )

inline

Definition at line 754 of file Future.h.

References testing::Args(), and folly::gen::move.

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

template<class T >

template<class F >

SemiFuture< T > folly::SemiFuture< T >::deferError

(

F &&

func

)

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

Example:

makeSemiFuture() .defer([] { throw std::runtime_error("oh no!"); return 42; }) .deferError([] (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 927 of file Future-inl.h.

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

                                                   {
  return std::move(*this).defer(
      [func = std::forward<F>(func)](Try<T> t) mutable {
        if (t.hasException()) {
          return makeSemiFutureWith([&]() mutable {
            return std::forward<F>(func)(std::move(t.exception()));
          });
        } else {
          return makeSemiFuture<T>(std::move(t));
        }
      });
}

template<class T>

template<class R , class... Args>

SemiFuture<T> folly::SemiFuture< T >::deferError ( R(&)(Args...)  func )

inline

Definition at line 786 of file Future.h.

References folly::gen::move.

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

template<class T >

template<typename F >

SemiFuture< typename futures::detail::valueCallableResult< T, F >::value_type > folly::SemiFuture< T >::deferValue

(

F &&

func

)

Defer for functions taking a T rather than a Try<T>.

Preconditions:

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

Postconditions:

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

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

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

                                     {
  return std::move(*this).defer([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>());
  });
}

template<class T>

template<typename R , typename... Args>

auto folly::SemiFuture< T >::deferValue ( R(&)(Args...)  func )

inline

Definition at line 720 of file Future.h.

References testing::Args(), and folly::gen::move.

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

template<typename T >

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

Delay the completion of this SemiFuture 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 941 of file Future-inl.h.

References folly::collectAllSemiFuture(), folly::gen::move, folly::futures::sleep(), and folly::pushmi::detail::t.

                                                                    {
  return collectAllSemiFuture(*this, futures::sleep(dur, tk))
      .toUnsafeFuture()
      .thenValue([](std::tuple<Try<T>, Try<Unit>> tup) {
        Try<T>& t = std::get<0>(tup);
        return makeFuture<T>(std::move(t));
      });
}

template<class T >

T folly::SemiFuture< T >::get

(

)

Blocks until the promise is fulfilled, either by value (which is returned) or exception (which is thrown).

Preconditions:

• valid() == true (else throws FutureInvalid)
• must not have a continuation, e.g., via .thenValue() or similar

Postconditions:

• valid() == false

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

References folly::gen::move.

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

template<class T>

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

delete

template<class T >

T folly::SemiFuture< T >::get

(

Duration

dur

)

Blocks until the semifuture 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 2172 of file Future-inl.h.

References folly::gen::move.

                                    {
  return std::move(*this).getTry(dur).value();
}

template<class T>

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

delete

template<class T >

SemiFuture< T >::DeferredExecutor * folly::SemiFuture< T >::getDeferredExecutor ( ) const

private

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

References folly::pushmi::executor, and folly::futures::detail::FutureBase< T >::getExecutor().

Referenced by folly::futures::detail::getDeferredExecutor().

          {
  if (auto executor = this->getExecutor()) {
    assert(dynamic_cast<DeferredExecutor*>(executor) != nullptr);
    return static_cast<DeferredExecutor*>(executor);
  }
  return nullptr;
}

template<class T >

Try< T > folly::SemiFuture< T >::getTry

(

)

Blocks until the future is fulfilled. Returns the Try of the result (moved-out).

Preconditions:

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

Postconditions:

• valid() == false

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

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

                                {
  wait();
  auto future = folly::Future<T>(this->core_);
  this->core_ = nullptr;
  return std::move(std::move(future).getTry());
}

template<class T >

Try< T > folly::SemiFuture< T >::getTry

(

Duration

dur

)

Blocks until the future is fulfilled, or until dur elapses. Returns the Try of the result (moved-out), or throws FutureTimeout exception.

Preconditions:

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

Postconditions:

• valid() == false

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

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

                                            {
  wait(dur);
  auto future = folly::Future<T>(this->core_);
  this->core_ = nullptr;

  if (!future.isReady()) {
    throw_exception<FutureTimeout>();
  }
  return std::move(std::move(future).getTry());
}

template<class T >

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

static

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

Postcondition:

• RESULT.valid() == false

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

Referenced by TEST().

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

template<class T>

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

delete

template<class T >

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

noexcept

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

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

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

template<class T >

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

noexcept

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

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

                                                                  {
  releaseDeferredExecutor(this->core_);
  this->assign(std::move(other));
  // SemiFuture should not have an executor on construction
  if (this->core_) {
    this->setExecutor(nullptr);
  }
  return *this;
}

template<class T >

void folly::SemiFuture< T >::releaseDeferredExecutor ( Core *  core )

staticprivate

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

References folly::futures::detail::FutureBase< T >::detach(), folly::pushmi::executor, folly::futures::detail::Core< T >::getExecutor(), and folly::futures::detail::Core< T >::setExecutor().

                                                      {
  if (!core) {
    return;
  }
  if (auto executor = core->getExecutor()) {
    assert(dynamic_cast<DeferredExecutor*>(executor) != nullptr);
    static_cast<DeferredExecutor*>(executor)->detach();
    core->setExecutor(nullptr);
  }
}

template<class T >

folly::Executor::KeepAlive< typename SemiFuture< T >::DeferredExecutor > folly::SemiFuture< T >::stealDeferredExecutor ( ) const

private

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

References folly::futures::detail::FutureBase< T >::core_, folly::pushmi::executor, folly::futures::detail::FutureBase< T >::getExecutor(), folly::getKeepAliveToken(), and folly::futures::detail::Core< T >::setExecutor().

Referenced by folly::futures::detail::stealDeferredExecutor().

                                           {
  if (auto executor = this->getExecutor()) {
    assert(dynamic_cast<DeferredExecutor*>(executor) != nullptr);
    auto executorKeepAlive =
        folly::getKeepAliveToken(static_cast<DeferredExecutor*>(executor));
    this->core_->setExecutor(nullptr);
    return executorKeepAlive;
  }
  return {};
}

template<class T >

Future< T > folly::SemiFuture< T >::toUnsafeFuture

(

)

Returns a future that completes inline, as if the future had no executor. Intended for porting legacy code without behavioral change, and for rare cases where this is really the intended behavior. Future is unsafe in the sense that the executor it completes on is non-deterministic in the standard case. For new code, or to update code that temporarily uses this, please use via and pass a meaningful executor.

Preconditions:

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

Postconditions:

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

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

References folly::InlineExecutor::instance(), and folly::gen::move.

                                           {
  return std::move(*this).via(&InlineExecutor::instance());
}

template<class T >

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

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

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

References folly::pushmi::executor, folly::getKeepAliveToken(), and folly::gen::move.

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

template<class T >

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

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

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

                        {
  if (!executor) {
    throw_exception<FutureNoExecutor>();
  }

  if (auto deferredExecutor = getDeferredExecutor()) {
    deferredExecutor->setExecutor(executor.copy());
  }

  auto newFuture = Future<T>(this->core_);
  this->core_ = nullptr;
  newFuture.setExecutor(std::move(executor), priority);

  return newFuture;
}

template<class T >

SemiFuture< T > && folly::SemiFuture< T >::wait

(

)

Blocks the caller's thread until this Future isReady(), i.e., until the asynchronous producer has stored a result or exception.

Preconditions:

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

Postconditions:

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

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

References folly::futures::detail::WaitExecutor::create(), folly::futures::detail::FutureBase< T >::detach(), folly::futures::detail::getDeferredExecutor(), folly::Promise< T >::getSemiFuture(), folly::gen::move, folly::futures::detail::FutureBase< T >::setCallback_(), folly::Future< T >::wait(), and folly::futures::detail::waitImpl().

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

                                     {
  if (auto deferredExecutor = getDeferredExecutor()) {
    // Make sure that the last callback in the future chain will be run on the
    // WaitExecutor.
    Promise<T> promise;
    auto ret = promise.getSemiFuture();
    setCallback_(
        [p = std::move(promise)](auto&& r) mutable { p.setTry(std::move(r)); });
    auto waitExecutor = futures::detail::WaitExecutor::create();
    deferredExecutor->setExecutor(waitExecutor.copy());
    while (!ret.isReady()) {
      waitExecutor->drive();
    }
    waitExecutor->detach();
    this->detach();
    *this = std::move(ret);
  } else {
    futures::detail::waitImpl(*this);
  }
  return *this;
}

template<class T>

SemiFuture<T>&& folly::SemiFuture< T >::wait

(

)

Blocks the caller's thread until this Future isReady(), i.e., until the asynchronous producer has stored a result or exception.

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 >

bool folly::SemiFuture< T >::wait

(

Duration

dur

)

Blocks until the future is fulfilled, or dur elapses. Returns true if the future was fulfilled.

Preconditions:

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

Postconditions:

• valid() == false

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

References folly::futures::detail::WaitExecutor::create(), folly::futures::detail::FutureBase< T >::detach(), folly::futures::detail::getDeferredExecutor(), folly::Promise< T >::getSemiFuture(), folly::gen::move, now(), folly::futures::detail::FutureBase< T >::setCallback_(), folly::SemiFuture< T >::wait(), and folly::futures::detail::waitImpl().

                                                 {
  if (auto deferredExecutor = getDeferredExecutor()) {
    // Make sure that the last callback in the future chain will be run on the
    // WaitExecutor.
    Promise<T> promise;
    auto ret = promise.getSemiFuture();
    setCallback_(
        [p = std::move(promise)](auto&& r) mutable { p.setTry(std::move(r)); });
    auto waitExecutor = futures::detail::WaitExecutor::create();
    auto deadline = futures::detail::WaitExecutor::Clock::now() + dur;
    deferredExecutor->setExecutor(waitExecutor.copy());
    while (!ret.isReady()) {
      if (!waitExecutor->driveUntil(deadline)) {
        break;
      }
    }
    waitExecutor->detach();
    this->detach();
    *this = std::move(ret);
  } else {
    futures::detail::waitImpl(*this, dur);
  }
  return *this;
}

template<class T>

SemiFuture<T>& folly::SemiFuture< T >::wait ( Duration  dur )

private

Blocks until the future is fulfilled, or dur elapses.

Preconditions:

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

Postconditions:

• valid() == true
• &RESULT == this
• isReady() will be indeterminate - may or may not be true

template<class T>

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

inline

Definition at line 790 of file Future.h.

References folly::gen::move.

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

template<class T>

template<class E >

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

inline

Definition at line 795 of file Future.h.

References folly::coro::co_viaIfAsync(), folly::gen::move, promise_, and folly::value().

                                                                       {
    return this->isReady() ? std::move(*this)
                           : std::move(*this).withinImplementation(dur, e, tk);
  }

Friends And Related Function Documentation

template<class T>

template<class >

friend class Future

friend

Definition at line 885 of file Future.h.

template<class T>

template<class >

friend class futures::detail::FutureBase

friend

Definition at line 881 of file Future.h.

template<class T>

DeferredExecutor* futures::detail::getDeferredExecutor ( SemiFuture< T > &  )

friend

template<class T>

folly::Executor::KeepAlive<DeferredExecutor> futures::detail::stealDeferredExecutor ( SemiFuture< T > &  )

friend

template<class T>

template<class T2 >

SemiFuture<T2> makeSemiFuture ( Try< T2 >  )

friend

template<class T>

friend class Promise< T >

friend

Definition at line 879 of file Future.h.

template<class T>

template<class >

friend class SemiFuture

friend

Definition at line 883 of file Future.h.

---

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

• proxygen/folly/folly/futures/Future-pre.h
• proxygen/folly/folly/futures/Future.h
• proxygen/folly/folly/futures/Future-inl.h