folly::fibers::Promise< T, BatonT > Class Template Reference

#include <Promise.h>

Public Types
typedef T	value_type
typedef BatonT	baton_type

Public Member Functions
	~Promise ()
	Promise (const Promise &)=delete
Promise &	operator= (const Promise &)=delete
	Promise (Promise &&) noexcept
Promise &	operator= (Promise &&)
void	setValue ()
template<class M >
void	setValue (M &&value)
void	setTry (folly::Try< T > &&t)
template<class F >
void	setWith (F &&func)
void	setException (folly::exception_wrapper)

Static Public Member Functions
template<class F >
static value_type	await (F &&func)

Private Member Functions
	Promise (folly::Try< T > &value, BatonT &baton)
void	throwIfFulfilled () const
template<class F >
std::enable_if< std::is_convertible< invoke_result_t< F >, T >::value &&!std::is_same< T, void >::value >::type	fulfilHelper (F &&func)
template<class F >
std::enable_if< std::is_same< invoke_result_t< F >, void >::value &&std::is_same< T, void >::value >::type	fulfilHelper (F &&func)

Private Attributes
folly::Try< T > *	value_
BatonT *	baton_

Detailed Description

template<typename T, typename BatonT = Baton>
class folly::fibers::Promise< T, BatonT >

Definition at line 28 of file Promise.h.

Member Typedef Documentation

template<typename T, typename BatonT = Baton>

typedef BatonT folly::fibers::Promise< T, BatonT >::baton_type

Definition at line 31 of file Promise.h.

template<typename T, typename BatonT = Baton>

typedef T folly::fibers::Promise< T, BatonT >::value_type

Definition at line 30 of file Promise.h.

Constructor & Destructor Documentation

template<class T , class BatonT >

folly::fibers::Promise< T, BatonT >::~Promise

(

)

Definition at line 47 of file Promise-inl.h.

References folly::fibers::Promise< T, BatonT >::setException(), and folly::fibers::Promise< T, BatonT >::value_.

                             {
  if (value_) {
    setException(folly::make_exception_wrapper<std::logic_error>(
        "promise not fulfilled"));
  }
}

template<typename T, typename BatonT = Baton>

folly::fibers::Promise< T, BatonT >::Promise ( const Promise< T, BatonT > &  )

delete

template<class T , class BatonT >

folly::fibers::Promise< T, BatonT >::Promise ( Promise< T, BatonT > &&  other )

noexcept

Definition at line 26 of file Promise-inl.h.

    : value_(other.value_), baton_(other.baton_) {
  other.value_ = nullptr;
  other.baton_ = nullptr;
}

template<class T , class BatonT >

folly::fibers::Promise< T, BatonT >::Promise ( folly::Try< T > &  value, BatonT &  baton  )

private

Definition at line 22 of file Promise-inl.h.

    : value_(&value), baton_(&baton) {}

Member Function Documentation

template<class T , class BatonT >

template<class F >

Promise< T, BatonT >::value_type folly::fibers::Promise< T, BatonT >::await ( F &&  func )

static

Blocks task execution until given promise is fulfilled.

Calls function passing in a Promise<T>, which has to be fulfilled.

Returns

data which was used to fulfill the promise.

Definition at line 94 of file Promise-inl.h.

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

Referenced by folly::fibers::await().

                                                                        {
  folly::Try<value_type> result;
  std::exception_ptr funcException;

  BatonT baton;
  baton.wait([&func, &result, &baton, &funcException]() mutable {
    try {
      func(Promise<value_type, BatonT>(result, baton));
    } catch (...) {
      // Save the exception, but still wait for baton to be posted by user code
      // or promise destructor.
      funcException = std::current_exception();
    }
  });

  if (UNLIKELY(funcException != nullptr)) {
    std::rethrow_exception(funcException);
  }

  return std::move(result).value();
}

template<typename T, typename BatonT = Baton>

template<class F >

std::enable_if< std::is_convertible<invoke_result_t<F>, T>::value && !std::is_same<T, void>::value>::type folly::fibers::Promise< T, BatonT >::fulfilHelper ( F &&  func )

private

template<typename T, typename BatonT = Baton>

template<class F >

std::enable_if< std::is_same<invoke_result_t<F>, void>::value && std::is_same<T, void>::value>::type folly::fibers::Promise< T, BatonT >::fulfilHelper ( F &&  func )

private

template<typename T, typename BatonT = Baton>

Promise& folly::fibers::Promise< T, BatonT >::operator= ( const Promise< T, BatonT > &  )

delete

template<class T , class BatonT >

Promise< T, BatonT > & folly::fibers::Promise< T, BatonT >::operator=

