folly::futures::detail::FutureBase< T > Class Template Reference

#include <Future.h>

Inheritance diagram for folly::futures::detail::FutureBase< 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>
	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

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

Protected Member Functions
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 Protected Member Functions
template<typename Self >
static decltype(auto)	getCoreImpl (Self &self)
template<typename Self >
static decltype(auto)	getCoreTryChecked (Self &self)

Protected Attributes
Core *	core_

Friends
class	Promise< T >
template<class >
class	SemiFuture
template<class >
class	Future

Detailed Description

template<class T>
class folly::futures::detail::FutureBase< T >

Definition at line 115 of file Future.h.

Member Typedef Documentation

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 , typename >

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

(

T2 &&

val

)

Construct from a value (perfect forwarding)

Postconditions:

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

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

    : core_(Core::make(Try<T>(std::forward<T2>(val)))) {}

template<class T >

template<typename T2 >

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

(

typename std::enable_if< std::is_same< Unit, T2 >::value >::type *

)

Construct a (logical) FutureBase-of-void.

Postconditions:

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

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

References testing::Args(), folly::T, type, and folly::futures::detail::FutureBase< T >::value().

    : core_(Core::make(Try<T>(T()))) {}

template<class T >

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

folly::futures::detail::FutureBase< T >::FutureBase ( in_place_t  , Args &&...  args  )

explicit

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

    : core_(Core::make(in_place, std::forward<Args>(args)...)) {}

template<class T >

folly::futures::detail::FutureBase< T >::FutureBase ( FutureBase< T > const &  )

delete

template<class T >

folly::futures::detail::FutureBase< T >::FutureBase ( SemiFuture< T > &&  other )

noexcept

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

                                                        : core_(other.core_) {
  other.core_ = nullptr;
}

template<class T >

folly::futures::detail::FutureBase< T >::FutureBase ( Future< T > &&  other )

noexcept

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

                                                    : core_(other.core_) {
  other.core_ = nullptr;
}

template<class T >

folly::futures::detail::FutureBase< T >::FutureBase ( Future< T > const &  )

delete

template<class T >

folly::futures::detail::FutureBase< T >::FutureBase ( SemiFuture< T > const &  )

delete

template<class T >

folly::futures::detail::FutureBase< T >::~FutureBase

(

)

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

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

                           {
  detach();
}

template<class T >

folly::futures::detail::FutureBase< T >::FutureBase ( Core *  obj )

inlineexplicitprotected

Definition at line 401 of file Future.h.

References folly::pushmi::__adl::noexcept().

: core_(obj) {}

template<class T >

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

explicitprotectednoexcept

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

    : core_(nullptr) {}

Member Function Documentation

template<class T >

void folly::futures::detail::FutureBase< T >::assign ( FutureBase< T > &&  other )

protectednoexcept

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

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

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

                                                         {
  detach();
  core_ = exchange(other.core_, nullptr);
}

template<class T >

void folly::futures::detail::FutureBase< T >::cancel ( )

inline

Raises a FutureCancellation interrupt. See raise(exception_wrapper) for details.

Definition at line 343 of file Future.h.

                {
    raise(FutureCancellation());
  }

template<class T >

void folly::futures::detail::FutureBase< T >::detach ( )

protected

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

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

Referenced by folly::futures::detail::FutureBase< T >::assign(), folly::SemiFuture< T >::releaseDeferredExecutor(), folly::SemiFuture< T >::wait(), and folly::futures::detail::FutureBase< T >::~FutureBase().

                           {
  if (core_) {
    core_->detachFuture();
    core_ = nullptr;
  }
}

template<class T >

Core& folly::futures::detail::FutureBase< T >::getCore ( )

inlineprotected

Definition at line 366 of file Future.h.

