Re: [boost] [futures] boost::futures

From: Braddock Gaskill (braddock_at_[hidden])
Date: 2007-03-14 07:43:47

On Wed, 14 Mar 2007 06:49:57 +0100, Oliver.Kowalke wrote:
>> I've made a futures implementation in the hopes of combining 
>> http://braddock.com/~braddock/future/
> 
> In your implementation I'm missing operators for logical combination of
> futures like it is supported by the futures implementation of Thorsten Schütt
> (vault files).

Hi Oliver,
Yes, I would like to either add this, or merge into Schutt's implementation if
he is interested.  And example of an unintrusive operator||() is below.

I added a public add_callback() method which calls an observer function when the
future's state changes.  This should allow grouping of futures or combined waits to
be handled unintrusively outside of the main future classes. 

This public observer method is also needed for things like future-aware task
scheduling (like Frank Hess's draft active object or boost::coroutine).

template <typename T>
struct future_or {
  future_or(future<T> &a, future<T> &b) : a_(a), b_(b) {}
  future_or(const future_or &f) : a_(f.a_), b_(f.b_), p_(f.p_) {}
  struct future_or_failed : public std::exception { };
  void operator()() {
    boost::mutex::scoped_lock lck(mutex_);
    if (a_.has_value())
      p_.set(a_.get());
    else if (b_.has_value())
      p_.set(b_.get());
    else if (a_.has_exception() && b_.has_exception()) // both failed
      p_.set_exception(future_or_failed());
  }
  future<T> a_,b_;
  promise<T> p_;
  boost::mutex mutex_;
};

template<typename T>
future<T> operator||(future<T> &a, future<T> &b) {
  future_or<T> fa(a, b);
  a.add_callback(fa);
  return fa.p_;
}

void TestCase7() { // test future or || example
  promise<int> p1;
  promise<int> p2;
  future<int> f1(p1);
  future<int> f2(p2);
  future<int> f1_or_f2 = f1 || f2;
  BOOST_CHECK(!f1_or_f2.ready());
  p1.set(97);
  p2.set(-5); // will be ignored by the or
  BOOST_CHECK(f1_or_f2.ready());
  BOOST_CHECK_EQUAL(f1_or_f2.get(), 97);
}