folly::SharedPromise< T > Class Template Reference

#include <SharedPromise.h>

Public Member Functions
	SharedPromise ()=default
	~SharedPromise ()=default
	SharedPromise (SharedPromise const &)=delete
SharedPromise &	operator= (SharedPromise const &)=delete
	SharedPromise (SharedPromise< T > &&) noexcept
SharedPromise &	operator= (SharedPromise< T > &&) noexcept
SemiFuture< T >	getSemiFuture ()
Future< T >	getFuture ()
size_t	size ()
void	setException (exception_wrapper ew)
template<class E >
std::enable_if< std::is_base_of< std::exception, E >::value >::type	setException (E const &)
void	setInterruptHandler (std::function< void(exception_wrapper const &)>)
template<class B = T>
std::enable_if< std::is_same< Unit, B >::value, void >::type	setValue ()
	Sugar to fulfill this SharedPromise<Unit> More...
template<class M >
void	setValue (M &&value)
void	setTry (Try< T > &&t)
template<class F >
void	setWith (F &&func)
bool	isFulfilled ()

Private Attributes
std::mutex	mutex_
size_t	size_ {0}
bool	hasValue_ {false}
Try< T >	try_
std::vector< Promise< T > >	promises_
std::function< void(exception_wrapper const &)>	interruptHandler_

Detailed Description

template<class T>
class folly::SharedPromise< T >

Definition at line 41 of file SharedPromise.h.

Constructor & Destructor Documentation

template<class T>

folly::SharedPromise< T >::SharedPromise ( )

default

template<class T>

folly::SharedPromise< T >::~SharedPromise ( )

default

template<class T>

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

delete

template<class T>

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

noexcept

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

References folly::gen::move.

                                                                 {
  *this = std::move(other);
}

Member Function Documentation

template<class T >

Future< T > folly::SharedPromise< T >::getFuture

(

)

Return a Future tied to the shared core state. Unlike Promise::getFuture, this can be called an unlimited number of times per SharedPromise. NOTE: This function is deprecated. Please use getSemiFuture and pass the appropriate executor to .via on the returned SemiFuture to get a valid Future where necessary.

Definition at line 72 of file SharedPromise-inl.h.

References folly::InlineExecutor::instance(), type, and value.

Referenced by TEST(), and wangle::OutputBufferingHandler::write().

                                      {
  return getSemiFuture().via(&InlineExecutor::instance());
}

template<class T >

SemiFuture< T > folly::SharedPromise< T >::getSemiFuture

(

)

Return a Future tied to the shared core state. Unlike Promise::getFuture, this can be called an unlimited number of times per SharedPromise.

Definition at line 57 of file SharedPromise-inl.h.

References g(), and mutex_.

Referenced by TEST().

                                              {
  std::lock_guard<std::mutex> g(mutex_);
  size_++;
  if (hasValue_) {
    return makeFuture<T>(Try<T>(try_));
  } else {
    promises_.emplace_back();
    if (interruptHandler_) {
      promises_.back().setInterruptHandler(interruptHandler_);
    }
    return promises_.back().getSemiFuture();
  }
}

template<class T >

bool folly::SharedPromise< T >::isFulfilled

(

)

Definition at line 133 of file SharedPromise-inl.h.

References g(), and mutex_.

Referenced by folly::SharedPromise< folly::folly::Unit >::setValue(), and TEST().

                                   {
  std::lock_guard<std::mutex> g(mutex_);
  return hasValue_;
}

template<class T>

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

delete

template<class T>

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

noexcept

Definition at line 27 of file SharedPromise-inl.h.

References folly::detail::lock(), mutex_, and folly::f14::swap().

                                       {
  if (this == &other) {
    return *this;
  }

  // std::lock will perform deadlock avoidance, in case
  // Thread A: p1 = std::move(p2)
  // Thread B: p2 = std::move(p1)
  // race each other
  std::lock(mutex_, other.mutex_);
  std::lock_guard<std::mutex> g1(mutex_, std::adopt_lock);
  std::lock_guard<std::mutex> g2(other.mutex_, std::adopt_lock);

  std::swap(size_, other.size_);
  std::swap(hasValue_, other.hasValue_);
  std::swap(try_, other.try_);
  std::swap(interruptHandler_, other.interruptHandler_);
  std::swap(promises_, other.promises_);

  return *this;
}