Referenced by folly::futures::detail::chainExecutor(), folly::futures::detail::FutureBase< T >::isReady(), folly::Future< T >::onError(), folly::futures::detail::FutureBase< T >::poll(), folly::futures::detail::FutureBase< T >::raise(), folly::futures::detail::FutureBase< T >::setCallback_(), and folly::futures::detail::FutureBase< T >::thenImplementation().

                  {
    return getCoreImpl(*this);
  }

template<class T >

Core const& folly::futures::detail::FutureBase< T >::getCore ( ) const

inlineprotected

Definition at line 369 of file Future.h.

                              {
    return getCoreImpl(*this);
  }

template<class T >

template<typename Self >

static decltype(auto) folly::futures::detail::FutureBase< T >::getCoreImpl ( Self &  self )

inlinestaticprotected

Definition at line 374 of file Future.h.

                                                {
    if (!self.core_) {
      throw_exception<FutureInvalid>();
    }
    return *self.core_;
  }

template<class T >

Try<T>& folly::futures::detail::FutureBase< T >::getCoreTryChecked ( )

inlineprotected

Definition at line 381 of file Future.h.

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

                              {
    return getCoreTryChecked(*this);
  }

template<class T >

Try<T> const& folly::futures::detail::FutureBase< T >::getCoreTryChecked ( ) const

inlineprotected

Definition at line 384 of file Future.h.

                                          {
    return getCoreTryChecked(*this);
  }

template<class T >

template<typename Self >

static decltype(auto) folly::futures::detail::FutureBase< T >::getCoreTryChecked ( Self &  self )

inlinestaticprotected

Definition at line 389 of file Future.h.

                                                      {
    auto& core = self.getCore();
    if (!core.hasResult()) {
      throw_exception<FutureNotReady>();
    }
    return core.getTry();
  }

template<class T >

Executor* folly::futures::detail::FutureBase< T >::getExecutor ( ) const

inlineprotected

Definition at line 412 of file Future.h.

Referenced by folly::futures::detail::chainExecutor(), folly::futures::detail::convertFuture(), folly::Future< T >::delayed(), folly::SemiFuture< T >::getDeferredExecutor(), folly::FutureSplitter< T >::getExecutorFrom(), folly::SemiFuture< T >::stealDeferredExecutor(), folly::Future< T >::thenError(), folly::futures::detail::FutureBase< T >::thenImplementation(), and folly::Future< T >::within().

                                {
    return getCore().getExecutor();
  }

template<class T >

int8_t folly::futures::detail::FutureBase< T >::getPriority ( ) const

inline

Definition at line 348 of file Future.h.

                             {
    return getCore().getPriority();
  }

template<class T >

bool folly::futures::detail::FutureBase< T >::hasException

(

)

const

True if the result is an exception (not a value) on a future for which isReady returns true.

Equivalent to result().hasException()

Preconditions:

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

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

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

                                       {
  return result().hasException();
}

template<class T >

bool folly::futures::detail::FutureBase< T >::hasValue

(

)

const

True if the result is a value (not an exception) on a future for which isReady returns true.

Equivalent to result().hasValue()

Preconditions:

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

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

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

Referenced by fizz::server::test::ServerProtocolTest::getActions(), and folly::Future< T >::willEqual().

                                   {
  return result().hasValue();
}

template<class T >

bool folly::futures::detail::FutureBase< T >::isReady

(

)

const

True when the result (or exception) is ready; see value(), result(), etc.

Preconditions:

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

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

References folly::futures::detail::FutureBase< T >::getCore(), and folly::futures::detail::Core< T >::hasResult().

Referenced by folly::Future< T >::getTryVia(), folly::Future< T >::getVia(), folly::makePromiseContract(), TEST(), folly::futures::detail::waitViaImpl(), and folly::Future< T >::within().

                                  {
  return getCore().hasResult();
}

template<class T >

Optional< Try< T > > folly::futures::detail::FutureBase< T >::poll

(

)

Returns either an Optional holding the result or an empty Optional depending on whether or not (respectively) the promise has been fulfilled (i.e., isReady() == true).

Preconditions:

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

Postconditions:

