fedex.h

Go to the documentation of this file.

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


#pragma once

#include <rtiMsConfig.h>

#include "federate.h"
#include "timeInfoList.h"
#include "asynchronousFileDistributor.h"
#include "execCmds.h"
#include "distributorThreadEvents.h"

#include <rtiApiTypes.h>
#include <connection.h>
#include <fomMgr.h>
#include <vlThreadedObject.h>

#include <joinRespMsg.h>
#include <resignMsg.h>
#include <savRespMsg.h>
#include <syncPointMsg.h>
#include <savFinMsg.h>
#include <resEndMsg.h>
#include <resignRespMsg.h>
#include <creRespMsg.h>
#include <reportFederationMembersMsg.h>

#include <vlutil/vlString.h>
#include <vlutil/vlUtil.h>
#include <vlutil/vlFedTarget.h>

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

class DtRtiExec;
class DtRidFileTester;
class DtFederateHandleSet;
class DtLogicalTimeFactory;
class DtRIDParameters;
class DtSyncPt;
class DtTimeInfo;

class DtAliveMsg;
class DtTransferRidParamsMsg;
class DtConstrainedSyncMsg;
class DtDisableMsg;
class DtEnableRegulationMsg;
class DtEnableConstrainedMsg;
class DtJoinConfirmMsg;
class DtJoinMsg;
class DtNextEventRequestMsg;
class DtOwnershipMsg;
class DtResignMsg;
class DtResignDirectiveMsg;
class DtRestoreBegunMsg;
class DtRestoreCompleteMsg;
class DtRestoreRequestMsg;
class DtAbortRestoreMsg;
class DtSaveBegunMsg;
class DtSaveCompleteMsg;
class DtSaveRequestMsg;
class DtSaveRequestTsoMsg;
class DtAbortSaveMsg;
class DtInitiatedSaveMsg;
class DtSaveTimeAdvanceMsg;
class DtSyncPointMsg;
class DtSyncPointQueryMsg;
class DtTimeAdvanceRequestMsg;
class DtReserveNameMsg;
class DtQuerySaveStatusMsg;
class DtQueryRestoreStatusMsg;
class DtFedExec;
class DtFedJoinInfo;
class DtRtiAssistantExecClient;
class DtReserveMultiNameMsg;
class DtReleaseMultiNameMsg;
class DtFomModuleDistExecMsg;

typedef DtFedExec* (*DtFedExecCreator)(DtRtiExec* rtiexec, const std::vector<unsigned int> & crcs, DtString const & fedExName,
   std::string const & timeImplName, MAKRti::DtFomType fedType, const DtString& momModuleName,
   const std::vector<DtString>& fedFileName, int fedExHandle, DtRIDParameters* params, unsigned int momModuleCrc);

typedef void (*DtFederateCbFn)(DtFederate* federate, void* usr);

typedef void (*DtFederateCbFn)(DtFederate* handle, void* usr );

typedef void (*DtSyncPointCbFn)(DtSyncPt* pt, void* usr);

typedef void (*DtSyncPointAchievedCbFn)(DtFederate* who, DtSyncPt* pt, void* usr);

typedef std::map<DtFederateHandle, DtFederate*> DtFederateHandleInfoMap;

typedef std::map<DtString, DtFederate*> DtFederateNameInfoMap;

typedef std::pair< const DtString, DtFomClassMgr > DtFileToFedTgtPair;

typedef std::pair<DtString, DtFedReadStatus> DtFomToReadStatusPair;

class DT_DLL_EXEC DtFedExec
{

protected:
   
   DtFedExec(DtRtiExec* rtiexec, const std::vector<unsigned int> & crcs, DtString const & fedExName,
      std::string const & timeImplName, MAKRti::DtFomType fedType, const DtString& momModuleName,
      const std::vector<DtString >& modules,  int fedExHandle, DtRIDParameters* params, unsigned int momModuleCrc);
   
public:

   virtual ~DtFedExec();

