SharedMemory/SharedMemory.h

// -----------------------------------------------------------------------------
#ifndef SharedMemory_H_
#define SharedMemory_H_
// -----------------------------------------------------------------------------
#include <string>
#include <list>
#include "IONotifyController_LT.h"
#include "Mutex.h"
#include "PassiveTimer.h"
#include "NCRestorer.h"
#include "WDTInterface.h"
// -----------------------------------------------------------------------------

class SharedMemory:
    public IONotifyController_LT
{
    public:
        SharedMemory( UniSetTypes::ObjectId id, std::string datafile, std::string confname="" );
        virtual ~SharedMemory();

        static SharedMemory* init_smemory( int argc, const char* const* argv );
        static void help_print( int argc, const char* const* argv );

        // функция определяет "готовность" SM к работе.
        // должна использоваться другими процессами, для того, 
        // чтобы понять, когда можно получать от SM данные.
        virtual CORBA::Boolean exist();

        void addReadItem( Restorer_XML::ReaderSlot sl );
        

        // ------------  HISTORY  --------------------
        typedef std::list<long> HBuffer;
        
        struct HistoryItem
        {
            HistoryItem():id(UniSetTypes::DefaultObjectId){}

            UniSetTypes::ObjectId id;
            HBuffer buf;

            AIOStateList::iterator ait;
            DIOStateList::iterator dit;

            void add( long val, size_t size )
            {
                buf.push_back(val);
                if( buf.size() >= size )
                    buf.erase(buf.begin());
            }
        };

        typedef std::list<HistoryItem> HistoryList;

        struct HistoryInfo
        {
            HistoryInfo():
                id(0),
                size(0),filter(""),
                fuse_id(UniSetTypes::DefaultObjectId),
                fuse_invert(false),fuse_use_val(false),fuse_val(0),
                fuse_sec(0),fuse_usec(0)
                {
                      struct timeval tv;
                      struct timezone tz;
                      gettimeofday(&tv,&tz);
                      fuse_sec = tv.tv_sec;
                      fuse_usec = tv.tv_usec;
                }
            
            long id;                        // ID
            HistoryList hlst;               // history list
            int size;
            std::string filter;             // filter field
            UniSetTypes::ObjectId fuse_id;  // fuse sesnsor
            bool fuse_invert;
            bool fuse_use_val;
            long fuse_val;
            // timestamp
            long fuse_sec;
            long fuse_usec;
        };
        
        friend std::ostream& operator<<( std::ostream& os, const HistoryInfo& h );
        
        typedef std::list<HistoryInfo> History;

        // т.к. могуть быть одинаковые "детонаторы" для разных "историй" то, 
        // вводим не просто map, а "map списка историй". 
        // точнее итераторов-историй.
        typedef std::list<History::iterator> HistoryItList;
        typedef std::map<UniSetTypes::ObjectId,HistoryItList> HistoryFuseMap;

        typedef sigc::signal<void,HistoryInfo*> HistorySlot;
        HistorySlot signal_history(); 
        inline int getHistoryStep(){ return histSaveTime; } 
    protected:
        typedef std::list<Restorer_XML::ReaderSlot> ReadSlotList;
        ReadSlotList lstRSlot;

        virtual void processingMessage( UniSetTypes::VoidMessage *msg );
        virtual void sysCommand( UniSetTypes::SystemMessage *sm );
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm );
        virtual void timerInfo( UniSetTypes::TimerMessage *tm );
        virtual void askSensors( UniversalIO::UIOCommand cmd );
        virtual void sendEvent( UniSetTypes::SystemMessage& sm );

        // действия при завершении работы
        virtual void sigterm( int signo );
        bool activateObject();
//      virtual void logging(UniSetTypes::SensorMessage& sm){}
//      virtual void dumpToDB(){}
        bool readItem( UniXML& xml, UniXML_iterator& it, xmlNode* sec );
    
        void buildEventList( xmlNode* cnode );
        void readEventList( std::string oname );
        
        UniSetTypes::uniset_mutex mutex_start;
        
        struct HeartBeatInfo
        {
            HeartBeatInfo():
                a_sid(UniSetTypes::DefaultObjectId),
                d_sid(UniSetTypes::DefaultObjectId),
                reboot_msec(UniSetTimer::WaitUpTime),
                timer_running(false),
                ptReboot(UniSetTimer::WaitUpTime)
            {}
            
            UniSetTypes::ObjectId a_sid; // аналоговый счётчик
            UniSetTypes::ObjectId d_sid; // дискретный датчик состояния процесса
            AIOStateList::iterator ait;
            DIOStateList::iterator dit;

            int reboot_msec; 
            bool timer_running;
            PassiveTimer ptReboot;
        };

        enum Timers
        {
            tmHeartBeatCheck,
            tmEvent,
            tmHistory,
            tmPulsar
        };
        
        int heartbeatCheckTime;
        std::string heartbeat_node;
        int histSaveTime;
        
        void checkHeartBeat();

        typedef std::list<HeartBeatInfo> HeartBeatList;
        HeartBeatList hlist; // список датчиков "сердцебиения"
        WDTInterface* wdt;
        bool activated;
        bool workready;

        typedef std::list<UniSetTypes::ObjectId> EventList;
        EventList elst;
        std::string e_filter;
        int evntPause;
        int activateTimeout;

        virtual void loggingInfo(UniSetTypes::SensorMessage& sm);
        virtual void dumpOrdersList(const IOController_i::SensorInfo& si, const IONotifyController::ConsumerList& lst){}
        virtual void dumpThresholdList(const IOController_i::SensorInfo& si, const IONotifyController::ThresholdExtList& lst){}

        bool dblogging;

        History hist;
        HistoryFuseMap histmap;  
        virtual void updateHistory( UniSetTypes::SensorMessage* sm );
        virtual void saveHistory();

        void buildHistoryList( xmlNode* cnode );
        void checkHistoryFilter( UniXML_iterator& it );
        bool isActivated();


        DIOStateList::iterator ditPulsar;
        IOController_i::SensorInfo siPulsar;
        UniversalIO::IOTypes iotypePulsar;
        int msecPulsar;
        
        UniSetTypes::uniset_mutex act_mutex;

    private:
        HistorySlot m_historySignal;
};
// -----------------------------------------------------------------------------
#endif // SharedMemory_H_
// -----------------------------------------------------------------------------