VariantMessage.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 <swarmio/Exception.h>
#include <ros/ros.h>
#include <ros/message_traits.h>

namespace swarmros::introspection 
{
    class VariantMessage : public Message
    {
        private:

            swarmio::data::Variant _value;

        public:

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

            VariantMessage() { }

            VariantMessage(const std::string& type, const swarmio::data::Variant& value)
                : Message(type), _value(value) { }

            const swarmio::data::Variant& GetValue() const
            {
                return _value;
            }

            swarmio::data::Variant& GetMutableValue()
            {
                return _value;
            }

            void SetValue(const swarmio::data::Variant& value)
            {
                _value = value;
            }
    };
}

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

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

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

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

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

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

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

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

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