fedMgr.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1998 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: fedMgr.h,v $ $Revision: 1.96 $ $State: Exp $
*******************************************************************************/

#ifndef fedMgr_H_
#define fedMgr_H_


#include "resignMsg.h"
#include "resignDirectiveMsg.h"
#include "joinConfMsg.h"

#include <RIDparams.h>

#include <mtl/fedReader.h>

#include <vlutil/vlPrint.h>
#include <vlutil/vlTime.h>
#include <vlutil/vlString.h>
#include <vlutil/vlList.h>
#include <vlutil/vlSmartPointers.h>

#include <list>

#if defined(DtIFSPEC13)
   #ifdef DtIFSPEC13DLC
      #include "RTI13.h"
      #define RTI rti13
   #else
      #include "RTI.hh"
   #endif
#else
   #include "RTI/RTIambassador.h"
   #include "RTI/Enums.h"
   #if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
      #include "RTI/LogicalTimeFactory.h"
   #else
      #include "RTI/time/LogicalTimeFactory.h"
   #endif
#endif

class DtRtiSaveFile;
class DtFomClassMgr;
class DtFomModuleManager;
class DtRIDParameters;
class DtObjectMgr;
class DtInteractionMgr;
class DtTimeMgr;
class DtDataDistMgr;
class DtMomMgr;
class DtFederateHandleSet;
class DtLogicalTimeFactory;
class DtResignMsg;
class DtSaveInitiateMsg;
class DtSaveResponseMsg;
class DtSaveFinishedMsg;
class DtRestoreReplyMsg;
class DtRestoreInitiateMsg;
class DtRestoreEndMsg;
class DtRestoreMsg;
class DtFederateMgr;
class DtFedAmbWrapper;
class DtRtiAssistantLrcClient;
class DtAssistantExitMsg;
class DtAssistantLogEnableMsg;
class DtRtiAmbassadorBaseImplementor;
class DtTestManager;
class DtTestMgrFedAmbWrapper;
class DtEnableDisableNetworkTestingMsg;
class DtLatencyReportMsg;
class DtTestMgrStatusMsg;
class DtAssistantFederateSignalTickIntervalMsg;
class DtAssistantRidParamsMsg;


class DT_DLL_LRC DtFederateMgr
{
public:
   typedef DtFederateMgr* (*DtFederateMgrCreator)(
      DtRIDParameters* ridParams,
      DtRtiAmbassadorBaseImplementor* ambImplPtr,
      DtConnectionMgr* connMgr,
      std::shared_ptr<DtRtiAssistantLrcClient> assistantClient);

   // Callback for PostTick
   typedef void (*DtFedMgrPostTickCallbackFcn) (void*);
   typedef std::pair< DtFedMgrPostTickCallbackFcn, void* > DtFedMgrPostTickCallbackInfo;
   typedef std::map< MAKRti::DtString, DtFedMgrPostTickCallbackInfo > DtPostTickCallbackMap;

protected:

   DtFederateMgr(
      DtRIDParameters* params,
      DtRtiAmbassadorBaseImplementor* ambImplPtr,
      DtConnectionMgr* connMgr,
      std::shared_ptr<DtRtiAssistantLrcClient> assistantClient);

public:

   virtual ~DtFederateMgr();

private:
   
   DtFederateMgr(DtFederateMgr const& );

   DtFederateMgr& operator= (DtFederateMgr const& );

public:


   virtual void setEnableCallbacks(bool enableCallbacks);
   virtual bool callbacksEnabled() const;

#if defined(DtIFSPEC13) || defined(DtIFSPEC1516)
   virtual void createFederationExecution(const char* executionName, const char* timeImplName, const char* fed) = 0;
#else
   virtual void createFederationExecution(const char* executionName, const char* timeImplName,
      const std::vector<DtString>& fomModules,
      const char* mimModule) = 0;
#endif

   virtual void destroyFederationExecution (
      const char* executionName) = 0;

#if !defined(DtIFSPEC13) && !defined(DtIFSPEC1516)
   virtual void listFederationExecutions() const = 0;

   virtual void listFederationMembers(DtString const& federationName) const = 0;
#endif

   virtual RTI_API::FederateHandle joinFederationExecution (
#if !defined(DtIFSPEC13) && !defined(DtIFSPEC1516)
      const char* federateName,
#endif
      const char* federateType,
      const char* executionName,
#if defined(DtIFSPEC13) || defined(DtIFSPEC1516)
      RTI_API::FederateAmbassador* federateAmbassadorReference,
#else
      const std::vector<DtString>& fomModules,
#endif
      unsigned long flags) = 0;

   virtual void resignFederationExecution(RTI_API::ResignAction theAction);

