MessageType.h

См. документацию.

/* This file is part of the UniSet project
 * Copyright (c) 2002 Free Software Foundation, Inc.
 * Copyright (c) 2002 Pavel Vainerman
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
// --------------------------------------------------------------------------
// -------------------------------------------------------------------------- 
#ifndef MessageType_H_
#define MessageType_H_
// --------------------------------------------------------------------------
#include <sys/time.h>
#include "Configuration.h"
#include "UniSetTypes.h"
#include "IOController_i.hh"

namespace UniSetTypes
{
    class Message
    {
        public:
            enum TypeOfMessage
             {
                Unused, // Сообщение не содержит информации
                SensorInfo,
                SysCommand, // Сообщение содержит системную команду
                Confirm,    // Сообщение содержит подтверждение
                Info,   // Сообщения содержит информацию для оператора (DEPRECATED)
                Timer,  // Сообщения о срабатывании таймера
                Alarm,  // Аварийное сообщение (DEPRECATED)
                DataBase, // (DEPRECATED)
                TheLastFieldOfTypeOfMessage // Обязательно оставьте последним
            };
    
            int type;   // Содержание сообщения (тип)

            enum Priority
            {
                Low,
                Medium,
                High,
                Super
            };

            Priority priority;
            ObjectId node;      // откуда
            ObjectId supplier;  // от кого
            ObjectId consumer;  // кому
            struct timeval tm;

            Message();

            template<class In> 
            static TransportMessage transport(const In& msg)
            {
                TransportMessage tmsg;
                assert(sizeof(UniSetTypes::RawDataOfTransportMessage)>=sizeof(msg));
                memcpy(&tmsg.data,&msg,sizeof(msg));
                return tmsg;
            }
    };
    

    class VoidMessage : public Message
    {
        public:
            VoidMessage( const TransportMessage& tm );
            VoidMessage();
            inline bool operator < ( const VoidMessage& msg ) const
            {
                if( priority != msg.priority )
                    return priority < msg.priority;
    
                if( tm.tv_sec != msg.tm.tv_sec )
                    return tm.tv_sec >= msg.tm.tv_sec;

                return tm.tv_usec >= msg.tm.tv_usec;
            }

            inline TransportMessage transport_msg() const
            {
                return transport(*this);
            }

            UniSetTypes::ByteOfMessage data[sizeof(UniSetTypes::RawDataOfTransportMessage)-sizeof(Message)];
    };

    class SensorMessage : public Message
    {
        public:

            ObjectId id;
            bool state;
            long value;
            bool undefined;

            // время изменения состояния датчика
            long sm_tv_sec;
            long sm_tv_usec;

            UniversalIO::IOTypes sensor_type;
            IOController_i::CalibrateInfo ci;
            
            // для пороговых датчиков
            bool threshold;
            UniSetTypes::ThresholdId tid;

            SensorMessage();
            SensorMessage(ObjectId id, bool state, Priority priority = Message::Medium, 
                            UniversalIO::IOTypes st = UniversalIO::DigitalInput,
                            ObjectId consumer=UniSetTypes::DefaultObjectId);

            SensorMessage(ObjectId id, long value, const IOController_i::CalibrateInfo& ci,
                            Priority priority = Message::Medium, 
                            UniversalIO::IOTypes st = UniversalIO::AnalogInput,
                            ObjectId consumer=UniSetTypes::DefaultObjectId);

            SensorMessage(const VoidMessage *msg);
            inline TransportMessage transport_msg() const
            {
                return transport(*this);
            }
    };

    class SystemMessage : public Message
    {
        public:
            enum Command
            {
                StartUp,    
                FoldUp,     
                Finish,     
                WatchDog,   
                ReConfiguration,        
                NetworkInfo,            
                LogRotate   
            };
            
            SystemMessage();
            SystemMessage(Command command, Priority priority = Message::High, 
                            ObjectId consumer=UniSetTypes::DefaultObjectId);
            SystemMessage(const VoidMessage *msg);

            inline TransportMessage transport_msg() const
            {
                return transport(*this);
            }

            int command;
            long data[2];
    };

    class InfoMessage : public Message
    {
        public:
            enum Character{
                                Normal,
                                Warning
                            };
            InfoMessage();
            InfoMessage(ObjectId id, const std::string str, ObjectId node = conf->getLocalNode(), 
                        Character ch = InfoMessage::Normal, 
                        Priority priority = Message::Medium, ObjectId consumer=UniSetTypes::DefaultObjectId);

            InfoMessage(ObjectId id, MessageCode icode, ObjectId node = conf->getLocalNode(), 
                        Character ch = InfoMessage::Normal, 
                        Priority priority = Message::Medium, ObjectId consumer=UniSetTypes::DefaultObjectId);

            InfoMessage(const VoidMessage *msg);

            inline TransportMessage transport_msg() const
            {
                return transport(*this);
            }

            ObjectId id;                    
            MessageCode infocode;           
            Character character;            
            bool broadcast;                 
            bool route;

            // т.к. размер транспортных сообщений ограничен, то 
            // мы можем высчитать максимальную длину текстового сообщения
            // считаем размер текстового сообщения по формуле
            // размерТраснпортного - РазмерБазового-суммаВсехВспомПолейДляДанногоСообщения-1
            // всё это конечно не очень хорошо, но пока так.
//          static const int size_of_info_message = sizeof(UniSetTypes::RawDataOfTransportMessage)-sizeof(Message)-sizeof(ObjectId)-sizeof(MessageCode)-sizeof(Character)-2*sizeof(bool)-1;
            // пока делаем размер постоянным
            static const unsigned int size_of_info_message = 55;
            char message[size_of_info_message]; 
    };

    class AlarmMessage : public Message
    {
        public:
            enum Character{
                                Normal,
                                Attention,
                                Warning,
                                Alarm
                            };

            AlarmMessage();
            AlarmMessage(ObjectId id, const std::string str, ObjectId node = conf->getLocalNode(), 
                        Character ch = AlarmMessage::Alarm, 
                        Priority prior = Message::Medium, ObjectId cons=UniSetTypes::DefaultObjectId);

            AlarmMessage(ObjectId id, const std::string str, MessageCode ccode, 
                            ObjectId node = conf->getLocalNode(),               
                            Character ch = AlarmMessage::Alarm, 
                            Priority prior = Message::Medium, ObjectId cons=UniSetTypes::DefaultObjectId);

            AlarmMessage(ObjectId id,  MessageCode acode, MessageCode ccode, 
                            ObjectId node=conf->getLocalNode(), 
                            Character ch=AlarmMessage::Alarm, 
                            Priority prior=Message::Medium, 
                            ObjectId cons=UniSetTypes::DefaultObjectId);

            AlarmMessage(const VoidMessage *msg);

            inline TransportMessage transport_msg() const
            {
                return transport(*this);
            }
            
            ObjectId id;                    
            MessageCode alarmcode;          
            MessageCode causecode;          
            Character character;            
            bool broadcast;                 
            bool route;


            // т.к. размер транспортных сообщений ограничен, то 
            // мы можем высчитать максимальную длину текстового сообщения
            // считаем размер текстового сообщения по формуле
            // размерТраснпортного - РазмерБазового-суммаВсехВспомПолейДляДанногоСообщения-1
            // всё это конечно не очень хорошо, но пока так.
            // sizeof(UniSetTypes::RawDataOfTransportMessage)-sizeof(Message)-sizeof(ObjectId)-2*sizeof(MessageCode)-sizeof(Character)-2*sizeof(bool)-1

            // пока делаем размер постоянным
            static const unsigned int size_of_alarm_message = 55;
            char message[size_of_alarm_message];    
    };

    class DBMessage : public Message
    {
        public:
            enum TypeOfQuery
            {
                Query,
                Update,
                Insert
            };
            
            DBMessage();

            DBMessage(TypeOfQuery qtype, const std::string query, TypeOfMessage tblid,
                        Priority prior=Message::Low, 
                        ObjectId cons=UniSetTypes::DefaultObjectId);
            DBMessage(const VoidMessage *msg);

            inline TransportMessage transport_msg() const
            {
                return transport(*this);
            }
            DBMessage::TypeOfQuery qtype;   // тип данных в запросе
            TypeOfMessage tblid;            // идентификатор таблицы


            // т.к. размер трансопртынх сообщений ограничен, то 
            // мы можем высчитать максимальнйю длину текстового запроса
            // считаем размер текстового сообщения по формуле
            // размерТраснпортного - РазмерБазового-суммаВсехВспомПолейДляДанногоСообщения-1
            // всё это конечно не очень хорошо, но пока так.
            // sizeof(UniSetTypes::RawDataOfTransportMessage)-sizeof(Message)-sizeof(DBMessage::TypeOfQuery)-sizeof(TypeOfMessage)-1

            static const unsigned int size_of_query = 55;
            char data[size_of_query];   
    };
    
    class TimerMessage : public Message
    {
        public:
            TimerMessage();
            TimerMessage(UniSetTypes::TimerId id, Priority prior = Message::High,
                            ObjectId cons=UniSetTypes::DefaultObjectId);
            TimerMessage(const VoidMessage *msg);
            inline TransportMessage transport_msg() const
            {
                return transport(*this);
            }
            
            UniSetTypes::TimerId id; 
    };

    class ConfirmMessage: public Message
    {
        public:

            inline TransportMessage transport_msg() const
            {
                return transport(*this);
            }
            
            ConfirmMessage( const VoidMessage *msg );
            
            ConfirmMessage(long in_sensor_id,
                    double in_value,
                    time_t in_time,
                    time_t in_time_usec,
                    time_t in_confirm,
                    Priority in_priority = Message::Medium);
                    

            long sensor_id;   /* ID датчика */
            double value;     /* значение датчика */
            time_t time;      /* время, когда датчик получил сигнал */
            time_t time_usec; /* время в микросекундах */
            time_t confirm;   /* время, когда произошло квитирование */

            bool broadcast;

            bool route;

        protected:
            ConfirmMessage();
    };

}
// --------------------------------------------------------------------------
#endif // MessageType_H_