federationsViewMgr.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2017 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include "rtiMsConfig.h"
#include "assistantMgr.h"
#include "assistantInfo.h"
#include "assistantConnectionInfo.h"
#include "forwarderInfo.h"
#include "rtiAssistantClient.h"
#include <QWidget>
#include <vlutil/vlSmartPointers.h>

class DtRtiAssistantServer;
class DtRtiAssistantPeer;
class DtFederationsViewDialog;
class DtForwarderConnStatusDialog;
class DtRtiConnectionInfo;
class DtAssistantInfo;
class DtAssistantComponentMgr;
class DtRtiConnectionAndConfiguration;
class DtAssistantConnectionInfoMgr;
class DtAssistantExecObserveRspMsg;
class DtAssistantNotifyMsg;
class DtAssistantAwaitingForwardersMsg;
class DtAssistantSignalRouter;
class DtAssistantFederationsInfoMgr;
class DtAssistantForwarderCompInfoMgr;
class QSignalMapper;
class DtAssistantRidParamsMsg;
class DtAssistantForwarderConnectMsg;
class DtSyncPtDialog;
class DtRIDParameters;
class DtWidgetDialog;
class DtRidWidget;

class DT_DLL_ASSISTANTAPP DtAssistantFederationsViewMgr : public DtAssistantMgr
{
   Q_OBJECT

public:

   DtAssistantFederationsViewMgr(std::shared_ptr<DtRtiAssistantServer> server,
      std::shared_ptr<DtRtiAssistantPeer> peer,
      DtAssistantSignalRouter& signalRouter,
      std::shared_ptr<DtAssistantComponentMgr> compMgr,
      std::shared_ptr<DtAssistantConnectionInfoMgr> connInfoMgr,
      std::shared_ptr<DtAssistantFederationsInfoMgr> fedInfoMgr,
      std::shared_ptr<DtAssistantForwarderCompInfoMgr> netCompInfoMgr,
      const MAKRti::DtFilename& configDir);

   ~DtAssistantFederationsViewMgr();

private:

   DtAssistantFederationsViewMgr(DtAssistantFederationsViewMgr const& );
   DtAssistantFederationsViewMgr& operator= (DtAssistantFederationsViewMgr const& );

public:

   virtual void tick();

   virtual void startShutdown();

   virtual bool dialogsVisible() const;

   void saveGuiState();



   static void processExecObserveRspMsg( const DtAssistantExecObserveRspMsg& msg, void* usr );

   virtual void processExecObserveRspMsg( const DtAssistantExecObserveRspMsg& msg );

   static void processRtiexecNotifyMsg( const DtAssistantNotifyMsg& msg, void* usr );

   virtual void processRtiexecNotifyMsg( const DtAssistantNotifyMsg& msg );

   static void processAwaitingForwardersMsg( const DtAssistantAwaitingForwardersMsg& msg, void* usr );

   virtual void processAwaitingForwardersMsg( const DtAssistantAwaitingForwardersMsg& msg );

   static void processRidParamMsg( const DtAssistantRidParamsMsg& msg, void* usr );

   virtual void processRidParamMsg( const DtAssistantRidParamsMsg& msg );

   static void processForwardersConnectMsg( const DtAssistantForwarderConnectMsg& msg, void* usr );

   virtual void processForwardersConnectMsg( const DtAssistantForwarderConnectMsg& msg );



protected:

   virtual void processConnectionRemoval( const DtRtiConnectionInfoDataPair& conn );

   void logConnectionInfo(std::ofstream& fileStrm);

   void logFederationInfo(std::ofstream& fileStrm);

   void logFomInfo(std::ofstream& fileStrm, const std::list<MAKRti::DtString>* foms);

   void logFederateInfo(std::ofstream& fileStrm, const DtFederateInfoByHandleMap* federates,
      const DtAssistantForwarderInfo* fwInfo);

   struct DtCompRidParamDispStruct
   {
      DtRIDParameters* ridParams;
      DtWidgetDialog* ridDialog;
      DtRidWidget* ridWidget;
      MAKRti::DtString federation;
      unsigned federateHdl;
   };

