timer.hpp

#ifndef MRS_LIB_EXPERIMENTAL_TIMER_HPP_
#define MRS_LIB_EXPERIMENTAL_TIMER_HPP_
 
#include <chrono>
#include <functional>
#include <memory>
 
#include <rclcpp/callback_group.hpp>
#include <rclcpp/create_timer.hpp>
#include <rclcpp/node_interfaces/node_base_interface.hpp>
#include <rclcpp/node_interfaces/node_clock_interface.hpp>
#include <rclcpp/node_interfaces/node_interfaces.hpp>
#include <rclcpp/node_interfaces/node_timers_interface.hpp>
#include <rclcpp/timer.hpp>
 
#include "mrs_lib/utility/callback.hpp"
#include "utility/pimpl.hpp"
 
namespace mrs_lib
{

  using TimerNodeInterfaces = rclcpp::node_interfaces::NodeInterfaces<rclcpp::node_interfaces::NodeBaseInterface, rclcpp::node_interfaces::NodeTimersInterface,
                                                                      rclcpp::node_interfaces::NodeClockInterface>;
 
  namespace internal
  {

    class TimerImplInterface
    {
    public:
      TimerImplInterface() = default;

      virtual ~TimerImplInterface() = default;
 
      TimerImplInterface(const TimerImplInterface&) = delete;
      TimerImplInterface& operator=(const TimerImplInterface&) = delete;
      TimerImplInterface(TimerImplInterface&&) = delete;
      TimerImplInterface& operator=(TimerImplInterface&&) = delete;

      virtual void stop() = 0;

      virtual void start_or_reset() = 0;

      virtual void set_period(std::chrono::nanoseconds period) = 0;

      [[nodiscard]] virtual bool is_running() const = 0;
    };
 
  } // namespace internal

  struct RosTimerOptions
  {
    TimerNodeInterfaces node_interfaces;

    bool autostart = true;

    bool oneshot = false;

    std::shared_ptr<rclcpp::CallbackGroup> callback_group = nullptr;
  };

  struct ThreadTimerOptions
  {
    TimerNodeInterfaces node_interfaces;

    bool autostart = true;

    bool oneshot = false;
  };

  class Timer
  {
  public:
    using EventCallback = std::function<void()>;

    using EventCoroCallback = CoroCallback<void()>;

    explicit Timer(const RosTimerOptions& options, std::chrono::nanoseconds period, EventCallback callback);

    explicit Timer(const RosTimerOptions& options, std::chrono::nanoseconds period, EventCoroCallback callback);

    explicit Timer(const ThreadTimerOptions& options, std::chrono::nanoseconds period, EventCallback callback);

    explicit Timer(const ThreadTimerOptions& options, std::chrono::nanoseconds period, EventCoroCallback callback);

    void stop();

    void start_or_reset();

    void set_period(std::chrono::nanoseconds period);

    [[nodiscard]] bool is_running() const;
 
  private:
    Pimpl<internal::TimerImplInterface> impl_;
  };
 
} // namespace mrs_lib
 
#endif // MRS_LIB_EXPERIMENTAL_TIMER_HPP_