EventMessage.h

Go to the documentation of this file.

#pragma once

#include <swarmros/introspection/Message.h>
#include <swarmros/introspection/MessageSerializer.h>
#include <swarmros/introspection/RootFieldStack.h>
#include <swarmros/EventHeader.h>

namespace swarmros::bridge 
{
    class EventMessage : public introspection::Message
    {
        private:

            EventHeader _eventHeader;

            swarmio::data::Map _parameters;

        public:

            static bool IsEventSerializer(const introspection::MessageSerializer& serializer)
            {
                bool hasHeader = false;
                serializer.EnumerateFields([&hasHeader, &serializer](unsigned n, const introspection::Field& field) {
                    if (n == 0 && serializer.HasHeader())
                    {
                        // Skip this field
                        return true;
                    }
                    else if (field.GetSerializer().GetFullName() == "swarmros/EventHeader")
                    {
                        // We found it!
                        hasHeader = true;
                        return false;
                    }
                    else
                    {
                        // No point looking anymore
                        return false;
                    }                    
                });
                return hasHeader;
            }

            typedef boost::shared_ptr<EventMessage const> ConstPtr;
 
            typedef boost::shared_ptr<EventMessage> Ptr;

            EventMessage() { }

            EventMessage(const std::string& type, const std::string& name, const std::string& node, const swarmio::data::Map& parameters)
                : Message(type), _parameters(parameters)
            {
                _eventHeader.name = name;
                _eventHeader.node = node;   
            }

            const std::string& GetName() const
            {
                return _eventHeader.name;
            }

            void SetName(const std::string& name)
            {
                _eventHeader.name = name;
            }

            const std::string& GetNode() const
            {
                return _eventHeader.node;
            }

            void SetNode(const std::string& node)
            {
                _eventHeader.node = node;
            }

            const swarmio::data::Map& GetParameters() const
            {
                return _parameters;
            }

            swarmio::data::Map& GetMutableParameters()
            {
                return _parameters;
            }

            void SetParameters(const swarmio::data::Map& parameters)
            {
                _parameters = parameters;
            }

            const EventHeader& GetEventHeader() const
            {
                return _eventHeader;
            }

            EventHeader& GetMutableEventHeader()
            {
                return _eventHeader;
            }
    };
}

namespace ros
{
    namespace message_traits
    {
        template<> 
        struct IsMessage<swarmros::bridge::EventMessage> : public IsMessage<swarmros::introspection::Message> { };

        template<> 
        struct IsMessage<const swarmros::bridge::EventMessage> : public IsMessage<const swarmros::introspection::Message> { };
 
        template<> 
        struct MD5Sum<swarmros::bridge::EventMessage> : public MD5Sum<swarmros::introspection::Message> { };
        
        template<> 
        struct DataType<swarmros::bridge::EventMessage> : public DataType<swarmros::introspection::Message> { };
 
        template<> 
        struct Definition<swarmros::bridge::EventMessage> : public Definition<swarmros::introspection::Message> { };
    }

    namespace serialization
    {
        template<>
        struct PreDeserialize<swarmros::bridge::EventMessage>
        {
            static void notify(const PreDeserializeParams<swarmros::bridge::EventMessage>& params)
            {
                params.message->SetType((*params.connection_header)["type"]);
            }
        };

        template<> 
        struct Serializer<swarmros::bridge::EventMessage>
        {
            inline static uint32_t serializedLength(const swarmros::bridge::EventMessage& message) 
            {
                auto serializer = message.GetSerializer();
                if (serializer != nullptr)
                {
                    // Handle header
                    uint32_t headerLength = Serializer<swarmros::introspection::Message>::serializedLength(message);

                    // Handle event header
                    headerLength += Serializer<swarmros::EventHeader>::serializedLength(message.GetEventHeader());

                    // Handle contents
                    swarmros::introspection::RootFieldStack stack(serializer->GetFullName());
                    return headerLength + serializer->CalculateSerializedLength(message.GetParameters(), serializer->HasHeader() ? 2 : 1, stack);
                }
                else
                {
                    throw Exception("Trying to serialize EventMessage without serializer");
                }
            }

            template<typename Stream>
            inline static void write(Stream& stream, const swarmros::bridge::EventMessage& message) 
            {
                auto serializer = message.GetSerializer();
                if (serializer != nullptr)
                {
                    // Handle header
                    Serializer<swarmros::introspection::Message>::write(stream, message);

                    // Handle event header
                    Serializer<swarmros::EventHeader>::write(stream, message.GetEventHeader());

                    // Handle contents
                    swarmros::introspection::RootFieldStack stack(serializer->GetFullName());
                    serializer->Serialize(dynamic_cast<ros::serialization::OStream&>(stream), message.GetParameters(), serializer->HasHeader() ? 2 : 1, stack);
                }
                else
                {
                    throw Exception("Trying to serialize EventMessage without serializer");
                }
            }

            template<typename Stream>
            inline static void read(Stream& stream, swarmros::bridge::EventMessage& message)
            {
                auto serializer = message.GetSerializer();
                if (serializer != nullptr)
                {
                    // Handle header
                    Serializer<swarmros::introspection::Message>::read(stream, message);

                    // Handle event header
                    Serializer<swarmros::EventHeader>::read(stream, message.GetMutableEventHeader());

                    // Handle contents
                    swarmros::introspection::RootFieldStack stack(serializer->GetFullName());
                    serializer->Deserialize(dynamic_cast<ros::serialization::IStream&>(stream), message.GetMutableParameters(), serializer->HasHeader() ? 2 : 1, stack);
                }
                else
                {
                    throw Exception("Trying to deserialize EventMessage without serializer");
                }
            }
        };
    }
}