• valid() == true (note however that this moves-out the result when it returns a populated Try<T>, which effects any subsequent use of that result, e.g., poll(), result(), value(), get(), etc.)

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

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

                                     {
  auto& core = getCore();
  return core.hasResult() ? Optional<Try<T>>(std::move(core.getTry()))
                          : Optional<Try<T>>();
}

template<class T >

void folly::futures::detail::FutureBase< T >::raise

(

exception_wrapper

interrupt

)

Provides a threadsafe back-channel so the consumer's thread can send an interrupt-object to the producer's thread.

If the promise-holder registers an interrupt-handler and consumer thread raises an interrupt early enough (details below), the promise-holder will typically halt its work, fulfilling the future with an exception or some special non-exception value.

However this interrupt request is voluntary, asynchronous, & advisory:

• Voluntary: the producer will see the interrupt only if the producer uses a Promise object and registers an interrupt-handler; see Promise::setInterruptHandler().
• Asynchronous: the producer will see the interrupt only if raise() is called before (or possibly shortly after) the producer is done producing its result, which is asynchronous with respect to the call to raise().
• Advisory: the producer's interrupt-handler can do whatever it wants, including ignore the interrupt or perform some action other than halting its producer-work.

Guidelines:

• It is ideal if the promise-holder can both halt its work and fulfill the promise early, typically with the same exception that was delivered to the promise-holder in the form of an interrupt.
• If the promise-holder does not do this, and if it holds the promise alive for a long time, then the whole continuation chain will not be invoked and the whole future chain will be kept alive for that long time as well.
• It is also ideal if the promise-holder can invalidate the promise.
• The promise-holder must also track whether it has set a result in the interrupt handler so that it does not attempt to do so outside the interrupt handler, and must track whether it has set a result in its normal flow so that it does not attempt to do so in the interrupt handler, since setting a result twice is an error. Because the interrupt handler can be invoked in some other thread, this tracking may have to be done with some form of concurrency control.

Preconditions:

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

Postconditions:

• has no visible effect if raise() was previously called on this or any other Future/SemiFuture that uses the same shared state as this.
• has no visible effect if the producer never (either in the past or in the future) registers an interrupt-handler.
• has no visible effect if the producer fulfills its promise (sets the result) before (or possibly also shortly after) receiving the interrupt.
• otherwise the promise-holder's interrupt-handler is called, passing the exception (within an exception_wrapper).

The specific thread used to invoke the producer's interrupt-handler (if it is called at all) depends on timing:

• if the interrupt-handler is registered prior to raise() (or possibly concurrently within the call to raise()), the interrupt-handler will be executed using this current thread within the call to raise().
• if the interrupt-handler is registered after raise() (and possibly concurrently within the call to raise()), the interrupt-handler will be executed using the producer's thread within the call to Promise::setInterruptHandler().

Synchronizes between raise() (in the consumer's thread) and Promise::setInterruptHandler() (in the producer's thread).

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

References folly::futures::detail::FutureBase< T >::getCore(), folly::gen::move, and folly::futures::detail::Core< T >::raise().

                                                     {
  getCore().raise(std::move(exception));
}

template<class T >

template<class E >

void folly::futures::detail::FutureBase< T >::raise ( E &&  exception )

inline

Raises the specified exception-interrupt. See raise(exception_wrapper) for details.

Definition at line 336 of file Future.h.

References type.

                            {
    raise(make_exception_wrapper<typename std::remove_reference<E>::type>(
        std::forward<E>(exception)));
  }

template<class T >

Try< T > && folly::futures::detail::FutureBase< T >::result

(

)

Returns a reference to the result's Try if it is ready, with a reference category and const-qualification like those of the future.

Does not wait(); see get() for that.

Preconditions:

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

Postconditions:

• This call does not mutate the future's result.
• However calling code may mutate that result (including moving it out by move-constructing or move-assigning another result from it), for example, via the & or the && overloads or via casts.

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

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

