timer_handler.h

#ifndef MRS_TIMER_H
#define MRS_TIMER_H
 
#include <rclcpp/rclcpp.hpp>
#include <mutex>
 
#include <mrs_lib/coro/runners.hpp>
#include <mrs_lib/coro/task.hpp>
#include <mrs_lib/internal/coroutine_callback_helpers.hpp>
#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;
 
    template <typename C>
    static std::function<void()> createNonReentrantCallback(Task<> (C::*method)(), C* instance)
    {
      auto is_running = std::make_shared<std::atomic<bool>>(false);
      return [is_running, method, instance]() -> void {
        bool was_running = is_running->exchange(true);
 
        if (!was_running)
        {
          // The callback was not running and we have set it as running, we start it here.
          internal::start_task(
              // Capturing lambdas should not be used as coroutines.
              // Pass the values as arguments instead.
              [](std::shared_ptr<std::atomic<bool>> is_running, Task<> (C::*method)(), C* instance) -> mrs_lib::Task<> {
                // Run the user specified callback.
                co_await std::invoke(method, instance);
                // The task finished so we store false to allow another callback to start.
                is_running->store(false);
                co_return;
              },
              is_running, method, instance);
        }
      };
    }
 
    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);
 
    template <typename C>
    ROSTimer(const mrs_lib::TimerHandlerOptions& opts, const rclcpp::Rate& rate, Task<> (C::*method)(), C* instance)
        : ROSTimer(opts, rate, createNonReentrantCallback(method, instance))
    {
      internal::require_callback_group_coro_compatible(opts.callback_group.value_or(nullptr));
    }
 
    template <typename C>
    ROSTimer(const mrs_lib::TimerHandlerOptions& opts, const rclcpp::Rate& rate, Task<> (C::*method)(), std::shared_ptr<C> instance)
        : ROSTimer(opts, rate, createNonReentrantCallback(method, instance))
    {
      internal::require_callback_group_coro_compatible(opts.callback_group.value_or(nullptr));
    }
 
    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);
 
    template <typename C>
    ThreadTimer(const mrs_lib::TimerHandlerOptions& opts, const rclcpp::Rate& rate, Task<> (C::*method)(), C* instance)
        : ThreadTimer(opts, rate, createNonReentrantCallback(method, instance))
    {
      internal::require_callback_group_coro_compatible(opts.callback_group.value_or(nullptr));
    }
 
    template <typename C>
    ThreadTimer(const mrs_lib::TimerHandlerOptions& opts, const rclcpp::Rate& rate, Task<> (C::*method)(), std::shared_ptr<C> instance)
        : ThreadTimer(opts, rate, createNonReentrantCallback(method, instance))
    {
      internal::require_callback_group_coro_compatible(opts.callback_group.value_or(nullptr));
    }
 
    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