   void showRidDialog(const QString& name, const DtAssistantInfo& assistant,
      int compId);

   void createRidDialog(const QString& name, DtCompRidParamDispStruct& dispInfo);

   void updateRidParams(const DtAssistantInfo& assistant, int compId,
      const MAKRti::DtString& params, const MAKRti::DtString& filename,
      const MAKRti::DtString& federation, unsigned federateHdl);

   virtual void updatePeerForwarders(
      const DtAssistantForwarderInfo::DtPeerForwarderByAddrMap* newFwds,
      const DtAssistantForwarderInfo::DtPeerForwarderByAddrMap* oldFwds);

   virtual void updateRtiexecCompInfo(
      const DtAssistantNetworkCompInfo* newInfo,
      const DtAssistantNetworkCompInfo* oldInfo);

   virtual void updateFederateCompInfo(
      const DtAssistantForwarderInfo::DtCompByFederationAndHandleMap* newInfo,
      const DtAssistantForwarderInfo::DtCompByFederationAndHandleMap* oldInfo,
      const DtFederationStateByNameMap* federationMap);

   virtual void updateUnclassifiedComps(
      const DtAssistantNetworkCompInfoList* newInfo,
      const DtAssistantNetworkCompInfoList* oldInfo);

public slots:

   void showFederationsView();

   virtual void sendLogRequest();

   void connectForeignAssistant(const QString& hostName,
      const QString& hostIp, const QString& localInterface);

   void disconnectForeignAssistant(const QString& hostName,
      const QString& hostIP, const QString& localInterface);

   void startupRtiexec();

   void shutdownRtiexec();

   void startupRtiForwarder();

   void connectRtiForwarder(const DtRtiConnectionInfo& connection);

   void shutdownRtiForwarder();

   void processForwarderAdded( const DtRtiConnectionInfo& conn );

   void processForwarderConnUpdated( const DtRtiConnectionInfo& conn );

   void processForwarderUpdated( const DtRtiConnectionInfo& conn );

   void processForwarderRemoved( const DtRtiConnectionInfo& conn );

   void processDoNotWaitForForwarders(QWidget* dlg);

   void processShutDownWaitingForwarder(QWidget* dlg);

   // Ported from federationsViewMgr

   void changeViewedConnection( const DtRtiConnectionInfo& conn =
      DtRtiConnectionInfo::invalidConn() );

   void resignFederate( int, const QString& );

   void destroyFederation( const QString& );

   void sendNetworkTestingEnableMsg( const QString& fedexName );

   void sendNetworkTestingDisableMsg( const QString& fedexName );

   void showLatencyTestDialog( const QString& fedexName, int fedHandle );

   void processFederationUpdate(const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName);

   void processFederationRemoved(const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName);

   void processFederateUpdated(const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName,
      unsigned federateHandle);

   void processFederateRemoved(const DtRtiConnectionInfo& conn,
      const MAKRti::DtString& federationName,
      unsigned federateHandle);

   void removeLoadingIndication(const DtRtiConnectionInfo& conn);

   void saveToLog();

   void processConnectionsUpdate( const DtRtiConnectionAndConfiguration& conns );

   void processConnectionsRemoval( const DtRtiConnectionAndConfiguration& conns );

   void showFederationsViewPreferences();

   void processFederateSelection(const MAKRti::DtString& federation,
      int federate);

   void processRtiexecSelection();

   void processForwarderSelection(const MAKRti::DtString& fwHostName, int port);

   void processPeerForwarderSelection(const MAKRti::DtString& fwHostName, int port);


   void processFederationSelection(const MAKRti::DtString& federation);

   void processLightweightNodeSelection();

   void showSyncPtDialog(const MAKRti::DtString& federation);

   void showFederateStatsDialog(const MAKRti::DtString& federation, int federateHandle);

   void showFomDialog(const MAKRti::DtString& federation, int federateHandle);

   void showRtiexecRidParams();

   void showForwarderRidParams();

   void showFederateRidParams(const MAKRti::DtString& federation, int federateHandle);