(

Promise< T, BatonT > &&

other

)

Definition at line 33 of file Promise-inl.h.

References folly::fibers::Promise< T, BatonT >::baton_, folly::f14::swap(), and folly::fibers::Promise< T, BatonT >::value_.

                                                                 {
  std::swap(value_, other.value_);
  std::swap(baton_, other.baton_);
  return *this;
}

template<class T , class BatonT >

void folly::fibers::Promise< T, BatonT >::setException

(

folly::exception_wrapper

e

)

Fulfill the Promise with an exception_wrapper, e.g. auto ew = folly::try_and_catch<std::exception>([]{ ... }); if (ew) { p.setException(std::move(ew)); }

Definition at line 55 of file Promise-inl.h.

References folly::fibers::Promise< T, BatonT >::setTry().

Referenced by folly::fibers::Promise< T, BatonT >::~Promise().

                                                              {
  setTry(folly::Try<T>(e));
}

template<class T , class BatonT >

void folly::fibers::Promise< T, BatonT >::setTry

(

folly::Try< T > &&

t

)

Fulfill the promise with a given try

Parameters

t

Definition at line 60 of file Promise-inl.h.

References folly::fibers::Promise< T, BatonT >::baton_, folly::gen::move, folly::pushmi::detail::t, folly::fibers::Promise< T, BatonT >::throwIfFulfilled(), and folly::fibers::Promise< T, BatonT >::value_.

Referenced by folly::fibers::Promise< T, BatonT >::setException(), folly::fibers::Promise< T, BatonT >::setValue(), and folly::fibers::Promise< T, BatonT >::setWith().

                                               {
  throwIfFulfilled();

  *value_ = std::move(t);
  value_ = nullptr;

  // Baton::post has to be the last step here, since if Promise is not owned by
  // the posting thread, it may be destroyed right after Baton::post is called.
  baton_->post();
}

template<class T , class BatonT >

void folly::fibers::Promise< T, BatonT >::setValue

(

)

Fulfill this promise (only for Promise<void>)

Definition at line 80 of file Promise-inl.h.

References folly::fibers::Promise< T, BatonT >::setTry(), and value.

Referenced by TEST().

                                  {
  static_assert(std::is_same<T, void>::value, "Use setValue(value) instead");

  setTry(folly::Try<void>());
}

template<class T , class BatonT >

template<class M >

void folly::fibers::Promise< T, BatonT >::setValue

(

M &&

value

)

Set the value (use perfect forwarding for both move and copy)

Definition at line 73 of file Promise-inl.h.

References folly::fibers::Promise< T, BatonT >::setTry(), and value.

                                       {
  static_assert(!std::is_same<T, void>::value, "Use setValue() instead");

  setTry(folly::Try<T>(std::forward<M>(v)));
}

template<class T , class BatonT >

template<class F >

void folly::fibers::Promise< T, BatonT >::setWith

(

F &&

func

)

Fulfill this promise with the result of a function that takes no arguments and returns something implicitly convertible to T. Captures exceptions. e.g.

p.setWith([] { do something that may throw; return a T; });

Definition at line 88 of file Promise-inl.h.

References folly::makeTryWith(), and folly::fibers::Promise< T, BatonT >::setTry().

                                         {
  setTry(makeTryWith(std::forward<F>(func)));
}

template<class T , class BatonT >

void folly::fibers::Promise< T, BatonT >::throwIfFulfilled ( ) const

private

Definition at line 40 of file Promise-inl.h.

References folly::fibers::Promise< T, BatonT >::value_.

Referenced by folly::fibers::Promise< T, BatonT >::setTry().

                                                {
  if (!value_) {
    throw std::logic_error("promise already fulfilled");
  }
}

Member Data Documentation

template<typename T, typename BatonT = Baton>

BatonT* folly::fibers::Promise< T, BatonT >::baton_

private

Definition at line 87 of file Promise.h.

Referenced by folly::fibers::Promise< T, BatonT >::operator=(), and folly::fibers::Promise< T, BatonT >::setTry().

template<typename T, typename BatonT = Baton>

folly::Try<T>* folly::fibers::Promise< T, BatonT >::value_

private

Definition at line 86 of file Promise.h.

Referenced by folly::fibers::Promise< T, BatonT >::operator=(), folly::fibers::Promise< T, BatonT >::setTry(), folly::fibers::Promise< T, BatonT >::throwIfFulfilled(), and folly::fibers::Promise< T, BatonT >::~Promise().

---

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

• proxygen/folly/folly/fibers/Promise.h
• proxygen/folly/folly/fibers/Promise-inl.h