federationsInfoMgr.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2011 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: federationsInfoMgr.h,v $ $Revision: 1.16 $ $State: Exp $
*********************************************************************/

#ifndef federationsInfoMgr_H_
#define federationsInfoMgr_H_


#include "rtiMsConfig.h"
#include "assistantMgr.h"
#include "assistantInfo.h"
#include "federationInfo.h"
#include "connectionAndConfiguration.h"
#include <vlutil/vlSmartPointers.h>
#include <vlutil/vlTime.h>

class DtRtiAssistantServer;
class DtRtiAssistantPeer;
class DtAssistantMsg;
class DtAssistantFederationStateMsg;
class DtAssistantFederateStateMsg;
class DtAssistantTimeStateMsg;
class DtAssistantSyncPtUpdateMsg;
class DtAssistantStateObserveMsg;
class DtAssistantCommandMsg;
class DtAssistantDeleteFederateMsg;
class DtAssistantDeleteFederationMsg;
class DtAssistantExecStateMsg;
class DtAssistantNotifyMsg;
class DtAssistantPopupMsg;
class DtAssistantLogMsg;
class DtAssistantLogRequestMsg;
class DtAssistantSignalTickedMsg;
class DtAssistantExecObserveRspMsg;
class DtAssistantExitMsg;
class DtAssistantFederateReqMsg;
class DtAssistantFederateRespMsg;
class DtAssistantComponentMgr;
class DtAssistantConnectionInfoMgr;
class DtAssistantSignalRouter;
class DtAssistantComponentInfo;

class DT_DLL_ASSISTANTAPP DtAssistantFederationsInfoMgr : public DtAssistantMgr
{
   Q_OBJECT

public:

   DtAssistantFederationsInfoMgr( DtBoost::shared_ptr<DtRtiAssistantServer> server,
      DtBoost::shared_ptr<DtRtiAssistantPeer> peer,
      DtAssistantSignalRouter& signalRouter,
      DtBoost::shared_ptr<DtAssistantComponentMgr> compMgr,
      DtBoost::shared_ptr<DtAssistantConnectionInfoMgr> connInfoMgr );

   ~DtAssistantFederationsInfoMgr();

private:

   DtAssistantFederationsInfoMgr(DtAssistantFederationsInfoMgr const& );

   DtAssistantFederationsInfoMgr& operator= (DtAssistantFederationsInfoMgr const& );


public:

   virtual const DtAssistantFederationInfo* federationInfo(
      const DtRtiConnectionInfo& conn, const MAKRti::DtString& name) const;

   virtual const DtFederationStateByNameMap* federations(
      const DtRtiConnectionInfo& conn) const;

   virtual const DtAssistantFederateInfo* federateInfo(
      const DtRtiConnectionInfo& conn, const MAKRti::DtString& federationName,
      unsigned federateHandle);

   virtual const DtFederateInfoByHandleMap* federates(
      const DtRtiConnectionInfo& conn, const MAKRti::DtString& federationName) const;

   virtual bool isLocalRtiexecViewedRemotely(const DtRtiConnectionInfo& conn) const;

   virtual void tick();

   virtual void requestSingleUpdateFromConnectedRtiexecs(int id);

   virtual void pruneTimedOutSingleUpdates();
   
   virtual void viewFederationsForConnection(const DtRtiConnectionInfo& conn);



   static void processObserveMsg( const DtAssistantStateObserveMsg& msg, void* usr );

   virtual void processObserveMsg( const DtAssistantStateObserveMsg& msg );

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

   virtual void processExecObserveRspMsg( const DtAssistantExecObserveRspMsg& msg );

   static void processRemoteRtiexecPopupMsg( const DtAssistantPopupMsg& msg, void* usr );

   virtual void processRemoteRtiexecPopupMsg( const DtAssistantPopupMsg& msg );

   static void processFederationStateMsg( const DtAssistantFederationStateMsg& msg, void* usr );   

   virtual void processFederationStateMsg( const DtAssistantFederationStateMsg& msg );

   static void processFederateStateMsg( const DtAssistantFederateStateMsg& msg, void* usr );   

   virtual void processFederateStateMsg( const DtAssistantFederateStateMsg& msg );

   static void processExecStateMsgForConnection( 
      const DtAssistantExecStateMsg& msg, void* usr );

   virtual void processExecStateMsgForConnection( const DtAssistantExecStateMsg& msg );

   static void processTimeStateMsg( const DtAssistantTimeStateMsg& msg, void* usr );   

   virtual void processTimeStateMsg( const DtAssistantTimeStateMsg& msg );

   static void processSyncPtStateMsg( const DtAssistantSyncPtUpdateMsg& msg, void* usr );   

   virtual void processSyncPtStateMsg( const DtAssistantSyncPtUpdateMsg& msg );

   static void processAssistantCommandMsg(const DtAssistantCommandMsg& msg, void* usr);

   virtual void processAssistantCommandMsg(const DtAssistantCommandMsg& msg);

   static void processFederateDeleteMsg( const DtAssistantDeleteFederateMsg& msg, void* usr );

   static void processFederationDeleteMsg( const DtAssistantDeleteFederationMsg& msg, void* usr );

   static void processFederateRequestMsg( const DtAssistantFederateReqMsg& msg, void* usr );

   virtual void processFederateRequestMsg( const DtAssistantFederateReqMsg& msg );

   static void processFederateResponseMsg( const DtAssistantFederateRespMsg& msg, void* usr );

