subscribe_handler.h

Go to the documentation of this file.

// clang: MatousFormat
#ifndef SUBRSCRIBE_HANDLER_H
#define SUBRSCRIBE_HANDLER_H
 
#include <optional>
 
#include <ros/ros.h>
#include <mrs_lib/timeout_manager.h>
 
namespace mrs_lib
{
 
  static const ros::Duration no_timeout = ros::Duration(0);
 
  /* struct SubscribeHandlerOptions //{ */
  
  struct SubscribeHandlerOptions
  {
    SubscribeHandlerOptions(const ros::NodeHandle& nh) : nh(nh) {}
    SubscribeHandlerOptions() = default;
  
    ros::NodeHandle nh;  
    std::string node_name = {};  
    std::string topic_name = {};  
    std::shared_ptr<mrs_lib::TimeoutManager> timeout_manager = nullptr;  
    ros::Duration no_message_timeout = mrs_lib::no_timeout;  
    std::function<void(const std::string& topic_name, const ros::Time& last_msg)> timeout_callback = {};  
    bool threadsafe = true;  
    bool autostart = true;  
    uint32_t queue_size = 3;  
    ros::TransportHints transport_hints = ros::TransportHints();  
  };
  
  //}
 
  /* SubscribeHandler class //{ */
  template <typename MessageType>
  class SubscribeHandler
  {
    public:
      using message_type = MessageType;
 
      using timeout_callback_t = std::function<void(const std::string& topic_name, const ros::Time& last_msg)>;
 
      using message_callback_t = std::function<void(typename MessageType::ConstPtr)>;
 
    public:
      virtual typename MessageType::ConstPtr getMsg() {assert(m_pimpl); return m_pimpl->getMsg();};
 
      virtual typename MessageType::ConstPtr peekMsg() const {assert(m_pimpl); return m_pimpl->peekMsg();};
 
      virtual bool hasMsg() const {assert(m_pimpl); return m_pimpl->hasMsg();};
 
      virtual bool newMsg() const {assert(m_pimpl); return m_pimpl->newMsg();};
 
      virtual bool usedMsg() const {assert(m_pimpl); return m_pimpl->usedMsg();};
 
      virtual typename MessageType::ConstPtr waitForNew(const ros::WallDuration& timeout) {assert(m_pimpl); return m_pimpl->waitForNew(timeout);};
 
      virtual ros::Time lastMsgTime() const {assert(m_pimpl); return m_pimpl->lastMsgTime();};
 
      virtual std::string topicName() const {assert(m_pimpl); return m_pimpl->topicName();};
 
      virtual std::string subscribedTopicName() const {assert(m_pimpl); return m_pimpl->m_topic_name;};
 
      virtual uint32_t getNumPublishers() const {assert(m_pimpl); return m_pimpl->getNumPublishers();};
 
      virtual void setNoMessageTimeout(const ros::Duration& timeout) {assert(m_pimpl); return m_pimpl->setNoMessageTimeout(timeout);};
 
      virtual void start() {assert(m_pimpl); return m_pimpl->start();};
 
      virtual void stop() {assert(m_pimpl); return m_pimpl->stop();};
 
    public:
      SubscribeHandler() {};
 
      template<class ... Types>
      SubscribeHandler(
            const SubscribeHandlerOptions& options,
            const std::string& topic_name,
            Types ... args
          )
      :
        SubscribeHandler(
            [options, topic_name]()
            {
              SubscribeHandlerOptions opts = options;
              opts.topic_name = topic_name;
              return opts;
            }(),
            args...
            )
      {
      }
 
      SubscribeHandler(
            const SubscribeHandlerOptions& options,
            const message_callback_t& message_callback = {}
          )
      {
        if (options.threadsafe)
        {
          m_pimpl = std::make_unique<ImplThreadsafe>
            (
              options,
              message_callback
            );
        }
        else
        {
          m_pimpl = std::make_unique<Impl>
            (
              options,
              message_callback
            );
        }
        if (options.autostart)
          start();
      };
 