   virtual bool automaticReserveObjectName(const char *);

#if defined(DtIFSPEC13)
   virtual void registerFederationSynchronizationPoint(const char* label, const char* theTag) = 0;
#else
   virtual void registerFederationSynchronizationPoint(const char* label, RTI_API::VariableLengthData const & theTag) = 0;
#endif

   virtual void waitForResignResponse(bool serviceCall = true);

   virtual void waitForReserveNameResponse(bool serviceCall = true);

#if defined(DtIFSPEC13)
   virtual void registerFederationSynchronizationPoint(const char* label, const char* theTag,
      DtFederateHandleSet const& syncSet) = 0;
#else
   virtual void registerFederationSynchronizationPoint(const char* label, RTI_API::VariableLengthData const & theTag,
      DtFederateHandleSet const& syncSet) = 0;
#endif

   virtual void synchronizationPointAchieved(const char* label, bool successfully=true) = 0;

   virtual void init();
   

#if defined(DtIFSPEC13) || defined(DtIFSPEC1516)
   virtual void setTopLevelAmbassador(RTI_API::RTIambassador* ambPtr);
#else
   virtual void setTopLevelAmbassador(RTI_API::RTIambassador* ambPtr,
      RTI_API::FederateAmbassador* federateAmbassador);
#endif


   virtual bool tick();
   virtual void pretick();
   virtual void posttick();

   virtual void postTickCallbacks();

   virtual void addPostTickCallback(const MAKRti::DtString& label, const DtFedMgrPostTickCallbackInfo& cb);
   virtual void removePostTickCallback(const MAKRti::DtString& label);

   virtual void requestFederationSave(const char *label, const DtRtiApiTime* time=NULL) = 0;

#if !defined(DtIFSPEC13)
   virtual void queryFederationSaveStatus()=0;

   virtual void queryFederationRestoreStatus()=0;

#if !defined(DtIFSPEC1516)
   virtual void abortFederationSave () =0;

   virtual void abortFederationRestore () =0;
#endif
#endif

   virtual void federateSaveBegun () =0;

   virtual void federateSaveComplete () =0;

   virtual void federateSaveNotComplete () =0;

   virtual void requestFederationRestore ( const char *label) =0;

   virtual void federateRestoreComplete () =0;

   virtual void federateRestoreNotComplete () =0;

   virtual char* getTransportationName(MAKRti::DtTransportType transport);

   virtual char* getOrderName(MAKRti::DtOrderType order);

   virtual MAKRti::DtTransportType getTransportationHandle(MAKRti::DtString transport);

   virtual MAKRti::DtOrderType getOrderHandle(MAKRti::DtString order);

   virtual DtFederateHandle federateHandle() const;

   virtual MAKRti::DtString const & fedType() const;

   virtual MAKRti::DtString const & fedName() const;

   virtual MAKRti::DtString const & fedExName() const;

   virtual unsigned long fedExHandle() const;

   virtual bool isJoined() const;


   RTI_API::RTIambassador* rtiAmb();
   RTI_API::RTIambassador* rtiAmb() const;


   virtual RTI_API::FederateAmbassador * federateAmbassador();
   virtual RTI_API::FederateAmbassador * federateAmbassador() const;

   virtual DtConnectionMgr* connectMgr();
   virtual DtConnectionMgr* connectMgr() const;

   virtual DtRIDParameters* params();
   virtual DtRIDParameters* params() const;

   virtual DtFomModuleManager* fomManager();
   virtual DtFomModuleManager* fomManager() const;

   virtual DtFomClassMgr* fom();
   virtual DtFomClassMgr* fom() const;

   virtual DtInteractionMgr* interMgr();
   virtual DtInteractionMgr* interMgr() const;

   virtual DtTestManager* testMgr();
   virtual DtTestManager* testMgr() const;
   
   virtual DtObjectMgr* objMgr();
   virtual DtObjectMgr* objMgr() const;

#ifdef DtTIME
   virtual DtTimeMgr* timeMgr();
   virtual DtTimeMgr* timeMgr() const;
#endif

   virtual DtLogicalTimeFactory* timeFactory();
   virtual DtLogicalTimeFactory* timeFactory() const;

#ifdef DtMOM
   virtual DtMomMgr* momMgr(); 
   virtual DtMomMgr* momMgr() const; 
#endif

#ifdef DDM
   virtual DtDataDistMgr* ddmMgr();
   virtual DtDataDistMgr* ddmMgr() const;
#endif

   virtual DtRtiAssistantLrcClient* assistantClient();
   virtual DtRtiAssistantLrcClient* assistantClient() const;


   virtual bool isJoinedFederate(DtFederateHandle federateHandleValue) const;