   virtual void processFederateResponseMsg( const DtAssistantFederateRespMsg& msg );

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

   static void forwardRtiexecPopupMsg( const DtAssistantPopupMsg& msg, void* usr );

   static void forwardRtiexecLogMsg( const DtAssistantLogMsg& msg, void* usr );

   static void forwardLogRequestMsg( const DtAssistantLogRequestMsg& msg, void* usr );

   static void forwardRtiexecExitMsg( const DtAssistantExitMsg& msg, void* usr );

   virtual void forwardMsgToLocalRtiexec( const DtAssistantMsg& msg, 
      bool sendOnlyIfCommandsAccepted = false );

   virtual void forwardMsgFromLocalRtiexec( const DtAssistantMsg& msg );

   static void processSignalTickedMsg( const DtAssistantSignalTickedMsg& msg, void* usr );

   virtual void processSignalTickedMsg( const DtAssistantSignalTickedMsg& msg );


public slots:

   void processLocalFederateJoined( const DtAssistantComponentInfo* info,
      const MAKRti::DtString& federateType,
      const MAKRti::DtString& federateName,
      unsigned federateHandle,
      const MAKRti::DtString& federationName,
      unsigned federationHandle,
      DtHlaVersionId hlaVersion );

   void processLocalFederateResigned( const DtAssistantComponentInfo* );

   void processConnectionsUpdate( const DtRtiConnectionAndConfiguration& conns );

   void processConnectionsRemoval( const DtRtiConnectionAndConfiguration& conns );

   void sendAllFederationInfo();

   void pruneStaleFederationsAndObservers();

   void startRtiexec( const DtRtiConnectionInfoDataPair& conn, 
      const DtRtiConnectionConfigurationInfo& config,
      bool requestedRemotely );

   void updateFederateWarningTickInterval( float interval );

   void sendObserveFederationsMsg();

   void provideFederateInfo(const DtRtiConnectionInfo& conn, 
      const MAKRti::DtString& federationName, unsigned federateHandle, 
      const DtAssistantFederateInfo** info);

   void provideFederationInfo(const DtRtiConnectionInfo& conn, 
      const MAKRti::DtString& federationName, 
      const DtAssistantFederationInfo** info);

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

   void removeFederationsForRtiexec( const DtAssistantComponentInfo* );

signals:

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

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

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

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

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

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

   void rtiexecHasNoFederations(const DtRtiConnectionInfo& conn);

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

protected:

   typedef std::map< DtAssistantInfo, bool > DtRemoteObserversMap;
   typedef std::map< DtRtiConnectionInfo, DtRemoteObserversMap > DtConnToObserversMap;
   typedef std::map< DtRtiConnectionInfo, DtFederationStateByNameMap > DtConnToFederationStateMap; 
   typedef std::map< DtRtiConnectionInfo, int > DtConnToCompIdMap;

   virtual void processRtiexecConnUpdate( const DtRtiConnectionInfoDataPair& rtiexec );

   virtual void processLightweightConnUpdate( const DtRtiConnectionInfoDataPair& conn );

   virtual void processConnectionRemoval( const DtRtiConnectionInfoDataPair& conn );

   virtual bool localFederateInfo(int compId,
      const DtAssistantFederateInfo** federate,
      DtAssistantFederationInfo** federation);

protected:

   DtBoost::shared_ptr<DtAssistantComponentMgr> myCompMgr;

   DtBoost::shared_ptr<DtAssistantConnectionInfoMgr> myConnInfoMgr;

   DtConnToFederationStateMap myKnownFederations;

   DtConnToCompIdMap myLocalRtiexecConns;

   std::set< DtRtiConnectionInfo > myRtiexecsRequestedForRemoteStart;

   std::set< DtRtiConnectionInfo > myRtiexecsStartedByRemoteRequest;

   DtConnToObserversMap myRemotelyViewedConnections;

   std::set< DtRtiConnectionInfo > myRemotelyViewedConnectionsNeedingUpdate;

   DtRtiConnectionInfo myViewedConnection;

   DtRtiConnectionInfo myToBeViewedConnection;

   MAKRti::DtClock myClock;

   unsigned int myTimeStateUpdateInterval;

   std::map<std::pair<int, MAKRti::DtTime>, std::map<int, MAKRti::DtString> > myRequestedRtiexecUpdates;

   float myWarningTickInterval;

   MAKRti::DtTime myLastTickTime;

   std::map<int, bool> myFederateSignalTickMessages;

   typedef std::pair<MAKRti::DtString, unsigned> DtFedexFederatePair;
   typedef std::map<DtRtiConnectionInfo, std::set<DtFedexFederatePair> > DtFedsByConn;
   DtFedsByConn myFederateLocQueries;

   static const int theTimeToWaitForExecInfo;

   typedef std::map< int, DtAssistantFederateInfo > DtFedInfoByCompIdMap;
   typedef std::pair< MAKRti::DtString, unsigned int >FederationNameFederateHandlePair;
   typedef std::pair< DtRtiConnectionInfo, FederationNameFederateHandlePair> DtConnectionFederationNameFedHandleTriple;
   typedef std::map<DtConnectionFederationNameFedHandleTriple, DtAssistantFederateInfo> DtFedInfoByConnFederationPairMap;
   DtFedInfoByCompIdMap myLocalJoinedFederatesByCompIdMap;
   DtFedInfoByConnFederationPairMap myLocalJoinedFederatesByConnFederationNameMap;
};

#endif