timer_handler.h

#ifndef MRS_TIMER_H
#define MRS_TIMER_H
 
#include <rclcpp/rclcpp.hpp>
#include <mutex>
 
#include <mrs_lib/utils.h>
 
namespace mrs_lib
{
 
struct TimerHandlerOptions
{
  TimerHandlerOptions(const rclcpp::Node::SharedPtr node) : node(node) {
  }
 
  TimerHandlerOptions() = default;
 
  rclcpp::Node::SharedPtr node;
 
  bool oneshot = false;
 
  bool autostart = true;
 
  std::optional<rclcpp::CallbackGroup::SharedPtr> callback_group;
};
 
class MRSTimer {
public:
  using callback_t = std::function<void()>;
 
  virtual void stop() = 0;
 
  virtual void start() = 0;
 
  virtual void setPeriod(const rclcpp::Duration& duration) = 0;
 
  virtual void setCallback(const std::function<void()>& 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;
 
  rclcpp::Node::SharedPtr node_;
};
 
// | ------------------------ ROSTimer ------------------------ |
 
/* class ROSTimer //{ */
 
class ROSTimer : public MRSTimer {
public:
  ROSTimer();
 
  ROSTimer(const rclcpp::Node::SharedPtr& node, const rclcpp::Rate& rate, const std::function<void()>& callback);
 
  ROSTimer(const mrs_lib::TimerHandlerOptions& opts, const rclcpp::Rate& rate, const std::function<void()>& callback);
 
  virtual void stop() override;
 
  virtual void start() override;
 
  virtual void setPeriod(const rclcpp::Duration& duration) override;
 
  virtual void setCallback(const std::function<void()>& 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::function<void()> callback;
 
  bool oneshot;
 
  rclcpp::TimerBase::SharedPtr timer_;
 
  std::optional<rclcpp::CallbackGroup::SharedPtr> callback_group_;
};
 
//}
 
// | ----------------------- ThreadTimer ---------------------- |
 
/* class ThreadTimer //{ */
 
class ThreadTimer : public MRSTimer {
 
public:
  ThreadTimer();
 
  ThreadTimer(const rclcpp::Node::SharedPtr& node, const rclcpp::Rate& rate, const std::function<void()>& callback);
 
  ThreadTimer(const mrs_lib::TimerHandlerOptions& opts, const rclcpp::Rate& rate, const std::function<void()>& callback);
 
  virtual void stop() override;
 
  virtual void start() override;
 
  virtual void setPeriod(const rclcpp::Duration& duration) override;
 
  virtual void setCallback(const std::function<void()>& 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
 
//}
 
}  // namespace mrs_lib
 
#ifndef MRS_TIMER_HPP
#include <mrs_lib/impl/timer_handler.hpp>
#endif
 
#endif  // MRS_TIMER_H