   virtual bool forcedToResign() const;

   virtual void setMomResign();

   virtual void resetMomResign();

   virtual bool saveInitiated() const;

   virtual bool saveBegun() const;

   virtual bool restoreRequested() const;

   virtual bool restoreInitiated() const;

   virtual bool restoreBegun() const;

   virtual const MAKRti::DtString& restoreLabel() const;

   virtual const MAKRti::DtString& lastRestoreLabel() const;

   const MAKRti::DtString& currentTimeImplName() const;
   void setCurrentTimeImplName( const MAKRti::DtString&  );

   virtual const MAKRti::DtString& saveLabel() const;
   virtual void setSaveLabel(const MAKRti::DtString& value);

   virtual const MAKRti::DtString& lastSaveLabel() const;
   virtual void setLastSaveLabel(const MAKRti::DtString& value);


   virtual void testSaveProgress() const = 0;

   virtual void initiateSave();

   virtual void initiateTimedSave(DtRtiApiTime const& saveTime);

   virtual bool save( DtRtiSaveFile& file ){ return true;};

   virtual bool restore( DtRtiSaveFile& file ){ return true;};
   
   virtual MAKRti::DtString& getSaveFileName(const char* label,
      DtFederateHandle fedHandle, MAKRti::DtString& fileName,
      bool extendName=true);

   virtual MAKRti::DtString& getRestoreFileName(const char* label,
      DtFederateHandle fedHandle, MAKRti::DtString& fileName);

   virtual unsigned long tickCount() const;

   virtual bool isTicking() const;

   virtual void reportLatencyTestResults( const DtLatencyReportMsg& msg );

   virtual void reportLatencyTestStatus( const DtTestMgrStatusMsg& msg );

   unsigned long flags() const;


   virtual DtResignAction automaticResignDirective() const;

   virtual void setAutomaticResignDirective(DtResignAction action);

#if !defined(DtIFSPEC13) && !defined(DtIFSPEC1516)


   virtual RTI_API::ResignAction getAutomaticResignDirective() const;

   virtual void setAutomaticResignDirective(RTI_API::ResignAction action);

#endif


   virtual const MAKRti::DtString& getFederateNameFromHandle( DtFederateHandle handle );
   virtual DtFederateHandle getFederateHandleFromName( const MAKRti::DtString& name );

public:

   static DtFederateMgr* create(
      DtRIDParameters* params,
      DtRtiAmbassadorBaseImplementor* ambImplPtr,
      DtConnectionMgr* connMgr,
      std::shared_ptr<DtRtiAssistantLrcClient> assistantClient);

   static void setCreatorFunction(DtFederateMgrCreator fn);

   static void setInternalCreatorFunction(DtFederateMgrCreator fn);

protected:



   virtual void processResign(const DtResignMsg& msg);

   virtual void processEnableDisableNetworkTesting( const DtEnableDisableNetworkTestingMsg& msg );

   virtual void processSaveInitiate(const DtSaveInitiateMsg& msg);

   virtual void processSaveResponse(const DtSaveResponseMsg& msg);

   virtual void processSaveFinished(const DtSaveFinishedMsg& msg);

   virtual void processRestoreReply(const DtRestoreReplyMsg& msg);

   virtual void processRestoreInitiate(const DtRestoreInitiateMsg& msg);

   virtual void processRestoreEnd(const DtRestoreEndMsg& msg);

   virtual void processRestore(const DtRestoreMsg& msg);


   virtual void processAssistantResign(const DtAssistantExitMsg& msg);

   virtual void processAssistantEnableLogging(const DtAssistantLogEnableMsg& msg);

   virtual void processSignalTickInterval( const DtAssistantFederateSignalTickIntervalMsg& msg );

   virtual void processRidParamRequest( const DtAssistantRidParamsMsg& msg );

#if !defined(DtIFSPEC13) && !defined(DtIFSPEC1516)
   virtual void processResignDirective( const DtResignDirectiveMsg& msg );
#endif

   virtual void sendAlive();

   virtual void sendResignMsg(const char* fedExName, 
      DtFederateHandle fedHandle, DtResignAction action);

   void sendTickedMsg();

   virtual void applyRidParameters();

   virtual DtResignAction testResign(RTI_API::ResignAction theAction);

#if defined(DtIFSPEC13) || defined(DtIFSPEC1516)
   virtual void postJoinInit(
      const char* federateType, 
      const char* executionName, 
      const char* federateName,
      RTI_API::FederateAmbassador* federateAmbassadorReference);
#else
   virtual void postJoinInit(
      const char* federateType,
      const char* executionName,
      const char* federateName);
#endif

   virtual void handleFailedJoin(unsigned long sourceID, DtJoinConfirmMsg::errorCodes code);

