SubscribeR.h

Go to the documentation of this file.

#include <ros/ros.h>
#include <ros/package.h>
#include <std_msgs/String.h>
#include <topic_tools/shape_shifter.h>

class SubscribeR {
public:
        SubscribeR(ros::NodeHandle* handle, const char* cTopic, const char* cMsgType, const char* cMsgDefinition, const char* cMsgMD5){
                m_bNewMessage = false;
                m_bAnyMessage = false;
                m_rosSubscriber = handle->subscribe(cTopic, 1, &SubscribeR::callback, this);

                m_strMsgType            = cMsgType;
                m_strMsgDefinition      = cMsgDefinition;
                m_strMsgMD5                     = cMsgMD5;

                m_uiBufferSize = 10000000;

                m_ui8Buffer = new boost::shared_array<uint8_t> (new uint8_t[m_uiBufferSize]);
                m_isStream  = new ros::serialization::IStream(m_ui8Buffer->get(), m_uiBufferSize);
        };
        ~SubscribeR() {
                delete m_isStream;
                delete m_ui8Buffer;
        };

        void callback(const ros::MessageEvent<topic_tools::ShapeShifter const>& event) {
                m_bNewMessage = true;
                m_bAnyMessage = true;

                m_Event = event;

                // uninitialzed
                if(m_strMsgType.size() == 0){
                        m_strMsgType = m_Event.getMessage()->getDataType();
                        m_strMsgMD5  = m_Event.getMessage()->getMD5Sum();
                        m_strMsgDefinition = m_Event.getMessage()->getMessageDefinition();
                }
        };

        bool hasAnyMessage() { return m_bAnyMessage; };
        bool hasNewMessage() { return m_bNewMessage; };

        const char* getPublisher() {
                return m_Event.getPublisherName().c_str();      };
        const char* getMessageType() {
                return m_strMsgType.c_str();    };
        const char* getMessageDefinition() {
                return m_strMsgDefinition.c_str(); };
        const char* getMessageMD5() {
                return m_strMsgMD5.c_str(); };

        ros::serialization::IStream * getMessageStream(){
                m_bNewMessage = false;

                if(m_isStream->getLength() != m_uiBufferSize){
                        m_isStream->advance(-(m_uiBufferSize-m_isStream->getLength()));
                }

                m_Event.getMessage()->write(*m_isStream);
                m_isStream->advance(-m_Event.getMessage()->size());

                return m_isStream;
        };

private:
        bool m_bNewMessage;
        bool m_bAnyMessage;

        ros::Subscriber m_rosSubscriber;
        std::string m_strMsgType;
        std::string m_strMsgDefinition;
        std::string m_strMsgMD5;

        ros::MessageEvent<topic_tools::ShapeShifter const> m_Event;

        boost::shared_array<uint8_t> *m_ui8Buffer;
        unsigned int m_uiBufferSize;
        ros::serialization::IStream *m_isStream;
};

SubscribeR* rrosSubscriber(ros::NodeHandle* handle,
                                                        const char* topic,
                                                        const char* type,
                                                        const char* msg_def,
                                                        const char* msg_md5);

bool rrosSubscriberHasNewMsg(SubscribeR* subscriber);
bool rrosSubscriberHasAnyMsg(SubscribeR* subscriber);

ros::serialization::IStream* rrosSubscriberGetMessageStream(SubscribeR* subscriber);

const char* rrosSubscriberGetPublisher(SubscribeR* subscriber);
const char* rrosSubscriberGetMessageType(SubscribeR* subscriber);
const char* rrosSubscriberGetMessageMD5(SubscribeR* subscriber);
const char* rrosSubscriberGetMessageDefinition(SubscribeR* subscriber);

bool rros_stream_read_bool(ros::serialization::IStream *s);
signed char rros_stream_read_int8(ros::serialization::IStream *s);
unsigned char rros_stream_read_uint8(ros::serialization::IStream *s);
signed short rros_stream_read_int16(ros::serialization::IStream *s);
unsigned short rros_stream_read_uint16(ros::serialization::IStream *s);
signed int rros_stream_read_int32(ros::serialization::IStream *s);
unsigned int rros_stream_read_uint32(ros::serialization::IStream *s);
signed long long rros_stream_read_int64(ros::serialization::IStream *s);
unsigned long long rros_stream_read_uint64(ros::serialization::IStream *s);
float rros_stream_read_float32(ros::serialization::IStream *s);
double rros_stream_read_float64(ros::serialization::IStream *s);
char* rros_stream_read_string(ros::serialization::IStream *s);

std::vector<signed char>* rros_stream_read_int8_array(ros::serialization::IStream *s, unsigned int size=0);
std::vector<unsigned char>* rros_stream_read_uint8_array(ros::serialization::IStream *s, unsigned int size=0);
std::vector<signed short>* rros_stream_read_int16_array(ros::serialization::IStream *s, unsigned int size=0);
std::vector<unsigned short>* rros_stream_read_uint16_array(ros::serialization::IStream *s, unsigned int size=0);
std::vector<signed int>* rros_stream_read_int32_array(ros::serialization::IStream *s, unsigned int size=0);
std::vector<unsigned int>* rros_stream_read_uint32_array(ros::serialization::IStream *s, unsigned int size=0);
std::vector<signed long long>* rros_stream_read_int64_array(ros::serialization::IStream *s, unsigned int size=0);
std::vector<unsigned long long>* rros_stream_read_uint64_array(ros::serialization::IStream *s, unsigned int size=0);
std::vector<float>* rros_stream_read_float32_array(ros::serialization::IStream *s, unsigned int size=0);
std::vector<double>* rros_stream_read_float64_array(ros::serialization::IStream *s, unsigned int size=0);
std::vector<std::string>* rros_stream_read_string_array(ros::serialization::IStream *s, unsigned int size=0);