publisher_plugin.h

Go to the documentation of this file.

#ifndef MESSAGE_TRANSPORT_PUBLISHER_PLUGIN_H
#define MESSAGE_TRANSPORT_PUBLISHER_PLUGIN_H

#include <ros/ros.h>
#include "message_transport/single_subscriber_publisher.h"

namespace message_transport {

        class PublisherPluginGen : boost::noncopyable
        {
                public:
                        virtual ~PublisherPluginGen() {}

                        virtual std::string getTransportName() const = 0;

                        virtual void advertise(ros::NodeHandle & nh, const std::string& base_topic, uint32_t queue_size,
                                        bool latch = true) = 0;

                        virtual uint32_t getNumSubscribers() const = 0;

                        virtual std::string getTopic() const = 0;

                        virtual void shutdown() = 0;

                        static std::string getLookupName(const std::string& transport_name)
                        {
                                return transport_name + "_pub";
                        }

                protected:
        };

        template <class M>
                class PublisherPlugin : public PublisherPluginGen
        {
                public:
                        virtual ~PublisherPlugin() {}

                        virtual void advertise(ros::NodeHandle & nh, const std::string& base_topic, uint32_t queue_size,
                                        bool latch = true) {
                                advertiseImpl(nh,base_topic, queue_size, 
                                                typename message_transport::SingleSubscriberPublisher<M>::StatusCB(),
                                                typename message_transport::SingleSubscriberPublisher<M>::StatusCB(), ros::VoidPtr(), latch);

                        }

                        void advertise(ros::NodeHandle & nh, const std::string& base_topic, uint32_t queue_size,
                                        const typename message_transport::SingleSubscriberPublisher<M>::StatusCB& connect_cb,
                                        const typename message_transport::SingleSubscriberPublisher<M>::StatusCB& disconnect_cb = SingleSubscriberPublisher<M>::StatusCB(),
                                        const ros::VoidPtr& tracked_object = ros::VoidPtr(), bool latch = true)
                        {
                                advertiseImpl(nh,base_topic, queue_size, 
                                                connect_cb, disconnect_cb, tracked_object, latch);
                        }

                        virtual void publish(const M& message) const = 0;

                        virtual void publish(const typename M::ConstPtr& message) const
                        {
                                publish(*message);
                        }

                protected:
                        virtual void advertiseImpl(ros::NodeHandle & nh, const std::string& base_topic, uint32_t queue_size,
                                        const typename message_transport::SingleSubscriberPublisher<M>::StatusCB& connect_cb,
                                        const typename message_transport::SingleSubscriberPublisher<M>::StatusCB& disconnect_cb,
                                        const ros::VoidPtr& tracked_object, bool latch) = 0;
        };

} //namespace message_transport

#endif