Referenced by folly::collect(), folly::collectN(), folly::Future< T >::getTry(), folly::Future< T >::getTryVia(), folly::futures::detail::FutureBase< T >::hasException(), folly::futures::detail::FutureBase< T >::hasValue(), folly::futures::detail::FutureBase< T >::result(), and folly::futures::detail::FutureBase< T >::value().

                                {
  return getCoreTryChecked();
}

template<class T >

Try< T > const && folly::futures::detail::FutureBase< T >::result

(

)

const

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

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

                                           {
  return getCoreTryChecked();
}

template<class T >

Try<T>&& folly::futures::detail::FutureBase< T >::result

(

)

template<class T >

Try<T> const&& folly::futures::detail::FutureBase< T >::result

(

)

const

template<class T >

template<class F >

void folly::futures::detail::FutureBase< T >::setCallback_

(

F &&

func

)

This is not the method you're looking for.

This needs to be public because it's used by make* and when*, and it's not worth listing all those and their fancy template signatures as friends. But it's not for public consumption.

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

References folly::futures::detail::FutureBase< T >::getCore(), folly::RequestContext::saveContext(), folly::futures::detail::Core< T >::setCallback(), and folly::futures::detail::FutureBase< T >::throwIfContinued().

Referenced by folly::futures::detail::chainExecutor(), folly::collectN(), folly::Future< T >::onError(), folly::Future< T >::onTimeout(), folly::futures::detail::FutureBase< T >::thenImplementation(), and folly::SemiFuture< T >::wait().

                                         {
  throwIfContinued();
  getCore().setCallback(std::forward<F>(func), RequestContext::saveContext());
}

template<class T >

template<class F >

void folly::futures::detail::FutureBase< T >::setCallback_	(	F &&	func,
		std::shared_ptr< folly::RequestContext >	context
	)

template<class T >

void folly::futures::detail::FutureBase< T >::setExecutor ( Executor *  x, int8_t  priority = Executor::MID_PRI  )

inlineprotected

Definition at line 420 of file Future.h.

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

                                                                   {
    getCore().setExecutor(x, priority);
  }

template<class T >

void folly::futures::detail::FutureBase< T >::setExecutor ( Executor::KeepAlive<>  x, int8_t  priority = Executor::MID_PRI  )

inlineprotected

Definition at line 424 of file Future.h.

References folly::futures::detail::convertFuture(), f, folly::futures::detail::getDeferredExecutor(), folly::gen::move, folly::futures::detail::stealDeferredExecutor(), and type.

                                         {
    getCore().setExecutor(std::move(x), priority);
  }

template<class T >

template<typename F , typename R >

std::enable_if< R::ReturnsFuture::value, typename R::Return >::type folly::futures::detail::FutureBase< T >::thenImplementation ( F &&  func, R    )

protected

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

References B, folly::futures::detail::FutureBase< T >::core_, folly::Promise< T >::core_, f, folly::futures::detail::FutureBase< T >::getCore(), folly::futures::detail::FutureBase< T >::getExecutor(), folly::Promise< T >::getSemiFuture(), folly::futures::detail::detail_msvc_15_7_workaround::invoke(), folly::futures::detail::makeCoreCallbackState(), folly::makeTryWith(), folly::gen::move, folly::futures::detail::FutureBase< T >::setCallback_(), folly::pushmi::detail::t, and value.

