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