template<class T >

void folly::SharedPromise< T >::setException

(

exception_wrapper

ew

)

Fulfill the SharedPromise with an exception_wrapper

Definition at line 84 of file SharedPromise-inl.h.

References folly::gen::move.

Referenced by wangle::OutputBufferingHandler::close().

                                                        {
  setTry(Try<T>(std::move(ew)));
}

template<class T >

template<class E >

std::enable_if< std::is_base_of< std::exception, E >::value >::type folly::SharedPromise< T >::setException

(

E const &

e

)

Fulfill the SharedPromise with an exception type E, which can be passed to make_exception_wrapper(). Useful for originating exceptions. If you caught an exception the exception_wrapper form is more appropriate.

Definition at line 79 of file SharedPromise-inl.h.

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

template<class T >

void folly::SharedPromise< T >::setInterruptHandler

(

std::function< void(exception_wrapper const &)>

fn

)

Set an interrupt handler to handle interrupts. See the documentation for Future::raise(). Your handler can do whatever it wants, but if you bother to set one then you probably will want to fulfill the SharedPromise with an exception (or special value) indicating how the interrupt was handled.

Definition at line 89 of file SharedPromise-inl.h.

References g(), and mutex_.

Referenced by TEST().

                                                    {
  std::lock_guard<std::mutex> g(mutex_);
  if (hasValue_) {
    return;
  }
  interruptHandler_ = fn;
  for (auto& p : promises_) {
    p.setInterruptHandler(fn);
  }
}

template<class T>

void folly::SharedPromise< T >::setTry

(

Try< T > &&

t

)

Definition at line 114 of file SharedPromise-inl.h.

References g(), folly::gen::move, mutex_, and folly::pushmi::detail::t.

Referenced by wangle::OutputBufferingHandler::runLoopCallback(), and folly::SharedPromise< folly::folly::Unit >::setValue().

                                        {
  std::vector<Promise<T>> promises;

  {
    std::lock_guard<std::mutex> g(mutex_);
    if (hasValue_) {
      throw_exception<PromiseAlreadySatisfied>();
    }
    hasValue_ = true;
    try_ = std::move(t);
    promises.swap(promises_);
  }

  for (auto& p : promises) {
    p.setTry(Try<T>(try_));
  }
}

template<class T>

template<class B = T>

std::enable_if<std::is_same<Unit, B>::value, void>::type folly::SharedPromise< T >::setValue ( )

inline

Sugar to fulfill this SharedPromise<Unit>

Definition at line 92 of file SharedPromise.h.

Referenced by folly::SharedPromise< folly::folly::Unit >::setValue(), and TEST().

                                                                       {
    setTry(Try<T>(T()));
  }

template<class T >

template<class M >

void folly::SharedPromise< T >::setValue

(

M &&

value

)

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

Definition at line 103 of file SharedPromise-inl.h.

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

template<class T >

template<class F >

void folly::SharedPromise< T >::setWith

(

F &&

func

)

Fulfill this SharedPromise 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 109 of file SharedPromise-inl.h.

References folly::makeTryWith().

Referenced by folly::SharedPromise< folly::folly::Unit >::setValue(), and TEST().

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

template<class T >

size_t folly::SharedPromise< T >::size

(

)

Return the number of Futures associated with this SharedPromise

Definition at line 51 of file SharedPromise-inl.h.

References g(), and mutex_.

                              {
  std::lock_guard<std::mutex> g(mutex_);
  return size_;
}

Member Data Documentation

template<class T>

bool folly::SharedPromise< T >::hasValue_ {false}

private

Definition at line 116 of file SharedPromise.h.

template<class T>

std::function<void(exception_wrapper const&)> folly::SharedPromise< T >::interruptHandler_

private

Definition at line 119 of file SharedPromise.h.

template<class T>

std::mutex folly::SharedPromise< T >::mutex_

private

Definition at line 114 of file SharedPromise.h.

template<class T>

std::vector<Promise<T> > folly::SharedPromise< T >::promises_

private

Definition at line 118 of file SharedPromise.h.

template<class T>

size_t folly::SharedPromise< T >::size_ {0}

private

Definition at line 115 of file SharedPromise.h.

template<class T>

Try<T> folly::SharedPromise< T >::try_

private

Definition at line 117 of file SharedPromise.h.

---

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

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