   void destroyRidParamDialog(QWidget* widget);

   void sendPendingRidRequest(const DtRtiConnectionInfo& connInfo,
      const MAKRti::DtString& federationName, unsigned federateHdl,
      const DtAssistantInfo& astnt, unsigned compId);

   void showRtiexecLog();

   void showForwarderLog();

   void showFederateLog(const MAKRti::DtString& federation, int federateHandle);

   void removeDefunctFederateFromMap(const MAKRti::DtString& federation, int federateHandle);

   void processAssistantFound(const DtAssistantInfo& assistant);

   void processAssistantLost(const DtAssistantInfo& assistant);

signals:

   void aboutDialogRequested();

   void showPopup(const MAKRti::DtString&, const MAKRti::DtString&,
      const MAKRti::DtString&);

   // ported from federationsViewMgr
   void federateRemovalTimeChanged( float period );

   void showConfigDialog( DtPreferencesPage pageId );

   void showLrcLatencyTestDialog( int id );

   void showRtiexecLatencyTestDialog(
      const DtRtiConnectionInfoDataPair& connInfo,
      unsigned int federationHdl, const MAKRti::DtString& federationName,
      unsigned int federateHdl);

   void showFederateStatsDialog(const DtRtiConnectionInfo& connInfo,
      const MAKRti::DtString& federationName, unsigned int federateHdl);

   void showFomDialog(const DtRtiConnectionInfo& connInfo,
      const MAKRti::DtString& federationName, unsigned int federateHdl);


   void requestFederateLoc(const DtRtiConnectionInfo& connInfo,
      const MAKRti::DtString& federationName, unsigned int federateHdl);

   void showLogFileDialog( int compId );

   void queryFederateInfo(const DtRtiConnectionInfo&,
      const MAKRti::DtString&, unsigned, const DtAssistantFederateInfo**);

   void internalConnectionQuery(DtAssistantComponentType);

   void assistantFound(const DtAssistantInfo& assistant);

   void assistantLost(const DtAssistantInfo& assistant);

   void queryAssistantInfo(const DtAssistantUuid&, DtAssistantInfo* infoIn);

protected:

   typedef std::map< DtRtiConnectionInfo, DtAssistantInfoSet > DtConnectionToObserversMap;

   std::shared_ptr<DtAssistantComponentMgr> myCompMgr;

   std::shared_ptr<DtAssistantConnectionInfoMgr> myConnInfoMgr;

   std::shared_ptr<DtAssistantFederationsInfoMgr> myFedInfoMgr;

   std::shared_ptr<DtAssistantForwarderCompInfoMgr> myNetCompInfoMgr;

   DtRtiConnectionInfo myViewedConnection;

   DtAssistantForwarderInfo myCurrentForwarderInfo;

   const DtAssistantForwarderInfo myEmptyForwaderInfo;

   std::set<std::pair<MAKRti::DtString, unsigned> > myLightweightFederates;

   DtFederationsViewDialog* myFederationsViewDialog;

   MAKRti::DtClock myClock;

   bool myReceivedRemoteForwarderInfo;

   MAKRti::DtTime myRemoteForwarderInfoTimeout;

   typedef std::map< DtRtiConnectionInfo, DtForwarderConnStatusDialog* > DtConnectionToFwStatusDialogMap;
   DtConnectionToFwStatusDialogMap myFwStatusDlgMap;

   QSignalMapper* myFwStatusAcceptSigMapper;

   QSignalMapper* myFwStatusRejectSigMapper;

   std::map<MAKRti::DtString, DtSyncPtDialog*> mySyncPtDialogs;

   QSignalMapper* myRidDialogSignalMapper;

   typedef std::pair<DtAssistantInfo, int> DtUniqueCompId;

   typedef std::map<DtUniqueCompId, DtCompRidParamDispStruct> DtRidParmDlgByComp;

   DtRidParmDlgByComp myRidParamDialogs;

   std::list<DtCompRidParamDispStruct> myPendingFederateRidDialogs;

   static const int theUpdatePeriod;

   static const unsigned theMaxLogLoadSize;

   QString mySavedFile;

};