futuregroup.hpp

Go to the documentation of this file.

#pragma once
/*
**  Copyright (C) 2014 Aldebaran Robotics
**  See COPYING for the license
*/
#include <boost/container/flat_map.hpp>
#include <boost/thread/mutex.hpp>
#include <qi/future.hpp>
#include <qi/trackable.hpp>

namespace qi
{
  class ScopedFutureGroup
    : boost::noncopyable
    , public qi::Trackable<ScopedFutureGroup>
  {
  public:
    ScopedFutureGroup()
      : Trackable<ScopedFutureGroup>(this)
    {}

    ~ScopedFutureGroup()
    {
      destroy();
      cancelAll();
    }

    template< class T >
    void add(Future<T> future)
    {
      boost::mutex::scoped_lock lock(_mutex);
      if (!future.isCancelable())
      {
        qiLogVerbose("qi.scopedfuturegroup") << "Trying to add non-cancelable future added to ScopedFutureGroup - future ignored.";
        return;
      }

      _futureCancelList.insert(std::make_pair(future.uniqueId(), qi::bind<void()>(&Future<T>::cancel, future)));

      // The 2 following lines are necessary because of a compiler bug in VS2010 which is fixed in VS2015 and beyond
      typedef void (ScopedFutureGroup::* MemFuncType)(Future<T>);
      MemFuncType onFutureFinishedCallback = &ScopedFutureGroup::onFutureFinished<T>;
      future.template thenR<void>(onFutureFinishedCallback, this, _1);
    }

    void cancelAll()
    {
      FutureCancelList cancelList;
      {
        boost::mutex::scoped_lock lock(_mutex);
        swap(cancelList, _futureCancelList);
      }
      for (FutureCancelList::iterator it = cancelList.begin(), itEnd = cancelList.end();
           it != itEnd; ++it)
      {
        try
        {
          it->second();
        }
        catch (std::exception& ex)
        {
          qiLogWarning("qi.scopedfuturegroup") << "Failed to cancel scoped future: " << ex.what();
        }
        catch (...)
        {
          qiLogWarning("qi.scopedfuturegroup") << "Failed to cancel scoped future: unknown error.";
        }

      }
    }

    bool empty() const
    {
      boost::mutex::scoped_lock lock(_mutex);
      return _futureCancelList.empty();
    }

    size_t size() const
    {
      boost::mutex::scoped_lock lock(_mutex);
      return _futureCancelList.size();
    }

  private:
    mutable boost::mutex _mutex;
    typedef boost::container::flat_map< FutureUniqueId, boost::function<void()> > FutureCancelList;
    FutureCancelList _futureCancelList;

    template<class T>
    void onFutureFinished(Future<T> future)
    {
      boost::mutex::scoped_lock lock(_mutex);
      _futureCancelList.erase(future.uniqueId());
    }
  };
}