execFedMgr.h

Go to the documentation of this file.

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

#ifndef execFedMgr_H_
#define execFedMgr_H_



#include <rtiMsConfig.h>
#include <fedMgr.h>
#include <syncPointMsg.h>
#include <resBegMsg.h>
#include <creRespMsg.h>
#include <desRespMsg.h>
#include <joinRespMsg.h>
#include <joinConfMsg.h>
#include <savRespMsg.h>
#include <fomModuleRequestMsg.h>
#include <synchronousFileDistributor.h>
#include <ridFileTester.h>
#include <fileDistributor.h>
#include <newFomClassesMsg.h>
#include <resignRespMsg.h>
#include <rtiApiTypes.h>

#include <mtl/fedReader13.h>
#include <mtl/fedReader1516.h>
#include <mtl/fedReader1516e.h>

#include <vector>
#include <set>

class DtSyncPointMsg;
class DtDesignatedFederateMsg;
class DtSaveStatusMsg;
class DtRestoreStatusMsg;
class DtSaveFinishedMsg;
class DtSaveInitiateMsg;
class DtRestoreReplyMsg;
class DtRestoreEndMsg;
class DtRestoreInitiateMsg;
class DtRestoreMsg;
class DtReportFederationsMsg;
class DtReportFederationMembersMsg;
class DtNameReservedMsg;

namespace vrlmod
{
   class DtThreadedObject;
}

class DT_DLL_LRC DtRtiExecFederateMgr : public DtFederateMgr
{
public:

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

   virtual ~DtRtiExecFederateMgr();

private:
   
   DtRtiExecFederateMgr(DtFederateMgr const& );

   DtRtiExecFederateMgr& operator= (DtRtiExecFederateMgr const& );

public:



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

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

   virtual void listFederationMembers(DtString const& federationName) const;
#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);

   virtual void resignFederationExecution(RTI_API::ResignAction theAction);



   virtual void registerFederationSynchronizationPoint(
      char const * label,
      DtRtiApiTagConstRef theTag);

   virtual void registerFederationSynchronizationPoint(
      char const * label,
      DtRtiApiTagConstRef theTag,
      DtFederateHandleSet const & syncSet);

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



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

#if !defined(DtIFSPEC13)

   virtual void queryFederationSaveStatus();

   virtual void queryFederationRestoreStatus();

#if !defined(DtIFSPEC1516)

   virtual void abortFederationSave();

   virtual void abortFederationRestore();

#endif
#endif

   virtual void federateSaveBegun ();

   virtual void federateSaveComplete ();

   virtual void federateSaveNotComplete ();

   virtual void requestFederationRestore ( const char *label);

   virtual void federateRestoreComplete ();

   virtual void federateRestoreNotComplete ();

   DtSynchronousFileDistributor* distributor(const char* executionName);


   DtSynchronousFileDistributor* joinDistributor();
   DtSynchronousFileDistributor* joinDistributor() const;


   virtual void init();

protected:

   virtual void initRidTester();

   virtual void waitForCreateResponse( const char* executionName );

   virtual void waitForJoinResponse( const char* executionName, 
      std::vector<MAKRti::DtString> &joinModules );

   virtual void waitForResignResponse(bool serviceCall = true);

   virtual void waitForReserveNameResponse(bool serviceCall = true);

   void handleFailedJoinResponse(bool timedOutDueToCreation);

   virtual void initializeTimeFactory();

   virtual void initializeFOM( const char* executionName );

   virtual void initializeLocalFOM(const char* executionName);

   virtual void initializeDistributedFOM(const char* executionName);


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

   virtual void postJoinConfirmInit();

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

   virtual void setDesignatedFederate(bool isDesignated);
   virtual bool isDesignatedFederate();



   virtual void processSyncPointMsg(const DtSyncPointMsg& msg);

   virtual void processDesignatedFederateMsg(const DtDesignatedFederateMsg& msg);

   virtual void processFomModuleFileRequestMsg(const DtFomModuleRequestMsg& msg);

   virtual void processCreateResponseMsg(const DtCreateResponseMsg& msg);

   virtual void processReportFederationsMsg(const DtReportFederationsMsg& msg);

   virtual void processReportFederationMembersMsg(const DtReportFederationMembersMsg& msg);

   virtual void processJoinResponseMsg(const DtJoinResponseMsg& msg);

   virtual void processDestroyResponseMsg(const DtDestroyResponseMsg& msg);

   virtual void processSaveInitiate(const DtSaveInitiateMsg& msg);

   virtual void processSaveInitiate(const char* label);

   virtual void requestImmediateSave(const char *label);

   virtual void processSaveResponse(const DtSaveResponseMsg& msg);

   virtual void processSaveFinished(const DtSaveFinishedMsg& msg);

   virtual void processRestoreReply(const DtRestoreReplyMsg& msg);

   virtual void processRestoreEnd(const DtRestoreEndMsg& msg);

   virtual void processRestoreInitiate(const DtRestoreInitiateMsg& msg);

   virtual void processRestore(const DtRestoreMsg& msg);

#if !defined(DtIFSPEC13)
   virtual void processSaveStatusMsg(const DtSaveStatusMsg& msg);

   virtual void processRestoreStatusMsg(const DtRestoreStatusMsg& msg);
#endif

