MessageTypes.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef MESSAGE_TYPES_H_
#define MESSAGE_TYPES_H_

#include <fesa-core/Core/FesaDefs.h>
#include <fesa-core/Synchronization/MultiplexingContext.h>

#include <string>
#include <vector>
#include <map>

namespace fesa
{
const uint32_t MSG_DATA_SIZE_MAX = 8192;
const std::string NUMBER_SEPARATOR = " ";
const std::string STRING_SEPARATOR = "\n";

typedef enum MessageType
{
        AutomaticNotificationMsg, ManualNotificationMsg, CommandMsg, OnDemandMsg
}MessageType;

class AbstractMessage
{
  public:

    bool operator<(const AbstractMessage& msg) const;

    virtual void serialize(std::ostream& stream);

    AbstractMessage(uint32_t prio, MessageType msgType);

    AbstractMessage(std::istream& stream, MessageType msgType);

    virtual ~AbstractMessage();

    uint32_t prio_;

    MessageType msgType_;
};

inline bool AbstractMessage::operator<(const AbstractMessage& msg) const
{
    return prio_ < msg.prio_;
}

class AutomaticNotificationMessage: public AbstractMessage
{
        public:

                uint32_t notificationID_;

                MultiplexingContext* muxContext_;

                void serialize(std::ostream& stream);

                AutomaticNotificationMessage(const uint32_t& notificationID, MultiplexingContext* muxContext,
                                                uint32_t& prio);

                AutomaticNotificationMessage(std::istream& stream);
};

class ManualNotificationMessage: public AbstractMessage
{
        public:

                std::string className_;

                MultiplexingContext* muxContext_;

                std::map<std::string, std::vector<std::string> > propertiesAndDevicesCol_;

                void serialize(std::ostream& stream);

                void addPropertyAndDevice(const std::string& property, const std::string& device);

                void reset();

                ManualNotificationMessage(const std::string& className);

                ManualNotificationMessage(std::istream& stream);
};

class CommandMessage: public AbstractMessage
{
        public:

                std::string command_;

                std::string parameter1_;

                std::string parameter2_;

                void serialize(std::ostream& stream);

                CommandMessage(const std::string& command, const std::string& parameter1, const std::string& parameter2,
                                                uint32_t& prio);

                CommandMessage(std::istream& stream);
};

class OnDemandMessage: public AbstractMessage
{
        public:

                std::string cycleName_;

                uint32_t payloadSize_;

                char* payload_;

                void serialize(std::ostream& stream);

                OnDemandMessage(const std::string& cycleName, const char* payload, uint32_t payloadSize, uint32_t& prio);
                OnDemandMessage(const OnDemandMessage& msg);

                OnDemandMessage(std::istream& stream);

                ~OnDemandMessage();
};

}//fesa


#endif // MESSAGE_TYPES_H_