Message.h

Go to the documentation of this file.

#pragma once

#include <swarmros/introspection/MessageSerializer.h>
#include <swarmros/Exception.h>
#include <ros/ros.h>
#include <ros/message_traits.h>
#include <std_msgs/Header.h>

namespace swarmros::introspection 
{
    class Message
    {
        private:

            const MessageSerializer* _serializer;

            std::string _type;

            std_msgs::Header _header;       

        protected:

            Message() 
                : _serializer(nullptr), _type("*") { }

            Message(const std::string& type)
            {
                SetType(type);
            }

        public:

            void SetType(const std::string& type)
            {
                _serializer = &MessageSerializer::MessageSerializerForType(type, "swarmros");
                _type = _serializer->GetFullName();
            }

            const std::string& GetType() const
            {
                return _type;
            }

            void EraseType()
            {
                _serializer = nullptr;
                _type = "*";
            }

            const MessageSerializer* GetSerializer() const
            {
                return _serializer;
            }

            const std_msgs::Header& GetHeader() const
            {
                return _header;
            }

            std_msgs::Header& GetMutableHeader()
            {
                return _header;
            }
    };
}

namespace ros::message_traits
{
    template<> 
    struct IsMessage<swarmros::introspection::Message> : TrueType { };

    template<> 
    struct IsMessage<const swarmros::introspection::Message> : TrueType { };

    template<> 
    struct MD5Sum<swarmros::introspection::Message>
    {
        static const char* value(const swarmros::introspection::Message& message) 
        { 
            auto serializer = message.GetSerializer();
            if (serializer != nullptr)
            {
                return serializer->GetHash().c_str();
            }
            else
            {
                throw Exception("Trying to serialize Message without serializer");
            }
        }

        static const char* value() 
        { 
            return "*"; 
        }
    };

    template<> 
    struct DataType<swarmros::introspection::Message>
    {
        static const char* value(const swarmros::introspection::Message& message) 
        {
            auto serializer = message.GetSerializer();
            if (serializer != nullptr)
            {
                return message.GetType().c_str();
            }
            else
            {
                throw Exception("Trying to serialize Message without serializer");
            }             
        }

        static const char* value() 
        {
                return "*"; 
        }
    };

    template<> 
    struct Definition<swarmros::introspection::Message>
    {
        static const char* value(const swarmros::introspection::Message& message) 
        {
            auto serializer = message.GetSerializer();
            if (serializer != nullptr)
            {
                return serializer->GetCanonicalDefinition().c_str();
            }
            else
            {
                throw Exception("Trying to serialize Message without serializer");
            }
        }
    };
}

namespace ros::serialization
{
    template<> 
    struct Serializer<swarmros::introspection::Message>
    {
        inline static uint32_t serializedLength(const swarmros::introspection::Message& message) 
        {
            auto serializer = message.GetSerializer();
            if (serializer != nullptr)
            {
                if (serializer->HasHeader())
                {
                    return Serializer<std_msgs::Header>::serializedLength(message.GetHeader());
                }
                else
                {
                    return 0;
                }
            }
            else
            {
                throw Exception("Trying to serialize VariantMessage without serializer");
            }
        }

        template<typename Stream>
        inline static void write(Stream& stream, const swarmros::introspection::Message& message) 
        {
            auto serializer = message.GetSerializer();
            if (serializer != nullptr)
            {
                if (serializer->HasHeader())
                {
                    return Serializer<std_msgs::Header>::write(stream, message.GetHeader());
                }
            }
            else
            {
                throw Exception("Trying to serialize VariantMessage without serializer");
            }
        }

        template<typename Stream>
        inline static void read(Stream& stream, swarmros::introspection::Message& message)
        {
            auto serializer = message.GetSerializer();
            if (serializer != nullptr)
            {
                if (serializer->HasHeader())
                {
                    return Serializer<std_msgs::Header>::read(stream, message.GetMutableHeader());
                }
            }
            else
            {
                throw Exception("Trying to deserialize VariantMessage without serializer");
            }
        }
    };
}