   virtual DtConnectionMgr* connectMgr();

   virtual DtLogicalTimeFactory* fedTimeFactory();

   virtual const DtString& fedExName() const;

   virtual int fedExHandle() const;

   virtual const DtString& fedFileName() const;

   virtual const std::vector<DtString>& fomModules() const;

   virtual bool fullyCreated() const;

   virtual void setFullyCreated(bool val);

   virtual unsigned long creatorID() const;

   virtual void createDistributor( const unsigned long initiatingFedID,
      const DtString& momModuleName,
      const std::vector<DtString>& fomModules );

   virtual int numFederates() const;

   virtual DtFederate* getFederate(DtFederateHandle handle);

   virtual DtFedJoinInfo* getJoiningFederate(DtFederateHandle handle);

   virtual DtFederateHandle federateHandleOfConnection(unsigned long connId) const;

   virtual void disconnectFederate( DtFederate* fed );

   virtual bool removeFederateConnection(unsigned long id);

   virtual bool restoreFederateConnection( DtFederateHandle handle,
      unsigned long newConnId, unsigned long& oldConnId);

   virtual void reconnectFederateSucceeded( DtFederate* fed );

   virtual void reconnectFederateFailed( DtFederate* fed );

   virtual bool resignFederate(DtFederateHandle handle,
      DtResignAction action, DtResignReason reason );

   virtual void resetClockForHeartBeat();

   virtual bool tick();

   virtual void printFederates();

   virtual void addFederateJoinedCallback(DtFederateCbFn fn, void* usr);

   virtual void removeFederateJoinedCallback(DtFederateCbFn fn, void* usr);

   virtual void addFederateResignedCallback(DtFederateCbFn fn, void* usr);

   virtual void removeFederateResignedCallback(DtFederateCbFn fn, void* usr);

   virtual void addSyncPtRegisteredCallback(DtSyncPointCbFn fn, void* usr);

   virtual void removeSyncPtRegisteredCallback(DtSyncPointCbFn fn, void* usr);

   virtual void addSyncPtAchievedCallback(DtSyncPointAchievedCbFn fn, void* usr);

   virtual void removeSyncPtAchievedCallback(DtSyncPointAchievedCbFn fn, void* usr);

   virtual void addFederationSynchronizedCallback(DtSyncPointCbFn fn, void* usr);

   virtual void removeFederationSynchronizedCallback(DtSyncPointCbFn fn, void* usr);

   virtual void addFederateDisconnectedCallback(DtFederateCbFn fn, void* usr );

   virtual void removeFederateDisconnectedCallback(DtFederateCbFn fn, void* usr );

   //Register callbacks for federate reconnect.
   virtual void addFederateReconnectSucceededCallback(DtFederateCbFn fn, void* usr );

   //Unregister callbacks for federate reconnect.
   virtual void removeFederateReconnectSucceededCallback(DtFederateCbFn fn, void* usr );

   //Register callbacks for federate reconnect.
   virtual void addFederateReconnectFailedCallback(DtFederateCbFn fn, void* usr );

   // Unregister callbacks for federate reconnect.
   virtual void removeFederateReconnectFailedCallback(DtFederateCbFn fn, void* usr );

   void multFileReceivedCb(const DtFomModuleDistributionMsg& msg);

   void multFileRequestedCb(const DtFomModuleRequestMsg& msg);

   void pushFomModuleToJoinedFederates(DtFederate* newFederate,
      DtString fileName,
      unsigned int fileSize,
      const char* fileBuffer );

   void pushFomModuleToSingleFederate(DtFederateHandle recipient,
      DtString fileName,
      unsigned int fileSize,
      const char* fileBuffer );

   virtual void processRequestedModulesArrived( const DtRequestedModulesArrivedEvent& e );

   virtual void processFedFileRequestMsg( const DtFedFileRequestMsgEvent& e);

   virtual void processFileTransfer(const DtFedExTakeFileEvent& e);

