deferred.cpp

#define BOOST_THREAD_PROVIDES_FUTURE
#include <boost/thread.hpp>
#include <boost/thread/future.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/exception_ptr.hpp>
#include <iostream>

template <typename T>
class deferred
{
public:
  typedef T value_type;
  typedef boost::shared_ptr<T> shared_ptr_type;
  typedef boost::promise<shared_ptr_type> promise_type;
  typedef boost::future<shared_ptr_type> future_type;

private:
  shared_ptr_type value_;
  boost::shared_ptr<promise_type> promise_;

public:
  deferred(T* p)
    : value_(p)
    , promise_(new promise_type())
  {}

  deferred(const deferred& other)
    : value_(other.value_)
    , promise_(other.promise_)
  {}

  shared_ptr_type get() const { return value_; }
  shared_ptr_type operator->() const { return value_; }

  future_type future()
  {
    return promise_->get_future();
  }

  void resolve()
  {
    promise_->set_value(value_);
  }

  void reject()
  {
    reject(boost::current_exception());
  }

  void reject(boost::exception_ptr e)
  {
    promise_->set_exception(e);
  }
};

class response
{
  int status_code_;

public:
  response() { std::cout << "create response" << std::endl; }
  ~response() { std::cout << "destroy response" << std::endl; }

  void set_status_code(int code) { status_code_ = code; }
  int status_code() const { return status_code_; }
};

void worker(deferred<response> d)
{
  boost::this_thread::sleep(boost::posix_time::seconds(1));
  d->set_status_code(200);
  d.resolve();
}

deferred<response>::future_type request()
{
  deferred<response> d(new response());
  boost::thread(&worker, d);
  return d.future();
}

int main()
{
  deferred<response>::future_type f = request();
  deferred<response>::shared_ptr_type res = f.get();
  std::cout << res->status_code() << std::endl;
}