UNetUDP/UNetExchange.h

#ifndef UNetExchange_H_
#define UNetExchange_H_
// -----------------------------------------------------------------------------
#include <ostream>
#include <string>
#include <queue>
#include <cc++/socket.h>
#include "UniSetObject_LT.h"
#include "Trigger.h"
#include "Mutex.h"
#include "SMInterface.h"
#include "SharedMemory.h"
#include "ThreadCreator.h"
#include "UNetReceiver.h"
#include "UNetSender.h"
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
class UNetExchange:
    public UniSetObject_LT
{
    public:
        UNetExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0, const std::string& prefix="unet" );
        virtual ~UNetExchange();
    
        static UNetExchange* init_unetexchange( int argc, const char* argv[],
                                            UniSetTypes::ObjectId shmID, SharedMemory* ic=0, const std::string& prefix="unet" );

        virtual UNetReceiver* create_receiver( const std::string& h, const ost::tpport_t p, SMInterface* shm );
        virtual UNetSender* create_sender( const std::string& h, const ost::tpport_t p, SMInterface* shm,
                    const std::string& s_field="", const std::string& s_fvalue="", SharedMemory* ic=0 );

        static void help_print( int argc, const char* argv[] );

        bool checkExistUNetHost( const std::string& host, ost::tpport_t port );
        
        std::list<UNetReceiver*> get_receivers();
        
        void setIgnore(UniSetTypes::ObjectId id = UniSetTypes::DefaultObjectId, bool set = true);

    protected:
        UNetExchange();

        xmlNode* cnode;
        std::string s_field;
        std::string s_fvalue;

        SMInterface* shm;
        void step();
        

        virtual void processingMessage( UniSetTypes::VoidMessage *msg );
        void sysCommand( UniSetTypes::SystemMessage *msg );
        void sensorInfo( UniSetTypes::SensorMessage*sm );
        void timerInfo( UniSetTypes::TimerMessage *tm );
        void askSensors( UniversalIO::UIOCommand cmd );
        void waitSMReady();
        void receiverEvent( UNetReceiver* r, UNetReceiver::Event ev );

        virtual bool activateObject();
        
        // действия при завершении работы
        virtual void sigterm( int signo );

        void initIterators();
        void startReceivers();
        

        enum Timer
        {
            tmStep
        };

    private:
        bool initPause;
        UniSetTypes::uniset_mutex mutex_start;

        PassiveTimer ptHeartBeat;
        UniSetTypes::ObjectId sidHeartBeat;
        int maxHeartBeat;
        IOController::AIOStateList::iterator aitHeartBeat;
        UniSetTypes::ObjectId test_id;

        int steptime;   
        bool activated;
        int activateTimeout;

        struct ReceiverInfo
        {
            ReceiverInfo():r1(0),r2(0),
                sidRespond(UniSetTypes::DefaultObjectId),
                respondInvert(false),
                sidLostPackets(UniSetTypes::DefaultObjectId)
            {}

            ReceiverInfo(UNetReceiver* _r1, UNetReceiver* _r2 ):
                r1(_r1),r2(_r2),
                sidRespond(UniSetTypes::DefaultObjectId),
                respondInvert(false),
                sidLostPackets(UniSetTypes::DefaultObjectId)
            {}
            
            UNetReceiver* r1;   
            UNetReceiver* r2;   
            void step( SMInterface* shm, const std::string& myname );

            inline void setRespondID( UniSetTypes::ObjectId id, bool invert=false )
            { 
                sidRespond = id; 
                respondInvert = invert;
            }
            inline void setLostPacketsID( UniSetTypes::ObjectId id ){ sidLostPackets = id; }
            inline void initIterators( SMInterface* shm )
            {
                shm->initAIterator(aitLostPackets);
                shm->initDIterator(ditRespond);
            }

            // Сводная информация по двум каналам
            // сумма потерянных пакетов и наличие связи
            // хотя бы по одному каналу
            // ( реализацию см. ReceiverInfo::step() )
            UniSetTypes::ObjectId sidRespond;
            IOController::DIOStateList::iterator ditRespond;
            bool respondInvert;
            UniSetTypes::ObjectId sidLostPackets;
            IOController::AIOStateList::iterator aitLostPackets;
        };
        
        typedef std::list<ReceiverInfo> ReceiverList;
        ReceiverList recvlist;

        bool no_sender;  
        UNetSender* sender;
        UNetSender* sender2;
};
// -----------------------------------------------------------------------------
#endif // UNetExchange_H_
// -----------------------------------------------------------------------------