   virtual DtFederateHandleInfoMap const& federates() const;

   virtual void getFederateList(DtReportFederationMembersMsg::DtFederateList& federates) const;

#ifdef DtTIME
   virtual const DtTimeInfoList* regulatingFederates() const;

   virtual const DtTimeInfoList* constrainedFederates() const;
#endif

   virtual void disableNetworkTesting();

   virtual void enableNetworkTesting();

   virtual void changeLatencyTestMode( DtFederateHandle handle, bool runTest,
      bool continuous, bool haltContinuous, bool observing, 
      unsigned int interactionPeriod, unsigned int numInteractions, 
      unsigned int payloadBytes );

   virtual bool transferRidParams(DtFederateHandle handle, const DtString& ridString);

public:


   static void processJoinMsg(const DtJoinMsg& msg, void* usr);
   static void processJoinConfirm(const DtJoinConfirmMsg& msg, void* usr);
   static void processAlive(const DtAliveMsg& msg,void* usr);
   static void processResign(const DtResignMsg& msg, void* usr);
   static void processResignDirective(const DtResignDirectiveMsg& msg, void* usr);
   static void processSyncPoint(const DtSyncPointMsg& msg, void* usr);
   static void processSyncPointQuery(const DtSyncPointQueryMsg& msg, void* usr);
   static void processSaveRequest(const DtSaveRequestMsg& msg, void* usr);
   static void processInitiatedSave(const DtInitiatedSaveMsg& msg, void* usr);
   static void processSaveComplete(const DtSaveCompleteMsg& msg, void* usr);
   static void processSaveBegun(const DtSaveBegunMsg& msg, void* usr);
   static void processAbortSave(const DtAbortSaveMsg& msg, void* usr);
   static void processRestoreRequest(const DtRestoreRequestMsg& msg, void* usr);
   static void processRestoreBegun(const DtRestoreBegunMsg& msg, void* usr);
   static void processRestoreComplete(const DtRestoreCompleteMsg& msg, void* usr);
   static void processAbortRestore(const DtAbortRestoreMsg& msg, void* usr);
   static void processOwnership(const DtOwnershipMsg& msg, void* usr);
   static void processReserveName(DtReserveNameMsg const& msg, void* usr);
   static void processReserveMultiName(DtReserveMultiNameMsg const& msg, void* usr);
   static void processReleaseMultiName(DtReleaseMultiNameMsg const& msg, void* usr);
   static void processQuerySaveStatus(DtQuerySaveStatusMsg const& msg, void* usr);
   static void processQueryRestoreStatus(DtQueryRestoreStatusMsg const& msg, void* usr);
#ifdef DtTIME
   static void processSaveTimeAdvance(const DtSaveTimeAdvanceMsg& msg, void* usr);
   static void processSaveRequestTso(const DtSaveRequestTsoMsg& msg, void* usr);
   static void processEnableRegulation(const DtEnableRegulationMsg& msg, void* usr);
   static void processEnableConstrained(const DtEnableConstrainedMsg& msg, void* usr);
   static void processTimeAdvanceRequest(const DtTimeAdvanceRequestMsg& msg, void* usr);
   static void processDisable(const DtDisableMsg& msg, void* usr);
   static void processConstrainedSync(const DtConstrainedSyncMsg& msg, void* usr);
   static void processNextEventRequest(const DtNextEventRequestMsg& msg, void* usr);
#endif


   static void multFileReceivedExecCb(const DtFomModuleDistExecMsg& msg, void* usr);

   static void multFileReceivedCb( const DtFomModuleDistributionMsg& msg, void* usr );

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

   static DtFedExec* create(DtRtiExec* rtiexec, const std::vector<unsigned int> & crcs, DtString const & fedExName,
      std::string const & timeImplName, MAKRti::DtFomType fedType, DtString const& momModuleName,
      const std::vector<DtString>& fomModules, int fedExHandle, DtRIDParameters* params, unsigned int momModuleCrc);

