timeout_manager.hpp

#ifndef MRS_LIB_TIMEOUT_MANAGER_HPP_
#define MRS_LIB_TIMEOUT_MANAGER_HPP_
 
 
#include <chrono>
#include <functional>
#include <memory>
#include <mutex>
 
#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/time.hpp>
 
#include "mrs_lib/utility/owning_mutex.hpp"
#include "mrs_lib/utility/pimpl.hpp"
 
 
namespace mrs_lib
{
  class TimeoutManagerHandle;
 
  namespace internal
  {
    class TimeoutManagerHandleKey;
  }
 
  using TimeoutManagerNodeInterfaces =
      rclcpp::node_interfaces::NodeInterfaces<rclcpp::node_interfaces::NodeBaseInterface, rclcpp::node_interfaces::NodeTimersInterface,
                                              rclcpp::node_interfaces::NodeClockInterface>;
 

  struct TimeoutManagerRegisterOptions
  {
    std::chrono::nanoseconds timeout;
    std::function<void(rclcpp::Time)> callback;
    bool started = true;
    bool oneshot = false;
  };

  class TimeoutManager2
  {
  private:
    class Impl;
 
  public:
    using Callback = std::function<void(rclcpp::Time)>;

    explicit TimeoutManager2(TimeoutManagerNodeInterfaces node_interfaces, std::chrono::nanoseconds update_period);

    ~TimeoutManager2();

    TimeoutManager2(const TimeoutManager2&) = delete;
    TimeoutManager2& operator=(const TimeoutManager2&) = delete;

    TimeoutManager2(TimeoutManager2&&) noexcept;
    TimeoutManager2& operator=(TimeoutManager2&&) noexcept;

    std::shared_ptr<TimeoutManagerHandle> register_new(TimeoutManagerRegisterOptions options);

    void start_all();

    void pause_all();

    void clear_deleted();
 
  private:
    Pimpl<Impl> impl_;
 
    friend class internal::TimeoutManagerHandleKey;
  };
 
  namespace internal
  {
 
    class TimeoutManagerHandleKey
    {
    private:
      TimeoutManagerHandleKey() = default;
 
      friend class TimeoutManager2::Impl;
    };
 
  } // namespace internal

  class TimeoutManagerHandle
  {
  public:
    explicit TimeoutManagerHandle(internal::TimeoutManagerHandleKey key, TimeoutManagerRegisterOptions options,
                                  std::shared_ptr<rclcpp::node_interfaces::NodeClockInterface> clock_interface);

    ~TimeoutManagerHandle() = default;
    TimeoutManagerHandle(const TimeoutManagerHandle&) = delete;
    TimeoutManagerHandle& operator=(const TimeoutManagerHandle&) = delete;
    TimeoutManagerHandle(TimeoutManagerHandle&&) = delete;
    TimeoutManagerHandle& operator=(TimeoutManagerHandle&&) = delete;

    void reset_timeout();

    void start();

    void pause();

    void set_timeout(std::chrono::nanoseconds timeout);

    [[nodiscard]] bool is_started() const;

    [[nodiscard]] rclcpp::Time get_last_reset() const;

    void run_callback_if_expired(internal::TimeoutManagerHandleKey key);
 
  private:
    struct Data
    {
      std::shared_ptr<rclcpp::node_interfaces::NodeClockInterface> clock_interface;
      TimeoutManagerRegisterOptions options;
      rclcpp::Time last_reset;
      rclcpp::Time last_callback;
    };
 
    OwningMutex<Data, std::recursive_mutex> data_;
  };
 
} // namespace mrs_lib
 
#endif // MRS_LIB_TIMEOUT_MANAGER_HPP_