periodictask.hpp

Go to the documentation of this file.

#pragma once
/*
* Copyright (c) Aldebaran Robotics 2013 All Rights Reserved
*/
#ifndef _QI_PERIODICTASK_HPP_
# define _QI_PERIODICTASK_HPP_

# include <string>

# include <boost/function.hpp>
# include <boost/utility.hpp>

# include <qi/atomic.hpp>
# include <qi/future.hpp>
# include <qi/stats.hpp>
# include <qi/trackable.hpp>
# include <qi/actor.hpp>
# include <qi/clock.hpp>

namespace qi
{
  struct PeriodicTaskPrivate;
  class QI_API PeriodicTask: public boost::noncopyable
  {
  public:
    using Callback = boost::function<void()>;
    // internal
    using ScheduleCallback = boost::function<qi::Future<void>(const Callback&, qi::Duration delay)>;

    PeriodicTask();

    ~PeriodicTask();


    template <typename T>
    auto setCallback(T&& cb) -> typename std::enable_if<detail::IsAsyncBind<typename std::decay<T>::type>::value>::type
    {
      static_assert(sizeof(T) && false,
          "Don't use PeriodicTask::setCallback(qi::bind(...)) but setCallback(...) directly");
    }
    template <typename T>
    auto setCallback(T&& cb) -> typename std::enable_if<!detail::IsAsyncBind<typename std::decay<T>::type>::value>::type
    {
      _setCallback(std::forward<T>(cb));
    }
    template <typename AF, typename ARG0, typename... ARGS>
    inline void setCallback(AF&& callable, ARG0&& arg0, ARGS&&... args)
    {
      _connectMaybeActor(arg0);
      _setCallback(boost::bind(std::forward<AF>(callable), std::forward<ARG0>(arg0), std::forward<ARGS>(args)...));
    }

    void setStrand(qi::Strand* strand);

    void setUsPeriod(qi::int64_t usPeriod);

    void setPeriod(qi::Duration period);

    void start(bool immediate = true);

    void trigger();

    void stop();

    void asyncStop();

    void compensateCallbackTime(bool compensate);

    void setName(const std::string& name);

    bool isRunning() const;

    bool isStopping() const;

  private:
    boost::shared_ptr<PeriodicTaskPrivate> _p;

    template <typename ARG0>
    inline typename boost::enable_if<
        boost::is_base_of<Actor, typename detail::Unwrap<ARG0>::type>,
        void>::type
        _connectMaybeActor(const ARG0& arg0)
    {
      setStrand(detail::Unwrap<ARG0>::unwrap(arg0)->strand());
    }
    template <typename ARG0>
    inline typename boost::disable_if<
        boost::is_base_of<Actor, typename detail::Unwrap<ARG0>::type>,
        void>::type
        _connectMaybeActor(const ARG0& arg0)
    {
      setStrand(0);
    }

    void _setCallback(const Callback& cb);
  };

}
#endif