   static void setCreatorFunction(DtFedExecCreator creator);

   static void init( DtRtiAssistantExecClient* assistant );

protected:

   virtual const std::map< unsigned long, std::vector<DtString>*>& joinFomModules() const;
   
   virtual std::vector<DtString>& joinFomModulesForConnection(unsigned long connID) const;

   virtual const std::vector<DtString>& createFomModules() const;


   virtual void processJoinMsg(const DtJoinMsg& msg);   
   virtual bool handleJoinFailureCases( const DtJoinMsg &msg );   
   virtual void requestFedFileUpload( const DtJoinMsg& msg );
  
   virtual void processJoinConfirm(const DtJoinConfirmMsg& msg);
   virtual void processAlive(const DtAliveMsg& msg);
   virtual void processResign(const DtResignMsg& msg);
   virtual void processResignDirective(const DtResignDirectiveMsg& msg);
   virtual void processSyncPoint(const DtSyncPointMsg& msg);
   virtual void processSyncPointQuery(const DtSyncPointQueryMsg& msg);
   virtual void processSaveRequest(const DtSaveRequestMsg& msg);
   virtual void processInitiatedSave(const DtInitiatedSaveMsg& msg);
   virtual void processSaveComplete(const DtSaveCompleteMsg& msg);
   virtual void processSaveBegun(const DtSaveBegunMsg& msg);
   virtual void processAbortSave(const DtAbortSaveMsg& msg);
   virtual void processRestoreRequest(const DtRestoreRequestMsg& msg);
   virtual void processRestoreBegun(const DtRestoreBegunMsg& msg);
   virtual void processRestoreComplete(const DtRestoreCompleteMsg& msg);
   virtual void processAbortRestore(const DtAbortRestoreMsg& msg);
   virtual void processOwnership(const DtOwnershipMsg& msg);
   virtual void processReserveName(DtReserveNameMsg const& msg);
   virtual void processReserveMultiName(DtReserveMultiNameMsg const& msg);
   virtual void processReleaseMultiName(DtReleaseMultiNameMsg const& msg);
   virtual void processQuerySaveStatus(DtQuerySaveStatusMsg const& msg);
   virtual void processQueryRestoreStatus(DtQueryRestoreStatusMsg const& msg);

#ifdef DtTIME
   virtual void processEnableRegulation(const DtEnableRegulationMsg& msg);
   virtual void processEnableConstrained(const DtEnableConstrainedMsg& msg);
   virtual void processTimeAdvanceRequest(const DtTimeAdvanceRequestMsg& msg);
   virtual void processDisable(const DtDisableMsg& msg);
   virtual void processConstrainedSync( const DtConstrainedSyncMsg& msg);
   virtual void processSaveRequestTso(const DtSaveRequestTsoMsg& msg);
   virtual void processSaveTimeAdvance(const DtSaveTimeAdvanceMsg& msg);
   virtual void processNextEventRequest(const DtNextEventRequestMsg& msg);
#endif


   virtual void processRegisterSyncPoint(const DtSyncPointMsg& msg);

   virtual void processAchievedSyncPoint(const DtSyncPointMsg& msg);

   virtual void createSyncPoint(const DtSyncPointMsg& msg);

   virtual void processSyncPtAchievedCallbacks(DtSyncPt* point,
      DtFederate* federate);

   virtual void processFederationSynchronizedCallbacks(DtSyncPt* point);

   virtual bool synchronized(DtSyncPt* point,
      DtFederateHandleSet& unsuccessfulSet) const;

   virtual void sendSyncPointReport(const DtSyncPointQueryMsg& msg);

   virtual void sendSyncPointStatusReport(const DtSyncPointQueryMsg& msg);

   virtual DtFederate* addFederate(
     const char* federateType, const char* federateName, DtFederateHandle handle,
     unsigned long connHandle, int astntCompId, const char* fedHostName,
     MAKRti::DtInetAddr host, DtHlaVersionId hlaVersion);

