toast/async/promise.hpp

#ifndef toast_async_promise_hpp_INCLUDED
#define toast_async_promise_hpp_INCLUDED

#include <boost/type_traits.hpp>
#include <boost/optional.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/thread/condition.hpp>
#include <toast/async/thread_specific_request_queue.hpp>

namespace toast {
namespace async {

namespace detail {
template <typename T>
struct promise_data
{
  typedef T value_type;
  boost::optional<T> value;
  boost::mutex mutex;
  boost::condition condition;
};

template <typename PromiseType, typename PromiseValueType>
void set_data(PromiseType &pd, PromiseValueType const &t)
{
  boost::mutex::scoped_lock lock(pd.mutex);
  if(pd.value)
    return;
  pd.value = t;
  pd.condition.notify_all();
}

template <typename T, typename U>
void set_shared_data(T data, 
        U const &f)
{
  set_data(*data, f());
}
} // detail

template <typename T> class promise;

template <typename T> 
promise<T> future(const boost::function<T()>&, worker_pool&);

template <typename T>
class promise
{
private:
  mutable boost::shared_ptr<detail::promise_data<T> > data_;
  void wait_until_defined() const
  {
    boost::mutex::scoped_lock lock(data_->mutex);
    while(!data_->value)
      data_->condition.wait(lock);
  }
public:
  typedef void (promise::*unspecified_bool_type)() const;

  promise() : data_(new detail::promise_data<T>()) {}
  promise(boost::shared_ptr<detail::promise_data<T> > data) : data_(data) {}

  promise &operator=(T const &t)
  {
    detail::set_data(*data_, t);
    return data_->value;
  }
  const T &operator*() const
  {
    wait_until_defined();
    return *(data_->value);
  }
  const T *operator->() const
  {
    wait_until_defined();
    return data_->value.get_ptr();
  }
  operator unspecified_bool_type () const
  {
    boost::mutex::scoped_lock lock(data_->mutex);
    return data_->value ? &promise::wait_until_defined : 0;
  }
};

template <typename T>
promise<T> future(boost::function<T ()> const &f, worker_pool &pool = 
        default_worker_pool())
{
  boost::shared_ptr<detail::promise_data<T> > p(new detail::promise_data<T>());
  pool.push(boost::bind(&detail::set_shared_data<
                                                        boost::shared_ptr< detail::promise_data<T> >,
                                                        boost::function<T ()> >,
                                                p, f));
  return promise<T>(p);
}

} // namespace async
} // namespace toast

#endif // toast_async_promise_hpp_INCLUDED

---