#ifndef FUTURE_HPP
#define FUTURE_HPP

#include <memory>
#include <stdexcept>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>

namespace detail {

template <typename T>
class return_value
{
public:
  class exception_holder_base
  {
  public:
    virtual ~exception_holder_base()
    {
    }

    virtual void raise() const = 0;
  };

  template <typename E>
  class exception_holder :
    public exception_holder_base
  {
  public:
    exception_holder(E e)
      : e_(e)
    {
    }

    virtual void raise() const
    {
      throw e_;
    }

  private:
    E e_;
  };

  T get() const
  {
    boost::mutex::scoped_lock lock(mutex_);
    while (!value_.get() && !exception_.get())
      condition_.wait(lock);
    if (exception_.get())
      exception_->raise();
    return *value_;
  }

  void set(T t)
  {
    boost::mutex::scoped_lock lock(mutex_);
    if (value_.get() == 0 && exception_.get() == 0)
    {
      value_.reset(new T(t));
      condition_.notify_all();
    }
  }

  template <typename E>
  void fail(E e)
  {
    boost::mutex::scoped_lock lock(mutex_);
    if (value_.get() == 0 && exception_.get() == 0)
    {
      exception_.reset(new exception_holder<E>(e));
      condition_.notify_all();
    }
  }

private:
  mutable boost::mutex mutex_;
  mutable boost::condition condition_;
  std::auto_ptr<T> value_;
  std::auto_ptr<exception_holder_base> exception_;
};

} // namespace detail

template <typename T>
class future;

template <typename T>
class promise
{
public:
  promise()
    : return_value_(new detail::return_value<T>)
  {
  }

  void operator()(T t) // Fulfil
  {
    return_value_->set(t);
  }

  template <typename E>
  void fail(E e)
  {
    return_value_->fail(e);
  }

private:
  friend class future<T>;
  boost::shared_ptr<detail::return_value<T> > return_value_;
};

template <typename T>
class future
{
private:
public:
  future(promise<T>& p)
    : return_value_(p.return_value_)
  {
  }

  T operator()() const // Await
  {
    return return_value_->get();
  }

private:
  boost::shared_ptr<detail::return_value<T> > return_value_;
};

#endif // FUTURE_HPP