   virtual DtFederate* createFederate(
     const char* federateType, const char* federateName,
     DtFederateHandle handle, unsigned long connHandle, int astntCompId,
     const char* fedHostname, MAKRti::DtInetAddr host,
     DtHlaVersionId hlaVersion);

   virtual bool isMember(DtFederateHandle handle) const;

   virtual bool deleteFederate(DtFederateHandle handle);


   virtual DtFedReadStatus readCreateFom(DtFomClassMgr* target, const DtString& fomFile,
      bool addToMap, DtCreateResponseFlag& response, DtString& errorResponseString);

   virtual DtFedReadStatus readCreateFoms(DtFomClassMgr* topLevelTarget, std::vector<DtString>& fomFiles,
      DtCreateResponseFlag& response, DtString& errorResponseString);

   virtual DtFedReadStatus readJoinFom(DtFomClassMgr* target, const DtString& fomFile,
      DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);

   virtual DtFedReadStatus readJoinFoms(std::vector<DtString>& fomFiles,
      DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);

   virtual bool processCreateReady();

   virtual bool processJoin(unsigned long connID, const DtFedJoinInfo* fedInfo);

   virtual void processJoinReady();

   virtual void destroyDistributor();

   virtual DtAsyncFileDistributorRunnable* distributor() const;

   virtual unsigned int numberFederatesAllowed(unsigned int numPartners) const;
 
   virtual void resetControl();

   virtual bool tickDistributor();

   virtual bool processEvents();

   virtual bool areJoinFomModulesUploadedAndReady(unsigned long federateId);

   virtual DtCreateResponseFlag handleCreateResponse(DtFedReadStatus status, const DtFedReader* fedReader,
      const DtString filename, DtString& errorResponse) const;

   virtual DtJoinResponseMsg::errorCodes handleJoinResponse(DtFedReadStatus status, const DtFedReader* fedReader,
      const DtString filename, DtString& errorResponse) const;

protected:


   DtFedReader * getReader(DtFomType theFomType);
   DtFedReader * getReader( DtFomType theFomType, DtFomClassMgr* target);

   void populateWithUnknownFoms(std::vector<DtString> & mods, std::vector<DtString> & requestedMods);
   bool isFomAvailable(const DtString & fomName);
   bool doesCrcMatchKnownFomModuleCrc( const DtString & fomName, unsigned int myTakenFomCrc );

   virtual bool fedFileReady(const MAKRti::DtString& fileName) const;

   virtual bool fedFilesReady( const std::vector<MAKRti::DtString>& fileNames ) const;

   virtual bool addJoinFomModuleForConnection( unsigned long connId,
      const std::vector<MAKRti::DtString>& modulesFromJoinRequest );      

   virtual void removeJoinFomModuleForConnection( unsigned long connID );

   virtual void updateNewClassesToJoinedFederates(DtFomClassMgr* target, DtFederateHandle joiningFederate);

   virtual void handleBadJoin(unsigned long connID, const DtFedJoinInfo* joinInfo, std::vector<DtString>& joinModules,
      DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);

   virtual void readAndMergeJoiningFomModules(unsigned long connID, DtFomClassMgr* target,
      DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);


   virtual void tickSaveRestore();

   virtual void tickJoin();

   virtual void tickFederates();
   

   virtual void sendSyncPointMsg(
      DtSyncMsgType kind, int id,
      DtSyncPointStatus status,
      const char* name,
      RTI_API::VariableLengthData const* theTag = NULL,
      const DtFederateHandleSet* set = NULL,
      const DtFederateHandleSet* unsuccessfulSet = NULL);

