UNetExchange.h

#ifndef UNetExchange_H_
#define UNetExchange_H_
// -----------------------------------------------------------------------------
#include <ostream>
#include <string>
#include <queue>
#include <deque>
#include <cc++/socket.h>
#include "UniSetObject.h"
#include "Trigger.h"
#include "Mutex.h"
#include "SMInterface.h"
#include "SharedMemory.h"
#include "ThreadCreator.h"
#include "UNetReceiver.h"
#include "UNetSender.h"
#include "LogServer.h"
#include "DebugStream.h"
#include "UNetLogSugar.h"
#include "LogAgregator.h"
#include "VMonitor.h"
// -----------------------------------------------------------------------------
#ifndef vmonit
#define vmonit( var ) vmon.add( #var, var )
#endif
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
class UNetExchange:
    public UniSetObject
{
    public:
        UNetExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr, const std::string& prefix = "unet" );
        virtual ~UNetExchange();

        static std::shared_ptr<UNetExchange> init_unetexchange( int argc, const char* const argv[],
                UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = 0, const std::string& prefix = "unet" );

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

        bool checkExistUNetHost( const std::string& host, ost::tpport_t port );

        inline std::shared_ptr<LogAgregator> getLogAggregator()
        {
            return loga;
        }
        inline std::shared_ptr<DebugStream> log()
        {
            return unetlog;
        }

        virtual UniSetTypes::SimpleInfo* getInfo( CORBA::Long userparam = 0 ) override;

    protected:

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

        std::shared_ptr<SMInterface> shm;
        void step();

        void sysCommand( const UniSetTypes::SystemMessage* msg ) override;
        void sensorInfo( const UniSetTypes::SensorMessage* sm ) override;
        void timerInfo( const UniSetTypes::TimerMessage* tm ) override;
        void askSensors( UniversalIO::UIOCommand cmd );
        void waitSMReady();
        void receiverEvent( const std::shared_ptr<UNetReceiver>& r, UNetReceiver::Event ev );

        virtual bool activateObject();

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

        void initIterators();
        void startReceivers();

        enum Timer
        {
            tmStep
        };

    private:
        UNetExchange();
        timeout_t initPause;
        UniSetTypes::uniset_rwmutex mutex_start;

        PassiveTimer ptHeartBeat;
        UniSetTypes::ObjectId sidHeartBeat = { UniSetTypes::DefaultObjectId };
        timeout_t maxHeartBeat = 10;
        IOController::IOStateList::iterator itHeartBeat;
        UniSetTypes::ObjectId test_id = { UniSetTypes::DefaultObjectId };

        timeout_t steptime = { 1000 };    
        std::atomic_bool activated = { false };
        timeout_t activateTimeout = { 20000 }; // msec

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

            ReceiverInfo( const std::shared_ptr<UNetReceiver>& _r1, const std::shared_ptr<UNetReceiver>& _r2 ):
                r1(_r1), r2(_r2),
                sidRespond(UniSetTypes::DefaultObjectId),
                respondInvert(false),
                sidLostPackets(UniSetTypes::DefaultObjectId),
                sidChannelNum(UniSetTypes::DefaultObjectId)
            {}

            std::shared_ptr<UNetReceiver> r1;    
            std::shared_ptr<UNetReceiver> r2;    
            void step(const std::shared_ptr<SMInterface>& shm, const std::string& myname, std::shared_ptr<DebugStream>& log );

            inline void setRespondID( UniSetTypes::ObjectId id, bool invert = false )
            {
                sidRespond = id;
                respondInvert = invert;
            }
            inline void setLostPacketsID( UniSetTypes::ObjectId id )
            {
                sidLostPackets = id;
            }
            inline void setChannelNumID( UniSetTypes::ObjectId id )
            {
                sidChannelNum = id;
            }

            inline void initIterators( const std::shared_ptr<SMInterface>& shm )
            {
                shm->initIterator(itLostPackets);
                shm->initIterator(itRespond);
                shm->initIterator(itChannelNum);
            }

            // Сводная информация по двум каналам
            // сумма потерянных пакетов и наличие связи
            // хотя бы по одному каналу, номер рабочего канала
            // ( реализацию см. ReceiverInfo::step() )
            UniSetTypes::ObjectId sidRespond;
            IOController::IOStateList::iterator itRespond;
            bool respondInvert;
            UniSetTypes::ObjectId sidLostPackets;
            IOController::IOStateList::iterator itLostPackets;
            UniSetTypes::ObjectId sidChannelNum;
            IOController::IOStateList::iterator itChannelNum;
        };

        typedef std::deque<ReceiverInfo> ReceiverList;
        ReceiverList recvlist;

        bool no_sender;  
        std::shared_ptr<UNetSender> sender;
        std::shared_ptr<UNetSender> sender2;

        std::shared_ptr<LogAgregator> loga;
        std::shared_ptr<DebugStream> unetlog;
        std::shared_ptr<LogServer> logserv;
        std::string logserv_host = {""};
        int logserv_port = {0};

        VMonitor vmon;
};
// -----------------------------------------------------------------------------
#endif // UNetExchange_H_
// -----------------------------------------------------------------------------