Referenced by folly::futures::detail::chainExecutor(), folly::Future< T >::thenTry(), folly::Future< T >::thenValue(), folly::Future< T >::via(), and folly::futures::detail::FutureBase< T >::withinImplementation().

                                             {
  static_assert(
      R::Arg::ArgsSize::value <= 1, "Then must take zero/one argument");
  typedef typename R::ReturnsFuture::Inner B;

  Promise<B> p;
  p.core_->setInterruptHandlerNoLock(this->getCore().getInterruptHandler());

  // grab the Future now before we lose our handle on the Promise
  auto sf = p.getSemiFuture();
  sf.setExecutor(this->getExecutor());
  auto f = Future<B>(sf.core_);
  sf.core_ = nullptr;

  /* This is a bit tricky.

     We can't just close over *this in case this Future gets moved. So we
     make a new dummy Future. We could figure out something more
     sophisticated that avoids making a new Future object when it can, as an
     optimization. But this is correct.

     core_ can't be moved, it is explicitly disallowed (as is copying). But
     if there's ever a reason to allow it, this is one place that makes that
     assumption and would need to be fixed. We use a standard shared pointer
     for core_ (by copying it in), which means in essence obj holds a shared
     pointer to itself.  But this shouldn't leak because Promise will not
     outlive the continuation, because Promise will setException() with a
     broken Promise if it is destructed before completed. We could use a
     weak pointer but it would have to be converted to a shared pointer when
     func is executed (because the Future returned by func may possibly
     persist beyond the callback, if it gets moved), and so it is an
     optimization to just make it shared from the get-go.

     Two subtle but important points about this design. futures::detail::Core
     has no back pointers to Future or Promise, so if Future or Promise get
     moved (and they will be moved in performant code) we don't have to do
     anything fancy. And because we store the continuation in the
     futures::detail::Core, not in the Future, we can execute the continuation
     even after the Future has gone out of scope. This is an intentional design
     decision. It is likely we will want to be able to cancel a continuation
     in some circumstances, but I think it should be explicit not implicit
     in the destruction of the Future used to create it.
     */
  this->setCallback_(
      [state = futures::detail::makeCoreCallbackState(
           std::move(p), std::forward<F>(func))](Try<T>&& t) mutable {
        if (!R::Arg::isTry() && t.hasException()) {
          state.setException(std::move(t.exception()));
        } else {
          state.setTry(makeTryWith([&] {
            return detail_msvc_15_7_workaround::invoke(R{}, state, t);
          }));
        }
      });
  return f;
}

template<class T >

template<typename F , typename R >

std::enable_if<R::ReturnsFuture::value, typename R::Return>::type folly::futures::detail::FutureBase< T >::thenImplementation ( F &&  func, R    )

protected

template<class T >

void folly::futures::detail::FutureBase< T >::throwIfContinued ( ) const

protected

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

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

Referenced by folly::futures::detail::FutureBase< T >::setCallback_().

                                           {
  if (!core_ || core_->hasCallback()) {
    throw_exception<FutureAlreadyContinued>();
  }
}

template<class T >

void folly::futures::detail::FutureBase< T >::throwIfInvalid ( ) const

protected

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

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

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

                                         {
  if (!core_) {
    throw_exception<FutureInvalid>();
  }
}

template<class T >

bool folly::futures::detail::FutureBase< T >::valid ( ) const

inlinenoexcept

true if this has a shared state; false if this has been either moved-out or created without a shared state.

Definition at line 162 of file Future.h.

References context, folly::netops::poll(), and folly::value().

                              {
    return core_ != nullptr;
  }

template<class T >

T && folly::futures::detail::FutureBase< T >::value

(

)

Returns a reference to the result value if it is ready, with a reference category and const-qualification like those of the future.

Does not wait(); see get() for that.

Preconditions:

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

Postconditions:

• If an exception has been captured (i.e., if hasException() == true), throws that exception.
• This call does not mutate the future's value.
• However calling code may mutate that value (including moving it out by move-constructing or move-assigning another value from it), for example, via the & or the && overloads or via casts.

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

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

Referenced by BENCHMARK_RELATIVE(), folly::collectN(), folly::Future< T >::Future(), folly::futures::detail::FutureBase< T >::FutureBase(), folly::Future< T >::getVia(), folly::makeFuture(), folly::makeFutureWith(), folly::makeSemiFuture(), folly::makeSemiFutureWith(), folly::Future< T >::onError(), folly::Future< T >::onTimeout(), folly::Future< T >::operator=(), folly::reduce(), TEST(), folly::futures::detail::FutureBase< T >::value(), and folly::futures::detail::waitImpl().

                          {
  return result().value();
}