   virtual void sendResignMsg(
      const char* name, DtFederateHandle fedHandle, 
      DtResignAction action, DtResignReason reason,
      const DtTimeInfo* timeInfo );
   virtual void sendEnableDisableNetworkTestingMsg(
      const char* name, bool enabled );
   virtual void sendTransferRidParamsMsg(
      const char* name, DtFederateHandle fedHandle, const DtString& paramString);
   virtual void sendJoinResponseMsg(unsigned long destinationIDValue,
      unsigned short requestID, unsigned int crcOfFedFile, DtFederateHandle handle, 
      const char* federateName, int fedExHandle, const char* fedExName,
      const DtString& momModule, const std::vector<MAKRti::DtString>& modules,
      unsigned long flags, bool allowNetworkTesting, bool enableNetworkTesting,
      DtHlaVersionId hlaVers,
      DtJoinResponseMsg::errorCodes errorValue = DtJoinResponseMsg::DT_NO_ERROR,
      const DtString& errorString = DtString::nullString());
   virtual void sendResignResponseMsgIfNecessary( const DtResignMsg& msg, DtResignResponse response, DtFederateHandle fedHandle );
   virtual void sendSaveInitiateMsg(const char* labelVal);
   virtual void sendSaveInitiateConstrainedMsg(const char* labelVal);
   virtual void sendSaveResponse(DtFederateHandle fedHandle,
      unsigned long requestID, const char* labelVal,
      DtSaveResponseFlag response);
   virtual void sendDesignatedFederate(DtFederateHandle fedHandle);
   virtual void sendNameReservedMsg(DtFederateHandle requestingFederate,
      char const* objectName, bool result);
   virtual void sendMultiNameReservedMsg( DtFederateHandle requestingFederate, 
      std::set< std::wstring > const & objectNames,
      bool result );

   virtual void sendRestoreStatus(DtFederateHandle requestingFederate,
      DtRtiApiFederateRestoreStatusVector const & restoreStatusList);

   virtual void sendSaveStatus(DtFederateHandle requestingFederate,
      RTI_API::FederateHandleSaveStatusPairVector const & saveStatusList);

#ifdef DtTIME
   virtual void sendRegulationEnabledMsg(
      DtFederateHandle handle,
      DtRtiApiTime const & time);
   virtual void sendConstrainedEnabledMsg(
      DtFederateHandle handle,
      DtRtiApiTime const & time,
      DtRtiApiTime const & lbts);
   virtual void sendLbtsMsg(DtFederateHandle laggardFederate,
      DtRtiApiTime const & lbtsVal,
      DtRtiApiTime const & lagLbtsVal);
   virtual void sendNerLbtsMsg(
      unsigned long nerCycle, DtFederateHandle laggardFederate,
      bool nerPending, bool lagNerPending,
      DtRtiApiTime const & lbtsVal,
      DtRtiApiTime const & lagLbtsVal);
   virtual void sendSyncConstrainedMsg();
   virtual void sendResumeConstrainedMsg(DtFederateHandle laggardFederate,
      DtRtiApiTime const & lbtsVal,
      DtRtiApiTime const & lagLbtsVal);
   virtual void sendSaveTimeMsg(char const* label,
      DtRtiApiTime const & saveTime);
#endif 


   virtual void retireSyncPoint(const char* name);

   virtual void announceAllSyncPoints(DtFederateHandle hand);

   virtual void checkTimedSave();

   virtual void initiateSave(const char* label);

   virtual bool save( const char* label );

   virtual int  initializeRestore( const char* label );

   virtual bool restore( const char* label );

   virtual void endSave(DtSaveFinishedResult result);

   virtual void endRestore(DtEndRestoreResult restoreResult);

   virtual DtString& getSaveFileName(const char* label, MAKRti::DtString& fileName,
      bool extendName=true);

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

#ifdef DtTIME
   virtual void resignFederateTime(DtFederateHandle federateHandle);

   void disableFederateTimeRegulation(DtFederateHandle federateHandle);

   void removeRegulatingEntry(DtTimeInfo* entry);

   virtual void checkPendingConstrained(DtRtiApiTime const & lbts);

   virtual void checkPendingConstrained(DtTimeInfo* entry,
      DtRtiApiTime const & lbts);

