lazy_subscriber.hpp

Go to the documentation of this file.

#pragma once
 
// SPDX-License-Identifier: BSD-3-Clause
// SPDX-FileCopyrightText: Czech Technical University in Prague
 
#include <functional>
#include <memory>
#include <mutex>
#include <string>
 
#include <boost/functional.hpp>
 
#include <ros/node_handle.h>
#include <ros/publisher.h>
#include <ros/single_subscriber_publisher.h>
#include <ros/subscriber.h>
 
#include <cras_cpp_common/log_utils.h>
#include <cras_cpp_common/log_utils/node.h>
 
namespace cras
{
 
class ConditionalSubscriber : public ::cras::HasLogger
{
public:
  typedef ::std::function<void(::ros::Subscriber& sub)> ConnectFn;
 
  typedef ::std::function<void(::ros::Subscriber& sub)> DisconnectFn;
 
  ConditionalSubscriber(ConnectFn connectFn, DisconnectFn disconnectFn,
    const ::cras::LogHelperPtr& logHelper = ::std::make_shared<::cras::NodeLogHelper>());
 
  explicit ConditionalSubscriber(ConnectFn connectFn,
    const ::cras::LogHelperPtr& logHelper = ::std::make_shared<::cras::NodeLogHelper>());
 
  virtual ~ConditionalSubscriber();
 
  bool isLazy() const;
 
  void setLazy(bool lazy);
 
  bool isSubscribed() const;
 
protected:
  virtual bool shouldBeSubscribed() const = 0;
 
  void updateSubscription();
 
  void updateSubscriptionNoLock();
 
  void connectNoLock();
 
  void disconnectNoLock();
 
  ::ros::Subscriber sub;
 
  bool lazy {true};
 
  bool subscribed {false};
 
  ConnectFn connectFn;
 
  DisconnectFn disconnectFn;
 
  mutable ::std::mutex connectMutex;
};
 
template<typename PublisherMsgType>
class LazySubscriberBase : public ::cras::ConditionalSubscriber
{
public:
  LazySubscriberBase(::ros::NodeHandle publisherNh, const ::std::string& publisherTopic,
    typename ::cras::ConditionalSubscriber::ConnectFn connectFn,
    typename ::cras::ConditionalSubscriber::DisconnectFn disconnectFn,
    const ::cras::LogHelperPtr& logHelper = ::std::make_shared<::cras::NodeLogHelper>());
 
  LazySubscriberBase(::ros::NodeHandle publisherNh, const ::std::string& publisherTopic,
    typename ::cras::ConditionalSubscriber::ConnectFn connectFn,
    const ::cras::LogHelperPtr& logHelper = ::std::make_shared<::cras::NodeLogHelper>());
 
protected:
  void connectCb(const ::ros::SingleSubscriberPublisher&);
 
  bool shouldBeSubscribed() const override;
 
  ::ros::Publisher pub;
};
 
template<typename PublisherMsgType, typename CallbackType = const PublisherMsgType&>
class LazySubscriber : public ::cras::LazySubscriberBase<PublisherMsgType>
{
public:
  LazySubscriber(::ros::NodeHandle publisherNh, const ::std::string& publisherTopic,
                 ::ros::NodeHandle subscriberNh, const ::std::string& subscriberTopic, size_t subscriberQueueSize,
                 ::boost::function<void(CallbackType)> subscriberCallback, ::ros::SubscribeOptions subscribeOptions,
                 const ::cras::LogHelperPtr& logHelper = ::std::make_shared<::cras::NodeLogHelper>());
 
  LazySubscriber(::ros::NodeHandle publisherNh, const ::std::string& publisherTopic,
                 ::ros::NodeHandle subscriberNh, const ::std::string& subscriberTopic, size_t subscriberQueueSize,
                 ::boost::function<void(CallbackType)> subscriberCallback,
                 const ::cras::LogHelperPtr& logHelper = ::std::make_shared<::cras::NodeLogHelper>());
};
 
}
 
#include "impl/lazy_subscriber.hpp"