      template <class ... Types>
      SubscribeHandler(
            const SubscribeHandlerOptions& options,
            const timeout_callback_t& timeout_callback,
            Types ... args
          )
      :
        SubscribeHandler(
            [options, timeout_callback]()
            {
              SubscribeHandlerOptions opts = options;
              opts.timeout_callback = timeout_callback;
              return opts;
            }(),
            args...
            )
      {
      }
 
      template <class ObjectType1, class ... Types>
      SubscribeHandler(
            const SubscribeHandlerOptions& options,
            void (ObjectType1::*const timeout_callback) (const std::string& topic_name, const ros::Time& last_msg),
            ObjectType1* const obj1,
            Types ... args
          )
      :
        SubscribeHandler(
            [options, timeout_callback, obj1]()
            {
              SubscribeHandlerOptions opts = options;
              opts.timeout_callback = timeout_callback == nullptr ? timeout_callback_t() : std::bind(timeout_callback, obj1, std::placeholders::_1, std::placeholders::_2);
              return opts;
            }(),
            args...
            )
      {
      }
 
      template <class ObjectType2, class ... Types>
      SubscribeHandler(
            const SubscribeHandlerOptions& options,
            void (ObjectType2::*const message_callback) (typename MessageType::ConstPtr),
            ObjectType2* const obj2,
            Types ... args
          )
      :
        SubscribeHandler(
            options,
            message_callback == nullptr ? message_callback_t() : std::bind(message_callback, obj2, std::placeholders::_1),
            args...
            )
      {
      }
 
     template <class ObjectType1, class ObjectType2, class ... Types>
     SubscribeHandler(
           const SubscribeHandlerOptions& options,
           void (ObjectType2::*const message_callback) (typename MessageType::ConstPtr),
           ObjectType2* const obj2,
           void (ObjectType1::*const timeout_callback) (const std::string& topic_name, const ros::Time& last_msg),
           ObjectType1* const obj1,
           Types ... args
         )
     :
       SubscribeHandler(
            [options, timeout_callback, obj1]()
            {
              SubscribeHandlerOptions opts = options;
              opts.timeout_callback = timeout_callback == nullptr ? timeout_callback_t() : std::bind(timeout_callback, obj1, std::placeholders::_1, std::placeholders::_2);
              return opts;
            }(),
            message_callback == nullptr ? message_callback_t() : std::bind(message_callback, obj2, std::placeholders::_1),
            args...
            )
     {
     }
 
      template<class ... Types>
      SubscribeHandler(
            const SubscribeHandlerOptions& options,
            const ros::Duration& no_message_timeout,
            Types ... args
          )
      :
        SubscribeHandler(
            [options, no_message_timeout]()
            {
              SubscribeHandlerOptions opts = options;
              opts.no_message_timeout = no_message_timeout;
              return opts;
            }(),
            args...
            )
      {
      }
 
      template <class ... Types>
      SubscribeHandler(
            const SubscribeHandlerOptions& options,
            mrs_lib::TimeoutManager& timeout_manager,
            Types ... args
          )
      :
        SubscribeHandler(
            options,
            timeout_manager = timeout_manager,
            args...
            )
      {
      }
 
      ~SubscribeHandler() = default;
      // delete copy constructor and assignment operator (forbid copying shandlers)
      SubscribeHandler(const SubscribeHandler&) = delete;
      SubscribeHandler& operator=(const SubscribeHandler&) = delete;
      // define only move constructor and assignemnt operator
      SubscribeHandler(SubscribeHandler&& other)
      {
        this->m_pimpl = std::move(other.m_pimpl);
        other.m_pimpl = nullptr;
      }
      SubscribeHandler& operator=(SubscribeHandler&& other)
      {
        this->m_pimpl = std::move(other.m_pimpl);
        other.m_pimpl = nullptr;
        return *this;
      }
 
    private:
      class Impl;
      class ImplThreadsafe;
      std::unique_ptr<Impl> m_pimpl;
  };
  //}
 
  template<typename SubscribeHandler>
  using message_type = typename SubscribeHandler::message_type;
 
  template<typename Class, class ... Types>
  void construct_object(
        Class& object,
        Types ... args
      )
  {
    object = Class(args...);
  }
}
 
#include <mrs_lib/impl/subscribe_handler.hpp>
 
#endif // SUBRSCRIBE_HANDLER_H