   virtual bool becomeConstrained(DtTimeInfo* entry);

   void adjustRegulatingEntry(DtTimeInfo* entry,
      DtRtiApiTime const & time,
      DtRtiApiTimeInterval const & lookahead,
      bool isTimeAvailable);

   void checkNerCycle(DtFederateHandle fedHandle);

   virtual void processEnableRegulation(DtFederateHandle federateHandle,
      DtRtiApiTime const & time,
      DtRtiApiTimeInterval const & lookahead);

   virtual void processPendingRegulation(DtFederateHandle federateHandle,
      DtRtiApiTime const & time,
      DtRtiApiTimeInterval const & lookahead);

   virtual DtRtiApiTime& getTempTime();
   virtual void putTempTime(DtRtiApiTime& timePtr);
   virtual void destroyTempTimePool();

   virtual DtFederateHandle minLbtsFederate() const;

   virtual DtRtiApiTime const & minLbts() const;

   virtual DtRtiApiTime const & lagLbts() const;

   virtual bool minTimeAvailable() const;

   virtual bool lagTimeAvailable() const;

   virtual DtFederateHandle minNerLbtsFederate() const;

   virtual DtRtiApiTime const & minNerLbts() const;

   virtual DtFederateHandle lagNerLbtsFederate() const;

   virtual DtRtiApiTime const & lagNerLbts() const;

   virtual bool minNerPending() const;

   virtual bool lagNerPending() const;

   virtual void setSaveTime(DtRtiApiTime const & timeVal);

   virtual DtRtiApiTime const & saveTime() const;

   virtual unsigned int federateHandleSlot(DtFederateHandle handle) const;

   virtual bool isFederateHandleSlotInUse(DtFederateHandle handle) const;

   virtual void setFederateHandleSlotInUse(DtFederateHandle handle, bool isInUse);

#endif

   virtual bool authorizeFederateOperation(const DtJoinMsg& msg, DtString& errorMessage);


   virtual int getNextFreeFedHandle();


   DtFedExec();
   
   DtFedExec(const DtFedExec& orig);
   DtFedExec& operator=(DtFedExec const& orig);

protected:
   DtRtiExec* myRtiexec;
   unsigned int myCrcOfFedFile;
   int myFreeFedHandle;
   std::vector<bool> myFedHandlesInUse;
   bool myUseDestinationMetadata;
   DtString myFedExName;
   DtFederateHandleInfoMap myFederates;
   DtFederateNameInfoMap myFederatesByName;
   std::map< MAKRti::DtString, DtFederateHandle > myFederateHdlsByName;
   int myNumFederates;
   DtSyncHashlist mySyncList;   
   DtString myMomModule;
   unsigned int myMomModuleCrc;
   std::vector<unsigned int> myCreationFedFilesCRCs;
   MAKRti::DtFomType myFedType;
   std::vector<DtString> myFomModules;
   // ! This will be a Map with the keys being a FOM module name, and the value being its CRC.  
   // ! This map is populated at create and join
   std::map<DtString, unsigned int> myFomModulesNameToCrcMap;
   std::set<DtString> myFomModulesSet;
   std::vector<DtString> myCreateFomModules;
   std::map<unsigned long, std::vector<DtString>* >myJoinFomModules;
   DtFomClassMgr* myFom;

   int myFedExHandle;
   DtFederateHandle myDesignatedFederate;
   float myFederateTimeoutInterval;
   DtResignAction myResignAction;
   bool myAllowResignActionOverride;

   std::map<DtFederateHandle, DtFedJoinInfo*> myJoiningFederates;
   std::map<unsigned long, DtFedJoinInfo*> myJoiningFederatesByID;
   // List of joining federates that have been processed but are waiting for confirm
   std::set< unsigned long > myConnectionsJoinProcessed;
   int myNumberResponseAttempts;
   float myResponseInterval;

