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:
    typedef boost::function<void()> Callback;
    // internal
    typedef boost::function<qi::Future<void>(
        const Callback&, qi::Duration delay)> ScheduleCallback;

    PeriodicTask();

    ~PeriodicTask();


    void setCallback(const Callback& cb);
#ifdef DOXYGEN
    template <typename T, typename ARG0> PeriodicTask& setCallback(const T& callable, ARG0 tracked, ...);
#else
#define genCall(n, ATYPEDECL, ATYPES, ADECL, AUSE, comma)              \
  template <typename AF, typename ARG0 comma ATYPEDECL>                \
  inline void setCallback(const AF& fun, const ARG0& arg0 comma ADECL) \
  {                                                                    \
    setCallback(boost::bind(fun, arg0 comma AUSE));                    \
    _connectMaybeActor<ARG0>(arg0);                                    \
  }
    QI_GEN(genCall)
#undef genCall
#endif

    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);
    }
  };

}
#endif