template<class T >

T const && folly::futures::detail::FutureBase< T >::value

(

)

const

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

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

                                     {
  return result().value();
}

template<class T >

T&& folly::futures::detail::FutureBase< T >::value

(

)

template<class T >

T const&& folly::futures::detail::FutureBase< T >::value

(

)

const

template<class T >

template<typename E >

SemiFuture< T > folly::futures::detail::FutureBase< T >::withinImplementation ( Duration  dur, E  e, Timekeeper *  tk  )

protected

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

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

                                                                        {
  struct Context {
    explicit Context(E ex) : exception(std::move(ex)) {}
    E exception;
    Future<Unit> thisFuture;
    Promise<T> promise;
    std::atomic<bool> token{false};
  };

  std::shared_ptr<Timekeeper> tks;
  if (LIKELY(!tk)) {
    tks = folly::detail::getTimekeeperSingleton();
    tk = tks.get();
  }

  if (UNLIKELY(!tk)) {
    return makeSemiFuture<T>(FutureNoTimekeeper());
  }

  auto ctx = std::make_shared<Context>(std::move(e));

  auto f = [ctx](Try<T>&& t) {
    if (!ctx->token.exchange(true, std::memory_order_relaxed)) {
      ctx->promise.setTry(std::move(t));
    }
  };
  using R = futures::detail::callableResult<T, decltype(f)>;
  ctx->thisFuture = this->thenImplementation(std::move(f), R{});

  // Properly propagate interrupt values through futures chained after within()
  ctx->promise.setInterruptHandler(
      [weakCtx = to_weak_ptr(ctx)](const exception_wrapper& ex) {
        if (auto lockedCtx = weakCtx.lock()) {
          lockedCtx->thisFuture.raise(ex);
        }
      });

  // Have time keeper use a weak ptr to hold ctx,
  // so that ctx can be deallocated as soon as the future job finished.
  tk->after(dur).thenTry([weakCtx = to_weak_ptr(ctx)](Try<Unit>&& t) mutable {
    auto lockedCtx = weakCtx.lock();
    if (!lockedCtx) {
      // ctx already released. "this" completed first, cancel "after"
      return;
    }
    // "after" completed first, cancel "this"
    lockedCtx->thisFuture.raise(FutureTimeout());
    if (!lockedCtx->token.exchange(true, std::memory_order_relaxed)) {
      if (t.hasException()) {
        lockedCtx->promise.setException(std::move(t.exception()));
      } else {
        lockedCtx->promise.setException(std::move(lockedCtx->exception));
      }
    }
  });

  return ctx->promise.getSemiFuture();
}

Friends And Related Function Documentation

template<class T >

template<class >

friend class Future

friend

Definition at line 357 of file Future.h.

template<class T >

friend class Promise< T >

friend

Definition at line 353 of file Future.h.

template<class T >

template<class >

friend class SemiFuture

friend

Definition at line 355 of file Future.h.

Member Data Documentation

template<class T >

Core* folly::futures::detail::FutureBase< T >::core_

protected

Definition at line 399 of file Future.h.

Referenced by folly::futures::detail::FutureBase< T >::assign(), folly::futures::detail::chainExecutor(), folly::SemiFuture< T >::defer(), folly::futures::detail::FutureBase< T >::detach(), folly::SemiFuture< T >::getTry(), folly::SemiFuture< T >::operator=(), folly::SemiFuture< T >::SemiFuture(), folly::SemiFuture< T >::stealDeferredExecutor(), folly::futures::detail::FutureBase< T >::thenImplementation(), folly::futures::detail::FutureBase< T >::throwIfContinued(), folly::futures::detail::FutureBase< T >::throwIfInvalid(), folly::SemiFuture< T >::via(), folly::Future< T >::via(), and folly::SemiFuture< T >::~SemiFuture().

---

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

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