   virtual void processNewFomClassesMsg(const DtNewFomClassesMsg& msg);

   virtual void processResignResponseMsg(const DtResignRespMsg& msg);

   virtual void processRegisterNameMsg(const DtNameReservedMsg& msg);


   virtual void testSaveProgress() const;
   
   virtual void applyRidParameters();

   virtual void processNewFomClasses(const DtNewFomClassesMsg& msg);




   virtual void sendCreateMsg(MAKRti::DtString const & fedExNameVal,
      MAKRti::DtString const & timeImplName, const std::vector<unsigned int> & moduleCrcs,
      MAKRti::DtFomType fedType, MAKRti::DtString const &momModuleName,
      const std::vector<MAKRti::DtString>& fomModules, unsigned int momModuleCrc);

   virtual void sendDestroyMsg(const char* name);

   virtual void sendJoinMsg(
      unsigned long sourceID, unsigned short requestID, const char* fedType,
      const char* fedExName, const char* fedName,
      const std::vector<MAKRti::DtString>& fomModules,
      const unsigned long flags, const std::vector<unsigned int>& joinModulesCrcs);

   virtual void sendJoinConfirmMsg(
      unsigned long sourceID, DtJoinConfirmMsg::errorCodes errorCode);

   virtual void sendSyncPointMsg(DtSyncMsgType kind, DtFederateHandle& id,
       char const * name,
       DtRtiApiTagConstPtr tag = NULL,
       DtFederateHandleSet const * set = NULL);

#if defined(DtTIME)
   virtual void sendSaveRequestTsoMsg(char const * label,
       DtRtiApiTime const * time);
#endif

   virtual void sendSaveRequestMsg(unsigned long requestID, const char *label);

   virtual void sendSaveBegunMsg();

   virtual void sendSaveCompleteMsg(const char *label, bool success);

   virtual void sendRestoreRequestMsg(const char *label);

   virtual void sendRestoreBegunMsg(const char *label, DtResponseFlag response);

   virtual void sendRestoreCompleteMsg(const char *label, bool success);



   virtual void initiateSave();

   virtual void initiateTimedSave(DtRtiApiTime const& saveTime);

   virtual bool saveLRC(DtRtiSaveFile& saveFile);

   virtual bool save(DtRtiSaveFile& file);

   virtual void prepareToRestoreLRC();

   virtual bool restoreLRC(DtRtiSaveFile& saveFile);

   virtual void prepareToRestore();

   virtual bool restore( DtRtiSaveFile& file );

   virtual void posttick();

public:



   static void processSyncPointMsg(const DtSyncPointMsg& msg, void* usr);

   static void processDesignatedFederateMsg(const DtDesignatedFederateMsg& msg, void* usr);

   static void processFomModuleFileRequestMsg( const DtFomModuleRequestMsg& msg, void* usr);

   static void processCreateResponseMsg(const DtCreateResponseMsg& msg, void* usr);

   static void processReportFederationsMsg(const DtReportFederationsMsg& msg, void* usr);

   static void processReportFederationMembersMsg(const DtReportFederationMembersMsg& msg, void* usr);

   static void processJoinResponseMsg(const DtJoinResponseMsg& msg, void* usr);

   static void processDestroyResponseMsg(const DtDestroyResponseMsg& msg, void* usr);

#if !defined(DtIFSPEC13)
   static void processSaveStatusMsg(const DtSaveStatusMsg& msg, void* usr);

   static void processRestoreStatusMsg(const DtRestoreStatusMsg& msg, void* usr);
#endif

   static void processNewFomClassesMsg(const DtNewFomClassesMsg& msg, void* usr);

   static void processResignResponseMsg(const DtResignRespMsg& msg, void* usr);

   static void processRegisterNameMsg(const DtNameReservedMsg& msg, void* usr);


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

protected:
   
   std::map<DtString, DtSynchronousFileDistributor*> myDistributors;

   DtSynchronousFileDistributor* myJoinDistributor;

   DtCreateResponseFlag myCreateResponse;

   DtResignResponse myResignResponse;

   bool myResignResponseNotReceived;

   unsigned myRegisterNameResponse;

   MAKRti:: DtString myCreateResponseErrorString;

   DtDestroyResponseFlag myDestroyResponse;

   DtJoinResponseMsg* myJoinResponse;

   DtJoinConfirmMsg::errorCodes myJoinConfirmResponse;

   MAKRti::DtString myDestroyExecutionName;

   std::map<DtString, bool> myFedFileRequests;

   std::vector<MAKRti::DtString> myFomModuleRequests;

   unsigned short myJoinRequestID;

   unsigned long mySaveRequestID;

   DtSaveResponseFlag mySaveResponse;

   std::set<DtString> mySyncPoints;

#if defined(DtIFSPEC13)
   std::string* myFailedSyncPointLabel;
#else
   std::wstring* myFailedSyncPointLabel;
#endif

   DtFederateHandle myOldFedHandle;

   bool myIsDesignatedFederate;


   vrlmod::DtThreadedObject* myDistributorThread;
   bool myAsynchronousDistributor;

   std::list<DtNewFomClassesMsg*> myNewFomClassMsgs;

   bool myFullFedFileDistribution;
   MAKRti::DtString myHostname;

};

#endif