futurebarrier.hpp

Go to the documentation of this file.

#pragma once
/*
**  Copyright (C) 2015 Aldebaran Robotics
**  See COPYING for the license
*/

#ifndef QI_DETAIL_FUTURE_BARRIER_HXX_
#define QI_DETAIL_FUTURE_BARRIER_HXX_

namespace qi
{

namespace detail
{

template<typename T>
class FutureBarrierPrivate {
public:
  FutureBarrierPrivate(FutureCallbackType async = FutureCallbackType_Async)
    : _closed(0)
    , _count(0)
    , _futures()
    , _promise(&qi::PromiseNoop<std::vector<Future<T> > >, async)
  {}

  void onFutureFinish() {
    if (--(this->_count) == 0 && this->_closed.load()) {
      if (!_set.swap(true))
        this->_promise.setValue(this->_futures);
    }
  }

  void cancelAll() {
    QI_ASSERT(_closed.load());
    for (typename std::vector< Future<T> >::iterator it = this->_futures.begin();
         it != this->_futures.end();
         ++it)
      it->cancel();
  }

  Atomic<bool> _closed;
  Atomic<bool> _set;
  Atomic<int> _count;
  std::vector< Future<T> > _futures;
  Promise< std::vector< Future<T> > > _promise;

};

}

template<typename T>
class FutureBarrier : boost::noncopyable {
public:
  FutureBarrier(FutureCallbackType async = FutureCallbackType_Async)
    : _p(boost::make_shared<detail::FutureBarrierPrivate<T> >(async))
  {
    _p->_promise.setOnCancel(qi::bindWithFallback(
          boost::function<void()>(),
          &detail::FutureBarrierPrivate<T>::cancelAll,
          boost::weak_ptr<detail::FutureBarrierPrivate<T> >(_p)));
  }

  void addFuture(qi::Future<T> fut) {
    // Can't add future from closed qi::FutureBarrier.
    if (_p->_closed.load())
      throw std::runtime_error("Adding future to closed barrier");

    ++(_p->_count);
    fut.connect(boost::bind<void>(&detail::FutureBarrierPrivate<T>::onFutureFinish, _p));
    _p->_futures.push_back(fut);
  }

  Future< std::vector< Future<T> > > future() {
    this->close();
    return _p->_promise.future();
  }

protected:
  boost::shared_ptr<detail::FutureBarrierPrivate<T> > _p;

private:
  void close() {
    _p->_closed = true;
    if (_p->_count.load() == 0) {
      if (!_p->_set.swap(true))
        _p->_promise.setValue(_p->_futures);
    }
  }
};

template <typename T>
qi::FutureSync<std::vector<Future<T> > > waitForAll(std::vector<Future<T> >& vect) {
  typename std::vector< Future<T> >::iterator it;
  qi::FutureBarrier<T> barrier;

  for (it = vect.begin(); it != vect.end(); ++it) {
    barrier.addFuture(*it);
  }
  return barrier.future();
}

template <typename T>
qi::FutureSync< qi::Future<T> > waitForFirst(std::vector< Future<T> >& vect) {
  typename std::vector< Future<T> >::iterator it;
  qi::Promise< qi::Future<T> > prom;
  qi::Atomic<int>* count = new qi::Atomic<int>();
  count->swap((int)vect.size());
  for (it = vect.begin(); it != vect.end(); ++it) {
    it->connect(boost::bind<void>(&detail::waitForFirstHelper<T>, prom, *it, count));
  }
  return prom.future();
}

}

#endif