node_protocol.h

//========================================================================
#ifndef comfrm_cls_NodeProtocolH
#define comfrm_cls_NodeProtocolH
//========================================================================
#include "anymap.h"
#include "streamtools.h"

#include <string>

#define MAX_APP_SID_SIZE 100
//========================================================================
namespace com {
    namespace interproc {
        #pragma pack(push, 1)
        struct NodeProtocolHeader
        {
            char m_version;
            char m_messageType;
            unsigned int m_bodySize;
        };
        #pragma pack(pop)

        struct NodeHandshake
        {
            NodeHandshake()
                : m_appSid("")
            {}

            NodeHandshake( const std::string& p_appSid )
                : m_appSid(p_appSid)
            {}

            friend std::ostream& operator<<(std::ostream& o_out, const NodeHandshake& p_reg);
            friend std::istream& operator>>(std::istream& o_in, NodeHandshake& o_reg);

            std::string m_appSid;
        };

        // TODO: по сути это набор функций, оформленных в класс. Нужно что-то сделать с этим
        // Как вариант, все засунуть в namespace com::interproc::protocol
        class NodeProtocol
        {
            // TODO: C++11 specific
            enum ProtocolVersion : char
            {
                pv01 = 0x01
            };

        public:
            enum MessageType : char
            {
                mtHandshake,
                mtAnyMap,
            };

            NodeProtocol();
            ~NodeProtocol();

            bool readHeader(std::vector< char >& p_bytearray, NodeProtocolHeader& o_header);

            template< typename T >
            size_t read(std::vector< char >& p_bytearray, std::string& o_senderAppSid, std::string& o_receiverAppSid, T& o_data) // возаращет кол-во прочитанных байт
            {
                VectorStream vs(p_bytearray);
                NodeProtocolHeader header;
                vs.read((char*) &header, sizeof(header));
                if (header.m_messageType != getTypeByData< T >())
                    return 0;

                // Вычитываем sender app sid
                int senderAppSidSize;
                vs.read((char*) &senderAppSidSize, sizeof(senderAppSidSize));
                char* senderAppSidBuf = new char[senderAppSidSize];
                vs.read(senderAppSidBuf, senderAppSidSize);
                o_senderAppSid = std::string(senderAppSidBuf, senderAppSidSize);
                delete[] senderAppSidBuf;

                // Вычитываем receiver app sid
                int receiverAppSidSize;
                vs.read((char*) &receiverAppSidSize, sizeof(receiverAppSidSize));
                char* receiverAppSidBuf = new char[receiverAppSidSize];
                vs.read(receiverAppSidBuf, receiverAppSidSize);
                o_receiverAppSid = std::string(receiverAppSidBuf, receiverAppSidSize);
                delete[] receiverAppSidBuf;

                // Вычитываем собственно данные
                vs >> o_data;
                return p_bytearray.size() - vs.bytesAvailable();
            }

            template< typename T >
            void write(const std::string& p_senderAppSid, const std::string& p_receiverAppSid, const T& p_data, std::vector< char >& o_bytearray)
            {
                NodeProtocolHeader header = {pv01, getTypeByData< T >(), 0}; // bodySize = 0, т.к. он будет потом перезаписан
                VectorStream vs(o_bytearray);
                vs.write((const char*) &header, sizeof(header));

                int senderAppSidSize = p_senderAppSid.size();
                vs.write((const char*) &senderAppSidSize, sizeof(senderAppSidSize));
                vs.write(p_senderAppSid.c_str(), senderAppSidSize);

                int receiverAppSidSize = p_receiverAppSid.size();
                vs.write((const char*) &receiverAppSidSize, sizeof(receiverAppSidSize));
                vs.write(p_receiverAppSid.c_str(), receiverAppSidSize);

                vs << p_data;
                vs.flush();

                finalize(o_bytearray);
            }

        private:
            template< typename T >
            inline MessageType getTypeByData();

            void finalize(std::vector< char >& o_bytearray);
        };
    }
}
//========================================================================
#endif
//========================================================================