   virtual void postJoinConfirmInit();

protected:



   static void processResign(const DtResignMsg& msg, void* usr);

   static void processEnableDisableNetworkTesting(const DtEnableDisableNetworkTestingMsg& msg, void* usr );

   static void processSaveInitiate(const DtSaveInitiateMsg& msg, void* usr);

   static void processSaveResponse(const DtSaveResponseMsg& msg, void* usr);

   static void processSaveFinished(const DtSaveFinishedMsg& msg, void* usr);

   static void processRestoreReply(const DtRestoreReplyMsg& msg, void* usr);

   static void processRestore(const DtRestoreMsg& msg, void* usr);

   static void processRestoreInitiate(const DtRestoreInitiateMsg& msg,
      void* usr);

   static void processRestoreEnd(const DtRestoreEndMsg& msg, void* usr);



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

   static void processAssistantEnableLogging(const DtAssistantLogEnableMsg& msg, void* usr);
   
   static void processSignalTickInterval( const DtAssistantFederateSignalTickIntervalMsg& msg, void* usr );

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

#if !defined(DtIFSPEC13) && !defined(DtIFSPEC1516)
   static void processResignDirective( const DtResignDirectiveMsg& msg, void* usr );
#endif



   virtual void createObjectMgr();

   virtual void createInteractionMgr();

   virtual void createDdmMgr();

   virtual void createTimeMgr();

   virtual void createMomMgr();

   virtual void createTestMgr();



   virtual MAKRti::DtResignAction convertResignAction(RTI_API::ResignAction) const;
   virtual RTI_API::ResignAction convertResignAction(MAKRti::DtResignAction) const;

public:

   //In order to correctly stop evokeCallback we need to know what has reached a 
   //federate Ambassador. So we are putting this boolean here in order to do that
   //Accessors should be made once we know this works.
   bool myFedCallbackReached;

protected:

   RTI_API::RTIambassador* myRtiAmb;

   DtRtiAmbassadorBaseImplementor* myAmbImpl;



   DtConnectionMgr* myConnectMgr;

   DtFomModuleManager* myFomManager;

   DtInteractionMgr* myInterMgr;

   DtObjectMgr* myObjMgr;

   DtMomMgr* myMomMgr;

#ifdef DDM
   DtDataDistMgr* myDdmMgr;
#endif
#ifdef DtTIME
   DtTimeMgr* myTimeMgr;
#endif


   MAKRti::DtTime myResponseInterval;

   MAKRti::DtString myFedExName;

   unsigned long myFedExHandle;

   MAKRti::DtString myFedType;

   MAKRti::DtString myFedName;
 
   DtFederateHandle myFedHandle;

   MAKRti::DtString myCurrentTimeImplName;

   MAKRti::DtTime myLastHeartbeat;

   DtLogicalTimeFactory* myLogicalTimeFactory;
#if defined(DtIFSPEC13)
   RTI::FedTimeFactory myHlaTimeFactory;
#endif

   DtFedAmbWrapper* myPrinter;

   DtFedAmbWrapper* myFedAmbCatch;

   DtRIDParameters* myParams;

   std::shared_ptr<DtRtiAssistantLrcClient> myAssistantClient;



   bool mySaveInitiated;
   bool mySaveBegun;
   bool myRestoreRequested;
   bool myRestoreInitiated;
   bool myRestoreBegun;
   MAKRti::DtString  mySaveLabel;
   MAKRti::DtString  myLastSaveLabel;
   MAKRti::DtString  myRestoreLabel;
   MAKRti::DtString  myLastRestoreLabel;

   bool myIgnoreForcedResign;

   bool myForcedToResign;

   bool myMomResign;

   bool myMomSaveEvokeCallbacks;

   bool myResignInProgress;

   MAKRti::DtClock myClock;

   unsigned long myTickCount;

   bool myIsTicking;

   bool myEnableFederateHeartbeat;

   bool myCallbacksEnabled;

   unsigned long myFlags;

   DtTestManager* myTestMgr;
   bool myNetworkTestEnabled;

   float mySignalTickInterval;
   
   DtTime myLastTickTime;

   DtPostTickCallbackMap myPostTickCallbacks;

   MAKRti::DtFilename myStandardMimPath;

   // our list of Federate Names to Handles and vise-versa
   std::map< MAKRti::DtString, DtFederateHandle > myFederateNameToHandle;
   std::map< DtFederateHandle, MAKRti::DtString > myFederateHandleToName;

   MAKRti::DtResignAction myResignAction;

protected:
   static DtFederateMgrCreator theCreator;

   static DtFederateMgrCreator theInternalCreator;
};

#endif