UniSet  1.4.0
MessageType.h
См. документацию.
00001 /* This file is part of the UniSet project
00002  * Copyright (c) 2002 Free Software Foundation, Inc.
00003  * Copyright (c) 2002 Pavel Vainerman
00004  *
00005  * This program is free software; you can redistribute it and/or modify
00006  * it under the terms of the GNU General Public License as published by
00007  * the Free Software Foundation; either version 2 of the License, or
00008  * (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License
00016  * along with this program; if not, write to the Free Software
00017  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00018  */
00019 // --------------------------------------------------------------------------
00024 // -------------------------------------------------------------------------- 
00025 #ifndef MessageType_H_
00026 #define MessageType_H_
00027 // --------------------------------------------------------------------------
00028 #include <sys/time.h>
00029 #include "Configuration.h"
00030 #include "UniSetTypes.h"
00031 #include "IOController_i.hh"
00032 
00033 namespace UniSetTypes
00034 {
00035     class Message
00036     {
00037         public:
00038             enum TypeOfMessage
00039              {
00040                 Unused, // Сообщение не содержит информации
00041                 SensorInfo,
00042                 SysCommand, // Сообщение содержит системную команду
00043                 Confirm,    // Сообщение содержит подтверждение
00044                 Info,   // Сообщения содержит информацию для оператора
00045                 Timer,  // Сообщения о срабатывании таймера
00046                 Alarm,  // Аварийное сообщение
00047                 DataBase,
00048                 TheLastFieldOfTypeOfMessage // Обязательно оставьте последним
00049             };
00050     
00051             int type;   // Содержание сообщения (тип)
00052 
00053             enum Priority
00054             {
00055                 Low,
00056                 Medium,
00057                 High,
00058                 Super
00059             };
00060 
00061             Priority priority;
00062             ObjectId node;      // откуда
00063             ObjectId supplier;  // от кого
00064             ObjectId consumer;  // кому
00065             struct timeval tm;
00066 
00067             Message();
00068 
00069             template<class In> 
00070             static TransportMessage transport(const In& msg)
00071             {
00072                 TransportMessage tmsg;
00073                 assert(sizeof(UniSetTypes::RawDataOfTransportMessage)>=sizeof(msg));
00074                 memcpy(&tmsg.data,&msg,sizeof(msg));
00075                 return tmsg;
00076             }
00077     };
00078     
00079 
00080     class VoidMessage : public Message
00081     {
00082         public:
00083             VoidMessage( const TransportMessage& tm );
00084             VoidMessage();
00085             inline bool operator < ( const VoidMessage& msg ) const
00086             {
00087                 if( priority != msg.priority )
00088                     return priority < msg.priority;
00089     
00090                 if( tm.tv_sec != msg.tm.tv_sec )
00091                     return tm.tv_sec >= msg.tm.tv_sec;
00092 
00093                 return tm.tv_usec >= msg.tm.tv_usec;
00094             }
00095 
00096             inline TransportMessage transport_msg() const
00097             {
00098                 return transport(*this);
00099             }
00100 
00101             UniSetTypes::ByteOfMessage data[sizeof(UniSetTypes::RawDataOfTransportMessage)-sizeof(Message)];
00102     };
00103 
00105     class SensorMessage : public Message
00106     {
00107         public:
00108 
00109             ObjectId id;
00110             bool state;
00111             long value;
00112             bool undefined;
00113 
00114             // время изменения состояния датчика
00115             long sm_tv_sec;
00116             long sm_tv_usec;
00117 
00118             UniversalIO::IOTypes sensor_type;
00119             IOController_i::CalibrateInfo ci;
00120             
00121             // для пороговых датчиков
00122             bool threshold;
00123             UniSetTypes::ThresholdId tid;
00124 
00125             SensorMessage();
00126             SensorMessage(ObjectId id, bool state, Priority priority = Message::Medium, 
00127                             UniversalIO::IOTypes st = UniversalIO::DigitalInput,
00128                             ObjectId consumer=UniSetTypes::DefaultObjectId);
00129 
00130             SensorMessage(ObjectId id, long value, const IOController_i::CalibrateInfo& ci,
00131                             Priority priority = Message::Medium, 
00132                             UniversalIO::IOTypes st = UniversalIO::AnalogInput,
00133                             ObjectId consumer=UniSetTypes::DefaultObjectId);
00134 
00135             SensorMessage(const VoidMessage *msg);
00136             inline TransportMessage transport_msg() const
00137             {
00138                 return transport(*this);
00139             }
00140     };
00141 
00143     class SystemMessage : public Message
00144     {
00145         public:
00146             enum Command
00147             {
00148                 StartUp,    
00149                 FoldUp,     
00150                 Finish,     
00151                 WatchDog,   
00152                 ReConfiguration,        
00153                 NetworkInfo,            
00158                 LogRotate   
00159             };
00160             
00161             SystemMessage();
00162             SystemMessage(Command command, Priority priority = Message::High, 
00163                             ObjectId consumer=UniSetTypes::DefaultObjectId);
00164             SystemMessage(const VoidMessage *msg);
00165 
00166             inline TransportMessage transport_msg() const
00167             {
00168                 return transport(*this);
00169             }
00170 
00171             int command;
00172             long data[2];
00173     };
00174 
00176     class InfoMessage : public Message
00177     {
00178         public:
00179             enum Character{
00180                                 Normal,
00181                                 Warning
00182                             };
00183             InfoMessage();
00184             InfoMessage(ObjectId id, const std::string str, ObjectId node = conf->getLocalNode(), 
00185                         Character ch = InfoMessage::Normal, 
00186                         Priority priority = Message::Medium, ObjectId consumer=UniSetTypes::DefaultObjectId);
00187 
00188             InfoMessage(ObjectId id, MessageCode icode, ObjectId node = conf->getLocalNode(), 
00189                         Character ch = InfoMessage::Normal, 
00190                         Priority priority = Message::Medium, ObjectId consumer=UniSetTypes::DefaultObjectId);
00191 
00192             InfoMessage(const VoidMessage *msg);
00193 
00194             inline TransportMessage transport_msg() const
00195             {
00196                 return transport(*this);
00197             }
00198 
00199             ObjectId id;                    
00200             MessageCode infocode;           
00201             Character character;            
00202             bool broadcast;                 
00209             bool route;
00210 
00211             // т.к. размер транспортных сообщений ограничен, то 
00212             // мы можем высчитать максимальную длину текстового сообщения
00213             // считаем размер текстового сообщения по формуле
00214             // размерТраснпортного - РазмерБазового-суммаВсехВспомПолейДляДанногоСообщения-1
00215             // всё это конечно не очень хорошо, но пока так.
00216 //          static const int size_of_info_message = sizeof(UniSetTypes::RawDataOfTransportMessage)-sizeof(Message)-sizeof(ObjectId)-sizeof(MessageCode)-sizeof(Character)-2*sizeof(bool)-1;
00217             // пока делаем размер постоянным
00218             static const unsigned int size_of_info_message = 55;
00219             char message[size_of_info_message]; 
00220     };
00221 
00223     class AlarmMessage : public Message
00224     {
00225         public:
00226             enum Character{
00227                                 Normal,
00228                                 Attention,
00229                                 Warning,
00230                                 Alarm
00231                             };
00232 
00233             AlarmMessage();
00234             AlarmMessage(ObjectId id, const std::string str, ObjectId node = conf->getLocalNode(), 
00235                         Character ch = AlarmMessage::Alarm, 
00236                         Priority prior = Message::Medium, ObjectId cons=UniSetTypes::DefaultObjectId);
00237 
00238             AlarmMessage(ObjectId id, const std::string str, MessageCode ccode, 
00239                             ObjectId node = conf->getLocalNode(),               
00240                             Character ch = AlarmMessage::Alarm, 
00241                             Priority prior = Message::Medium, ObjectId cons=UniSetTypes::DefaultObjectId);
00242 
00243             AlarmMessage(ObjectId id,  MessageCode acode, MessageCode ccode, 
00244                             ObjectId node=conf->getLocalNode(), 
00245                             Character ch=AlarmMessage::Alarm, 
00246                             Priority prior=Message::Medium, 
00247                             ObjectId cons=UniSetTypes::DefaultObjectId);
00248 
00249             AlarmMessage(const VoidMessage *msg);
00250 
00251             inline TransportMessage transport_msg() const
00252             {
00253                 return transport(*this);
00254             }
00255             
00256             ObjectId id;                    
00257             MessageCode alarmcode;          
00258             MessageCode causecode;          
00259             Character character;            
00260             bool broadcast;                 
00267             bool route;
00268 
00269 
00270             // т.к. размер транспортных сообщений ограничен, то 
00271             // мы можем высчитать максимальную длину текстового сообщения
00272             // считаем размер текстового сообщения по формуле
00273             // размерТраснпортного - РазмерБазового-суммаВсехВспомПолейДляДанногоСообщения-1
00274             // всё это конечно не очень хорошо, но пока так.
00275             // sizeof(UniSetTypes::RawDataOfTransportMessage)-sizeof(Message)-sizeof(ObjectId)-2*sizeof(MessageCode)-sizeof(Character)-2*sizeof(bool)-1
00276 
00277             // пока делаем размер постоянным
00278             static const unsigned int size_of_alarm_message = 55;
00279             char message[size_of_alarm_message];    
00280     };
00281 
00283     class DBMessage : public Message
00284     {
00285         public:
00286             enum TypeOfQuery
00287             {
00288                 Query,
00289                 Update,
00290                 Insert
00291             };
00292             
00293             DBMessage();
00294 
00295             DBMessage(TypeOfQuery qtype, const std::string query, TypeOfMessage tblid,
00296                         Priority prior=Message::Low, 
00297                         ObjectId cons=UniSetTypes::DefaultObjectId);
00298             DBMessage(const VoidMessage *msg);
00299 
00300             inline TransportMessage transport_msg() const
00301             {
00302                 return transport(*this);
00303             }
00304             DBMessage::TypeOfQuery qtype;   // тип данных в запросе
00305             TypeOfMessage tblid;            // идентификатор таблицы
00306 
00307 
00308             // т.к. размер трансопртынх сообщений ограничен, то 
00309             // мы можем высчитать максимальнйю длину текстового запроса
00310             // считаем размер текстового сообщения по формуле
00311             // размерТраснпортного - РазмерБазового-суммаВсехВспомПолейДляДанногоСообщения-1
00312             // всё это конечно не очень хорошо, но пока так.
00313             // sizeof(UniSetTypes::RawDataOfTransportMessage)-sizeof(Message)-sizeof(DBMessage::TypeOfQuery)-sizeof(TypeOfMessage)-1
00314 
00315             static const unsigned int size_of_query = 55;
00316             char data[size_of_query];   
00317     };
00318     
00320     class TimerMessage : public Message
00321     {
00322         public:
00323             TimerMessage();
00324             TimerMessage(UniSetTypes::TimerId id, Priority prior = Message::High,
00325                             ObjectId cons=UniSetTypes::DefaultObjectId);
00326             TimerMessage(const VoidMessage *msg);
00327             inline TransportMessage transport_msg() const
00328             {
00329                 return transport(*this);
00330             }
00331             
00332             UniSetTypes::TimerId id; 
00333     };
00334 
00336     class ConfirmMessage: public Message
00337     {
00338         public:
00339 
00340             ConfirmMessage(const InfoMessage& msg, Priority prior = Message::High,
00341                             ObjectId cons=UniSetTypes::DefaultObjectId);
00342 
00343             ConfirmMessage(const AlarmMessage& msg, Priority prior = Message::High,
00344                             ObjectId cons=UniSetTypes::DefaultObjectId);
00345             ConfirmMessage(const VoidMessage *msg);
00346 
00347             inline TransportMessage transport_msg() const
00348             {
00349                 return transport(*this);
00350             }
00351             
00352             MessageCode code;       
00353             MessageCode orig_cause; 
00354             timeval orig_tm;        
00355             int orig_type;          
00356             ObjectId orig_node;     
00357             ObjectId orig_id;       
00358             bool broadcast;
00359 
00365             bool route;
00366 
00367         protected:
00368             ConfirmMessage();
00369     };
00370 
00371 }
00372 // --------------------------------------------------------------------------
00373 #endif // MessageType_H_