   bool mySave;
   bool myRestore;
   DtFederateHandleStdSet myPendingSaveFederates;
   DtFederateHandleStdSet myInitiatedSaveFederates;
   DtString mySaveLabel;
   DtFederateHandle mySavingFederate;
   DtFederateHandleStdSet myPendingRestoreFederates;
   DtFederateHandleInfoMap myRestoreFederatesByOld;
   DtFederateHandleInfoMap myRestoreFederatesByNew;
   DtString mySavePath;
   bool mySavePending;
   bool mySaveBegun;
   // When files are received from distributor, store them here until requester takes them.
   std::map<DtString, DtFileInformation*> myTakenFiles;
   // When FOMs are read, map FOM filename to fed target here.
   std::map< const DtString, DtFomClassMgr > myFedexFileToFedTgtMap;
   std::map<DtString, DtFedReadStatus> myFomToReadStatusMap;
   // Maps source IDs to booleans, used to ensure that another FED request isn't sent by the same
   // federate after the first successful request occurs
   std::map<unsigned long, bool> myFedRequests;

   bool myAwaitingCreateUpload;
   unsigned long myCreatorConnId;
   std::set< unsigned long> myAwaitingJoinUpload;
   bool myFullyCreated;

   int myTimeout;
   int myDefaultWait;

   DtList myJoinCallbacks;
   DtList myResignCallbacks;
   DtList myDisconnectCallbacks;
   DtList myReconnectSucceededCallbacks;
   DtList myReconnectFailedCallbacks;
   DtList myFedSynchronizedCallbacks;
   DtList mySpAchievedCallbacks;
   DtList mySpRegisterCallbacks;

   typedef std::set<std::string> DtFedExReservedNameSet;
   typedef std::map< DtFederateHandle, DtFedExReservedNameSet >
      DtFedExFederateReservedNameMap;
   DtFedExReservedNameSet myReservedNames;
   DtFedExFederateReservedNameMap myFederateReservedNames;

#ifdef DtTIME
   DtLogicalTimeFactory* myLogicalTimeFactory;
   DtTimeInfoList myRegulatingFederates;
   DtTimeInfoList myConstrainedFederates;
   DtTimeInfoList myPendingConstrained;
   DtTimeInfoList myPendingTar;
   DtTimeInfoList myPendingRegulation;
   DtTimeInfoList myNerLbtsList;
   DtTimeInfoList myNerRequested;
   DtTimeInfoList myPendingNerResponses;
   bool myNewNerRequestPending;
   bool myForceNerCycle;
   bool myNerChange;
   bool myTransmitLaggardLBTS;
   DtList mySyncConstrained;
   unsigned long myNerCycle;
   DtFederateHandle myNerFederate;
   DtFederateHandle myLagNerFederate;
   DtList myTempTimePool;
   DtRtiApiUniquePtrTime myPositiveInfinity;
   DtRtiApiUniquePtrTime mySaveTime;
   DtRtiApiUniquePtrTime myNerLbts;
   DtRtiApiUniquePtrTime myLagNerLbts;
#endif 
   
   vrlmod::DtThreadedObject* myDistributorThread;
   DtAsyncFileDistributorRunnable* myDistributor;
   static const std::vector<DtString> theEmptyStringSet;
   bool myDistributeFedFile;
   bool myCrcCheckFedFile;
   unsigned long myInitiatorID;
   int myStrictNameReservation;
   bool myAllowNetworkTesting;
   bool myNetworkTestingEnabled;
   bool myModulesArrived;

   DtClock myClock;

   unsigned int myNumberFederatesAllowed;

protected:

   static DtFedExecCreator theCreator;  
   //DtFedReaderFactory myFedReaderFactory;
   DtFedReader13 * myFedReader13;
   DtFedReader1516 * myFedReader1516;
   DtFedReader1516e * myFedReader1516e;
   DtFedReader1516_4 * myFedReader1516_2025;

private:

   static const DtString nullStr;
   bool myFullFedFileDistribution;

};