timer.h

#ifndef MRS_TIMER_H
#define MRS_TIMER_H
 
#include <ros/ros.h>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
 
namespace mrs_lib
{
  class MRSTimer
  {
    public:
    using callback_t = std::function<void(const ros::TimerEvent&)>;
 
    virtual void stop() = 0;
 
    virtual void start() = 0;
 
    virtual void setPeriod(const ros::Duration& duration, const bool reset = true) = 0;
 
    virtual void setCallback(const std::function<void(const ros::TimerEvent&)>& callback) = 0;
 
    virtual bool running() = 0;
 
    virtual ~MRSTimer() = default;
    MRSTimer(const MRSTimer&) = default;
    MRSTimer(MRSTimer&&) = default;
    MRSTimer& operator=(const MRSTimer&) = default;
    MRSTimer& operator=(MRSTimer&&) = default;
 
    protected:
    MRSTimer() = default;
  };
 
  // | ------------------------ ROSTimer ------------------------ |
 
  /* class ROSTimer //{ */
 
  class ROSTimer : public MRSTimer {
  public:
    ROSTimer();
 
    template <class ObjectType>
    ROSTimer(const ros::NodeHandle& nh, const ros::Rate& rate, void (ObjectType::*const callback)(const ros::TimerEvent&), ObjectType* const obj,
             const bool oneshot = false, const bool autostart = true);
 
    template <class ObjectType>
    ROSTimer(const ros::NodeHandle& nh, const ros::Duration& duration, void (ObjectType::*const callback)(const ros::TimerEvent&), ObjectType* const obj,
             const bool oneshot = false, const bool autostart = true);
 
    virtual void stop() override;
 
    virtual void start() override;
 
    virtual void setPeriod(const ros::Duration& duration, const bool reset = true) override;
 
    virtual void setCallback(const std::function<void(const ros::TimerEvent&)>& callback) override;
 
    virtual bool running() override;
 
    virtual ~ROSTimer() override {stop();};
    // to keep rule of five since we have a custom destructor
    ROSTimer(const ROSTimer&) = delete;
    ROSTimer(ROSTimer&&) = delete;
    ROSTimer& operator=(const ROSTimer&) = delete;
    ROSTimer& operator=(ROSTimer&&) = delete;
 
  private:
    std::mutex mutex_timer_;
 
    std::unique_ptr<ros::Timer> timer_;
  };
 
  //}
 
  // | ----------------------- ThreadTimer ---------------------- |
 
  /* class ThreadTimer //{ */
 
  class ThreadTimer : public MRSTimer {
 
  public:
    ThreadTimer();
 
    template <class ObjectType>
    ThreadTimer(const ros::NodeHandle& nh, const ros::Rate& rate, void (ObjectType::*const callback)(const ros::TimerEvent&), ObjectType* const obj,
                const bool oneshot = false, const bool autostart = true);
 
    template <class ObjectType>
    ThreadTimer(const ros::NodeHandle& nh, const ros::Duration& duration, void (ObjectType::*const callback)(const ros::TimerEvent&), ObjectType* const obj,
                bool oneshot = false, const bool autostart = true);
 
    virtual void stop() override;
 
    virtual void start() override;
 
    virtual void setPeriod(const ros::Duration& duration, const bool reset = true) override;
    
    virtual void setCallback(const std::function<void(const ros::TimerEvent&)>& callback) override;
 
    virtual bool running() override;
 
    virtual ~ThreadTimer() override {stop();};
    // to keep rule of five since we have a custom destructor
    ThreadTimer(const ThreadTimer&) = delete;
    ThreadTimer(ThreadTimer&&) = delete;
    ThreadTimer& operator=(const ThreadTimer&) = delete;
    ThreadTimer& operator=(ThreadTimer&&) = delete;
 
  private:
    class Impl;
 
    std::unique_ptr<Impl> impl_;
 
  };  // namespace mrs_lib
 
  //}
 
#include <mrs_lib/impl/timer.hpp>
 
}  // namespace mrs_lib
 
#endif  // MRS_TIMER_H