MAK RTIspy API Documentation for HLA 4
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
fedex.h
Go to the documentation of this file.
1 /*********************************************************************
2 ** Copyright (c) 1998 MaK Technologies, Inc.
3 ** All rights reserved.
4 *********************************************************************/
5 /*********************************************************************
6 ** $RCSfile: fedex.h,v $ $Revision: 1.24 $ $State: Exp $
7 *********************************************************************/
8 
11 
12 #pragma once
13 
14 #include <rtiMsConfig.h>
15 
16 #include "federate.h"
17 #include "timeInfoList.h"
18 #include "asynchronousFileDistributor.h"
19 #include "execCmds.h"
20 #include "distributorThreadEvents.h"
21 
22 #include <rtiApiTypes.h>
23 #include <connection.h>
24 #include <fomMgr.h>
25 #include <vlThreadedObject.h>
26 
27 #include <joinRespMsg.h>
28 #include <resignMsg.h>
29 #include <savRespMsg.h>
30 #include <syncPointMsg.h>
31 #include <savFinMsg.h>
32 #include <resEndMsg.h>
33 #include <resignRespMsg.h>
34 #include <creRespMsg.h>
35 #include <reportFederationMembersMsg.h>
36 
37 #include <vlutil/vlString.h>
38 #include <vlutil/vlUtil.h>
39 #include <vlutil/vlFedTarget.h>
40 
41 #include <mtl/fedReader13.h>
42 #include <mtl/fedReader1516.h>
43 #include <mtl/fedReader1516e.h>
44 #include <mtl/fedReader1516_4.h>
45 
46 class DtRtiExec;
47 class DtRidFileTester;
48 class DtFederateHandleSet;
49 class DtLogicalTimeFactory;
50 class DtRIDParameters;
51 class DtSyncPt;
52 class DtTimeInfo;
53 
54 class DtAliveMsg;
55 class DtTransferRidParamsMsg;
56 class DtConstrainedSyncMsg;
57 class DtDisableMsg;
58 class DtEnableRegulationMsg;
59 class DtEnableConstrainedMsg;
60 class DtJoinConfirmMsg;
61 class DtJoinMsg;
62 class DtNextEventRequestMsg;
63 class DtOwnershipMsg;
64 class DtResignMsg;
65 class DtResignDirectiveMsg;
66 class DtRestoreBegunMsg;
67 class DtRestoreCompleteMsg;
68 class DtRestoreRequestMsg;
69 class DtAbortRestoreMsg;
70 class DtSaveBegunMsg;
71 class DtSaveCompleteMsg;
72 class DtSaveRequestMsg;
73 class DtSaveRequestTsoMsg;
74 class DtAbortSaveMsg;
75 class DtInitiatedSaveMsg;
76 class DtSaveTimeAdvanceMsg;
77 class DtSyncPointMsg;
78 class DtSyncPointQueryMsg;
79 class DtTimeAdvanceRequestMsg;
80 class DtReserveNameMsg;
81 class DtQuerySaveStatusMsg;
82 class DtQueryRestoreStatusMsg;
83 class DtFedExec;
84 class DtFedJoinInfo;
85 class DtRtiAssistantExecClient;
86 class DtReserveMultiNameMsg;
87 class DtReleaseMultiNameMsg;
88 class DtFomModuleDistExecMsg;
89 
91 typedef DtFedExec* (*DtFedExecCreator)(DtRtiExec* rtiexec, const std::vector<unsigned int> & crcs, DtString const & fedExName,
92  std::string const & timeImplName, MAKRti::DtFomType fedType, const DtString& momModuleName,
93  const std::vector<DtString>& fedFileName, int fedExHandle, DtRIDParameters* params, unsigned int momModuleCrc);
94 
96 typedef void (*DtFederateCbFn)(DtFederate* federate, void* usr);
97 
99 typedef void (*DtFederateHandleCbFn)(DtFederateHandle handle, void* usr );
100 
102 typedef void (*DtSyncPointCbFn)(DtSyncPt* pt, void* usr);
103 
105 typedef void (*DtSyncPointAchievedCbFn)(DtFederate* who, DtSyncPt* pt, void* usr);
106 
108 typedef std::map<DtFederateHandle, DtFederate*> DtFederateHandleInfoMap;
109 
111 typedef std::map<DtString, DtFederate*> DtFederateNameInfoMap;
112 
113 typedef std::pair< const DtString, DtFomClassMgr > DtFileToFedTgtPair;
114 
115 typedef std::pair<DtString, DtFedReadStatus> DtFomToReadStatusPair;
116 
117 class DT_DLL_EXEC DtFedExec
118 {
119 
120 protected:
121 
123  DtFedExec(DtRtiExec* rtiexec, const std::vector<unsigned int> & crcs, DtString const & fedExName,
124  std::string const & timeImplName, MAKRti::DtFomType fedType, const DtString& momModuleName,
125  const std::vector<DtString >& modules, int fedExHandle, DtRIDParameters* params, unsigned int momModuleCrc);
126 
127 public:
128 
130  virtual ~DtFedExec();
131 
133  virtual DtConnectionMgr* connectMgr();
134 
136  virtual DtLogicalTimeFactory* fedTimeFactory();
137 
139  virtual const DtString& fedExName() const;
140 
142  virtual int fedExHandle() const;
143 
146  virtual const DtString& fedFileName() const;
147 
149  virtual const std::vector<DtString>& fomModules() const;
150 
152  virtual bool fullyCreated() const;
153 
155  virtual void setFullyCreated(bool val);
156 
158  virtual unsigned long creatorID() const;
159 
161  virtual void createDistributor( const unsigned long initiatingFedID,
162  const DtString& momModuleName,
163  const std::vector<DtString>& fomModules );
164 
166  virtual int numFederates() const;
167 
170  virtual DtFederate* getFederate(DtFederateHandle handle);
171 
174  virtual DtFedJoinInfo* getJoiningFederate(DtFederateHandle handle);
175 
178  virtual DtFederateHandle federateHandleOfConnection(unsigned long connId) const;
179 
181  virtual void disconnectFederate( DtFederate* fed );
182 
184  virtual bool removeFederateConnection(unsigned long id);
185 
190  virtual bool restoreFederateConnection( DtFederateHandle handle, unsigned long newConnId, unsigned long& oldConnId);
191 
193  virtual bool resignFederate(DtFederateHandle handle,
194  DtResignAction action, DtResignReason reason );
195 
202  virtual void resetClockForHeartBeat();
203 
205  virtual bool tick();
206 
208  virtual void printFederates();
209 
211  virtual void addFederateJoinedCallback(DtFederateCbFn fn, void* usr);
212 
214  virtual void removeFederateJoinedCallback(DtFederateCbFn fn, void* usr);
215 
217  virtual void addFederateResignedCallback(DtFederateCbFn fn, void* usr);
218 
220  virtual void removeFederateResignedCallback(DtFederateCbFn fn, void* usr);
221 
224  virtual void addSyncPtRegisteredCallback(DtSyncPointCbFn fn, void* usr);
225 
228  virtual void removeSyncPtRegisteredCallback(DtSyncPointCbFn fn, void* usr);
229 
232  virtual void addSyncPtAchievedCallback(DtSyncPointAchievedCbFn fn, void* usr);
233 
236  virtual void removeSyncPtAchievedCallback(DtSyncPointAchievedCbFn fn, void* usr);
237 
240  virtual void addFederationSynchronizedCallback(DtSyncPointCbFn fn, void* usr);
241 
244  virtual void removeFederationSynchronizedCallback(DtSyncPointCbFn fn, void* usr);
245 
247  virtual void addFederateDisconnectedCallback(DtFederateCbFn fn, void* usr );
248 
250  virtual void removeFederateDisconnectedCallback(DtFederateCbFn fn, void* usr );
251 
252  //Register callbacks for federate reconnect.
253  virtual void addFederateReconnectSucceededCallback(DtFederateCbFn fn, void* usr );
254 
255  //Unregister callbacks for federate reconnect.
256  virtual void removeFederateReconnectSucceededCallback(DtFederateCbFn fn, void* usr );
257 
258  //Register callbacks for federate reconnect.
259  virtual void addFederateReconnectFailedCallback(DtFederateHandleCbFn fn, void* usr );
260 
261  // Unregister callbacks for federate reconnect.
262  virtual void removeFederateReconnectFailedCallback(DtFederateHandleCbFn fn, void* usr );
263 
265  void multFileReceivedCb(const DtFomModuleDistributionMsg& msg);
266 
268  void multFileRequestedCb(const DtFomModuleRequestMsg& msg);
269 
271  void pushFomModuleToJoinedFederates(DtFederate* newFederate,
272  DtString fileName,
273  unsigned int fileSize,
274  const char* fileBuffer );
275 
277  void pushFomModuleToSingleFederate(DtFederateHandle recipient,
278  DtString fileName,
279  unsigned int fileSize,
280  const char* fileBuffer );
281 
283  virtual void processRequestedModulesArrived( const DtRequestedModulesArrivedEvent& e );
284 
286  virtual void processFedFileRequestMsg( const DtFedFileRequestMsgEvent& e);
287 
289  virtual void processFileTransfer(const DtFedExTakeFileEvent& e);
290 
292  virtual DtFederateHandleInfoMap const& federates() const;
293 
295  virtual void getFederateList(DtReportFederationMembersMsg::DtFederateList& federates) const;
296 
297 #ifdef DtTIME
298  virtual const DtTimeInfoList* regulatingFederates() const;
300 
302  virtual const DtTimeInfoList* constrainedFederates() const;
303 #endif
304 
306  virtual void disableNetworkTesting();
307 
309  virtual void enableNetworkTesting();
310 
312  virtual void changeLatencyTestMode( DtFederateHandle handle, bool runTest,
313  bool continuous, bool haltContinuous, bool observing,
314  unsigned int interactionPeriod, unsigned int numInteractions,
315  unsigned int payloadBytes );
316 
318  virtual bool transferRidParams(DtFederateHandle handle, const DtString& ridString);
319 
320 public:
321 
324 
325  static void processJoinMsg(const DtJoinMsg& msg, void* usr);
326  static void processJoinConfirm(const DtJoinConfirmMsg& msg, void* usr);
327  static void processAlive(const DtAliveMsg& msg,void* usr);
328  static void processResign(const DtResignMsg& msg, void* usr);
329  static void processResignDirective(const DtResignDirectiveMsg& msg, void* usr);
330  static void processSyncPoint(const DtSyncPointMsg& msg, void* usr);
331  static void processSyncPointQuery(const DtSyncPointQueryMsg& msg, void* usr);
332  static void processSaveRequest(const DtSaveRequestMsg& msg, void* usr);
333  static void processInitiatedSave(const DtInitiatedSaveMsg& msg, void* usr);
334  static void processSaveComplete(const DtSaveCompleteMsg& msg, void* usr);
335  static void processSaveBegun(const DtSaveBegunMsg& msg, void* usr);
336  static void processAbortSave(const DtAbortSaveMsg& msg, void* usr);
337  static void processRestoreRequest(const DtRestoreRequestMsg& msg, void* usr);
338  static void processRestoreBegun(const DtRestoreBegunMsg& msg, void* usr);
339  static void processRestoreComplete(const DtRestoreCompleteMsg& msg, void* usr);
340  static void processAbortRestore(const DtAbortRestoreMsg& msg, void* usr);
341  static void processOwnership(const DtOwnershipMsg& msg, void* usr);
342  static void processReserveName(DtReserveNameMsg const& msg, void* usr);
343  static void processReserveMultiName(DtReserveMultiNameMsg const& msg, void* usr);
344  static void processReleaseMultiName(DtReleaseMultiNameMsg const& msg, void* usr);
345  static void processQuerySaveStatus(DtQuerySaveStatusMsg const& msg, void* usr);
346  static void processQueryRestoreStatus(DtQueryRestoreStatusMsg const& msg, void* usr);
347 #ifdef DtTIME
348  static void processSaveTimeAdvance(const DtSaveTimeAdvanceMsg& msg, void* usr);
349  static void processSaveRequestTso(const DtSaveRequestTsoMsg& msg, void* usr);
350  static void processEnableRegulation(const DtEnableRegulationMsg& msg, void* usr);
351  static void processEnableConstrained(const DtEnableConstrainedMsg& msg, void* usr);
352  static void processTimeAdvanceRequest(const DtTimeAdvanceRequestMsg& msg, void* usr);
353  static void processDisable(const DtDisableMsg& msg, void* usr);
354  static void processConstrainedSync(const DtConstrainedSyncMsg& msg, void* usr);
355  static void processNextEventRequest(const DtNextEventRequestMsg& msg, void* usr);
356 #endif
357 
358 
360  static void multFileReceivedExecCb(const DtFomModuleDistExecMsg& msg, void* usr);
361 
363  static void multFileReceivedCb( const DtFomModuleDistributionMsg& msg, void* usr );
364 
366  static void multFileRequestedCb( const DtFomModuleRequestMsg& msg, void* usr );
367 
369  static DtFedExec* create(DtRtiExec* rtiexec, const std::vector<unsigned int> & crcs, DtString const & fedExName,
370  std::string const & timeImplName, MAKRti::DtFomType fedType, DtString const& momModuleName,
371  const std::vector<DtString>& fomModules, int fedExHandle, DtRIDParameters* params, unsigned int momModuleCrc);
372 
376  static void setCreatorFunction(DtFedExecCreator creator);
377 
378  static void init( DtRtiAssistantExecClient* assistant );
379 
380 protected:
381 
383  virtual const std::map< unsigned long, std::vector<DtString>*>& joinFomModules() const;
384 
385  virtual std::vector<DtString>& joinFomModulesForConnection(unsigned long connID) const;
386 
388  virtual const std::vector<DtString>& createFomModules() const;
389 
391  virtual void reconnectFederateSucceeded(DtFederate* fed);
392 
394  virtual void reconnectFederateFailed(DtFederateHandle federateHandle);
395 
398 
399  virtual void processJoinMsg(const DtJoinMsg& msg);
400  virtual bool handleJoinFailureCases( const DtJoinMsg &msg );
401  virtual void requestFedFileUpload( const DtJoinMsg& msg );
402 
403  virtual void processJoinConfirm(const DtJoinConfirmMsg& msg);
404  virtual void processAlive(const DtAliveMsg& msg);
405  virtual void processResign(const DtResignMsg& msg);
406  virtual void processResignDirective(const DtResignDirectiveMsg& msg);
407  virtual void processSyncPoint(const DtSyncPointMsg& msg);
408  virtual void processSyncPointQuery(const DtSyncPointQueryMsg& msg);
409  virtual void processSaveRequest(const DtSaveRequestMsg& msg);
410  virtual void processInitiatedSave(const DtInitiatedSaveMsg& msg);
411  virtual void processSaveComplete(const DtSaveCompleteMsg& msg);
412  virtual void processSaveBegun(const DtSaveBegunMsg& msg);
413  virtual void processAbortSave(const DtAbortSaveMsg& msg);
414  virtual void processRestoreRequest(const DtRestoreRequestMsg& msg);
415  virtual void processRestoreBegun(const DtRestoreBegunMsg& msg);
416  virtual void processRestoreComplete(const DtRestoreCompleteMsg& msg);
417  virtual void processAbortRestore(const DtAbortRestoreMsg& msg);
418  virtual void processOwnership(const DtOwnershipMsg& msg);
419  virtual void processReserveName(DtReserveNameMsg const& msg);
420  virtual void processReserveMultiName(DtReserveMultiNameMsg const& msg);
421  virtual void processReleaseMultiName(DtReleaseMultiNameMsg const& msg);
422  virtual void processQuerySaveStatus(DtQuerySaveStatusMsg const& msg);
423  virtual void processQueryRestoreStatus(DtQueryRestoreStatusMsg const& msg);
424 
425 #ifdef DtTIME
426  virtual void processEnableRegulation(const DtEnableRegulationMsg& msg);
427  virtual void processEnableConstrained(const DtEnableConstrainedMsg& msg);
428  virtual void processTimeAdvanceRequest(const DtTimeAdvanceRequestMsg& msg);
429  virtual void processDisable(const DtDisableMsg& msg);
430  virtual void processConstrainedSync( const DtConstrainedSyncMsg& msg);
431  virtual void processSaveRequestTso(const DtSaveRequestTsoMsg& msg);
432  virtual void processSaveTimeAdvance(const DtSaveTimeAdvanceMsg& msg);
433  virtual void processNextEventRequest(const DtNextEventRequestMsg& msg);
434 #endif
435 
437 
439  virtual void processRegisterSyncPoint(const DtSyncPointMsg& msg);
440 
442  virtual void processAchievedSyncPoint(const DtSyncPointMsg& msg);
443 
445  virtual void createSyncPoint(const DtSyncPointMsg& msg);
446 
448  virtual void processSyncPtAchievedCallbacks(DtSyncPt* point,
449  DtFederate* federate);
450 
452  virtual void processFederationSynchronizedCallbacks(DtSyncPt* point);
453 
457  virtual bool synchronized(DtSyncPt* point,
458  DtFederateHandleSet& unsuccessfulSet) const;
459 
461  virtual void sendSyncPointReport(const DtSyncPointQueryMsg& msg);
462 
464  virtual void sendSyncPointStatusReport(const DtSyncPointQueryMsg& msg);
465 
467  virtual DtFederate* addFederate(
468  const char* federateType, const char* federateName, DtFederateHandle handle,
469  unsigned long connHandle, int astntCompId, const char* fedHostName,
470  MAKRti::DtInetAddr host, DtHlaVersionId hlaVersion);
471 
474  virtual DtFederate* createFederate(
475  const char* federateType, const char* federateName,
476  DtFederateHandle handle, unsigned long connHandle, int astntCompId,
477  DtResignAction resignAction, const char* fedHostname, MAKRti::DtInetAddr host,
478  DtHlaVersionId hlaVersion);
479 
481  virtual bool isMember(DtFederateHandle handle) const;
482 
485  virtual bool deleteFederate(DtFederateHandle handle);
486 
488 
490  virtual DtFedReadStatus readCreateFom(DtFomClassMgr* target, const DtString& fomFile,
491  bool addToMap, DtCreateResponseFlag& response, DtString& errorResponseString);
492 
496  virtual DtFedReadStatus readCreateFoms(DtFomClassMgr* topLevelTarget, std::vector<DtString>& fomFiles,
497  DtCreateResponseFlag& response, DtString& errorResponseString);
498 
500  virtual DtFedReadStatus readJoinFom(DtFomClassMgr* target, const DtString& fomFile,
501  DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);
502 
505  virtual DtFedReadStatus readJoinFoms(std::vector<DtString>& fomFiles,
506  DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);
507 
509  virtual bool processCreateReady();
510 
513  virtual bool processJoin(unsigned long connID, const DtFedJoinInfo* fedInfo);
514 
517  virtual void processJoinReady();
518 
520  virtual void destroyDistributor();
521 
523  virtual DtAsyncFileDistributorRunnable* distributor() const;
524 
530  virtual unsigned int numberFederatesAllowed(unsigned int numPartners) const;
531 
533  virtual void resetControl();
534 
536  virtual bool tickDistributor();
537 
539  virtual bool processEvents();
540 
542  virtual bool areJoinFomModulesUploadedAndReady(unsigned long federateId);
543 
545  virtual DtCreateResponseFlag handleCreateResponse(DtFedReadStatus status, const DtFedReader* fedReader,
546  const DtString filename, DtString& errorResponse) const;
547 
549  virtual DtJoinResponseMsg::errorCodes handleJoinResponse(DtFedReadStatus status, const DtFedReader* fedReader,
550  const DtString filename, DtString& errorResponse) const;
551 
552 protected:
553 
554 
555  DtFedReader * getReader(DtFomType theFomType);
556  DtFedReader * getReader( DtFomType theFomType, DtFomClassMgr* target);
557 
558  void populateWithUnknownFoms(std::vector<DtString> & mods, std::vector<DtString> & requestedMods);
559  bool isFomAvailable(const DtString & fomName);
560  bool doesCrcMatchKnownFomModuleCrc( const DtString & fomName, unsigned int myTakenFomCrc );
561 
563  virtual bool fedFileReady(const MAKRti::DtString& fileName) const;
564 
566  virtual bool fedFilesReady( const std::vector<MAKRti::DtString>& fileNames ) const;
567 
569  virtual bool addJoinFomModuleForConnection( unsigned long connId,
570  const std::vector<MAKRti::DtString>& modulesFromJoinRequest );
571 
573  virtual void removeJoinFomModuleForConnection( unsigned long connID );
574 
576  virtual void updateNewClassesToJoinedFederates(DtFomClassMgr* target, DtFederateHandle joiningFederate);
577 
579  virtual void handleBadJoin(unsigned long connID, const DtFedJoinInfo* joinInfo, std::vector<DtString>& joinModules,
580  DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);
581 
583  virtual void readAndMergeJoiningFomModules(unsigned long connID, DtFomClassMgr* target,
584  DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);
585 
587 
589  virtual void tickSaveRestore();
590 
593  virtual void tickJoin();
594 
597  virtual void tickFederates();
598 
601 
602  virtual void sendSyncPointMsg(
603  DtSyncMsgType kind, int id,
604  DtSyncPointStatus status,
605  const char* name,
606  RTI_API::VariableLengthData const* theTag = NULL,
607  const DtFederateHandleSet* set = NULL,
608  const DtFederateHandleSet* unsuccessfulSet = NULL);
609 
610  virtual void sendResignMsg(
611  const char* name, DtFederateHandle fedHandle,
612  DtResignAction action, DtResignReason reason,
613  const DtTimeInfo* timeInfo );
614  virtual void sendEnableDisableNetworkTestingMsg(
615  const char* name, bool enabled );
616  virtual void sendTransferRidParamsMsg(
617  const char* name, DtFederateHandle fedHandle, const DtString& paramString);
618  virtual void sendJoinResponseMsg(unsigned long destinationIDValue,
619  unsigned short requestID, unsigned int crcOfFedFile, DtFederateHandle handle,
620  const char* federateName, int fedExHandle, const char* fedExName,
621  const DtString& momModule, const std::vector<MAKRti::DtString>& modules,
622  unsigned long flags, bool allowNetworkTesting, bool enableNetworkTesting,
623  DtHlaVersionId hlaVers,
624  DtJoinResponseMsg::errorCodes errorValue = DtJoinResponseMsg::DT_NO_ERROR,
625  const DtString& errorString = DtString::nullString());
626  virtual void sendResignResponseMsgIfNecessary( const DtResignMsg& msg, DtResignResponse response, DtFederateHandle fedHandle );
627  virtual void sendSaveInitiateMsg(const char* labelVal);
628  virtual void sendSaveInitiateConstrainedMsg(const char* labelVal);
629  virtual void sendSaveResponse(DtFederateHandle fedHandle,
630  unsigned long requestID, const char* labelVal,
631  DtSaveResponseFlag response);
632  virtual void sendDesignatedFederate(DtFederateHandle fedHandle);
633  virtual void sendNameReservedMsg(DtFederateHandle requestingFederate,
634  char const* objectName, bool result);
635  virtual void sendMultiNameReservedMsg( DtFederateHandle requestingFederate,
636  std::set< std::wstring > const & objectNames,
637  bool result );
638 
639  virtual void sendRestoreStatus(DtFederateHandle requestingFederate,
640  DtRtiApiFederateRestoreStatusVector const & restoreStatusList);
641 
642  virtual void sendSaveStatus(DtFederateHandle requestingFederate,
643  RTI_API::FederateHandleSaveStatusPairVector const & saveStatusList);
644 
645 #ifdef DtTIME
646  virtual void sendRegulationEnabledMsg(
647  DtFederateHandle handle,
648  DtRtiApiTime const & time);
649  virtual void sendConstrainedEnabledMsg(
650  DtFederateHandle handle,
651  DtRtiApiTime const & time,
652  DtRtiApiTime const & lbts);
653  virtual void sendLbtsMsg(DtFederateHandle laggardFederate,
654  DtRtiApiTime const & lbtsVal,
655  DtRtiApiTime const & lagLbtsVal);
656  virtual void sendNerLbtsMsg(
657  unsigned long nerCycle, DtFederateHandle laggardFederate,
658  bool nerPending, bool lagNerPending,
659  DtRtiApiTime const & lbtsVal,
660  DtRtiApiTime const & lagLbtsVal);
661  virtual void sendSyncConstrainedMsg();
662  virtual void sendResumeConstrainedMsg(DtFederateHandle laggardFederate,
663  DtRtiApiTime const & lbtsVal,
664  DtRtiApiTime const & lagLbtsVal);
665  virtual void sendSaveTimeMsg(char const* label,
666  DtRtiApiTime const & saveTime);
667 #endif
668 
669 
670  virtual void retireSyncPoint(const char* name);
673 
676  virtual void announceAllSyncPoints(DtFederateHandle hand);
677 
679  virtual void checkTimedSave();
680 
682  virtual void initiateSave(const char* label);
683 
686  virtual bool save( const char* label );
687 
690  virtual int initializeRestore( const char* label );
691 
694  virtual bool restore( const char* label );
695 
697  virtual void endSave(DtSaveFinishedResult result);
698 
700  virtual void endRestore(DtEndRestoreResult restoreResult);
701 
704  virtual DtString& getSaveFileName(const char* label, MAKRti::DtString& fileName,
705  bool extendName=true);
706 
709  virtual DtString& getRestoreFileName(const char* label, MAKRti::DtString& fileName);
710 
711 #ifdef DtTIME
712  virtual void resignFederateTime(DtFederateHandle federateHandle);
714 
716  void disableFederateTimeRegulation(DtFederateHandle federateHandle);
717 
719  void removeRegulatingEntry(DtTimeInfo* entry);
720 
722  virtual void checkPendingConstrained(DtRtiApiTime const & lbts);
723 
725  virtual void checkPendingConstrained(DtTimeInfo* entry,
726  DtRtiApiTime const & lbts);
727 
730  virtual bool becomeConstrained(DtTimeInfo* entry);
731 
734  void adjustRegulatingEntry(DtTimeInfo* entry,
735  DtRtiApiTime const & time,
736  DtRtiApiTimeInterval const & lookahead,
737  bool isTimeAvailable);
738 
740  void checkNerCycle(DtFederateHandle fedHandle);
741 
743  virtual void processEnableRegulation(DtFederateHandle federateHandle,
744  DtRtiApiTime const & time,
745  DtRtiApiTimeInterval const & lookahead);
746 
749  virtual void processPendingRegulation(DtFederateHandle federateHandle,
750  DtRtiApiTime const & time,
751  DtRtiApiTimeInterval const & lookahead);
752 
754  virtual DtRtiApiTime& getTempTime();
760  virtual void putTempTime(DtRtiApiTime& timePtr);
762  virtual void destroyTempTimePool();
764 
766  virtual DtFederateHandle minLbtsFederate() const;
767 
769  virtual DtRtiApiTime const & minLbts() const;
770 
772  virtual DtRtiApiTime const & lagLbts() const;
773 
776  virtual bool minTimeAvailable() const;
777 
780  virtual bool lagTimeAvailable() const;
781 
783  virtual DtFederateHandle minNerLbtsFederate() const;
784 
786  virtual DtRtiApiTime const & minNerLbts() const;
787 
789  virtual DtFederateHandle lagNerLbtsFederate() const;
790 
792  virtual DtRtiApiTime const & lagNerLbts() const;
793 
795  virtual bool minNerPending() const;
796 
798  virtual bool lagNerPending() const;
799 
801  virtual void setSaveTime(DtRtiApiTime const & timeVal);
802 
804  virtual DtRtiApiTime const & saveTime() const;
805 
807  virtual unsigned int federateHandleSlot(DtFederateHandle handle) const;
808 
810  virtual bool isFederateHandleSlotInUse(DtFederateHandle handle) const;
811 
813  virtual void setFederateHandleSlotInUse(DtFederateHandle handle, bool isInUse);
814 
815 #endif
816 
818  virtual bool authorizeFederateOperation(const DtJoinMsg& msg, DtString& errorMessage);
819 
820 
823  virtual int getNextFreeFedHandle();
824 
825 
827  DtFedExec();
828 
830  DtFedExec(const DtFedExec& orig);
831  DtFedExec& operator=(DtFedExec const& orig);
832 
833 protected:
834  DtRtiExec* myRtiexec;
835  unsigned int myCrcOfFedFile;
836  int myFreeFedHandle;
837  std::vector<bool> myFedHandlesInUse;
838  bool myUseDestinationMetadata;
839  DtString myFedExName;
840  DtFederateHandleInfoMap myFederates;
841  DtFederateNameInfoMap myFederatesByName;
842  std::map< MAKRti::DtString, DtFederateHandle > myFederateHdlsByName;
843  int myNumFederates;
844  DtSyncHashlist mySyncList;
845  DtString myMomModule;
846  unsigned int myMomModuleCrc;
847  std::vector<unsigned int> myCreationFedFilesCRCs;
848  MAKRti::DtFomType myFedType;
849  std::vector<DtString> myFomModules;
850  // ! This will be a Map with the keys being a FOM module name, and the value being its CRC.
851  // ! This map is populated at create and join
852  std::map<DtString, unsigned int> myFomModulesNameToCrcMap;
853  std::set<DtString> myFomModulesSet;
854  std::vector<DtString> myCreateFomModules;
855  std::map<unsigned long, std::vector<DtString>* >myJoinFomModules;
856  DtFomClassMgr* myFom;
857 
858  int myFedExHandle;
859  DtFederateHandle myDesignatedFederate;
860  float myFederateTimeoutInterval;
861  DtResignAction myResignAction;
862 
863  bool myAllowResignActionOverride;
864 
866  std::map<DtFederateHandle, DtFedJoinInfo*> myJoiningFederates;
867  std::map<unsigned long, DtFedJoinInfo*> myJoiningFederatesByID;
868  // List of joining federates that have been processed but are waiting for confirm
869  std::set< unsigned long > myConnectionsJoinProcessed;
871  int myNumberResponseAttempts;
873  float myResponseInterval;
874 
875  bool mySave;
876  bool myRestore;
877  DtFederateHandleStdSet myPendingSaveFederates;
878  DtFederateHandleStdSet myInitiatedSaveFederates;
879  DtString mySaveLabel;
880  DtFederateHandle mySavingFederate;
881  DtFederateHandleStdSet myPendingRestoreFederates;
882  DtFederateHandleInfoMap myRestoreFederatesByOld;
883  DtFederateHandleInfoMap myRestoreFederatesByNew;
884  DtString mySavePath;
885  bool mySavePending;
886  bool mySaveBegun;
887  // When files are received from distributor, store them here until requester takes them.
888  std::map<DtString, DtFileInformation*> myTakenFiles;
889  // When FOMs are read, map FOM filename to fed target here.
890  std::map< const DtString, DtFomClassMgr > myFedexFileToFedTgtMap;
891  std::map<DtString, DtFedReadStatus> myFomToReadStatusMap;
892  // Maps source IDs to booleans, used to ensure that another FED request isn't sent by the same
893  // federate after the first successful request occurs
894  std::map<unsigned long, bool> myFedRequests;
895 
896  bool myAwaitingCreateUpload;
897  unsigned long myCreatorConnId;
898  std::set< unsigned long> myAwaitingJoinUpload;
899  bool myFullyCreated;
900 
901  int myTimeout;
902  int myDefaultWait;
903 
904  DtList myJoinCallbacks;
905  DtList myResignCallbacks;
906  DtList myDisconnectCallbacks;
907  DtList myReconnectSucceededCallbacks;
908  DtList myReconnectFailedCallbacks;
909  DtList myFedSynchronizedCallbacks;
910  DtList mySpAchievedCallbacks;
911  DtList mySpRegisterCallbacks;
912 
913  typedef std::set<std::string> DtFedExReservedNameSet;
914  typedef std::map< DtFederateHandle, DtFedExReservedNameSet >
915  DtFedExFederateReservedNameMap;
916  DtFedExReservedNameSet myReservedNames;
917  DtFedExFederateReservedNameMap myFederateReservedNames;
918 
919 #ifdef DtTIME
920  DtLogicalTimeFactory* myLogicalTimeFactory;
921  DtTimeInfoList myRegulatingFederates;
922  DtTimeInfoList myConstrainedFederates;
923  DtTimeInfoList myPendingConstrained;
924  DtTimeInfoList myPendingTar;
925  DtTimeInfoList myPendingRegulation;
926  DtTimeInfoList myNerLbtsList;
927  DtTimeInfoList myNerRequested;
928  DtTimeInfoList myPendingNerResponses;
929  bool myNewNerRequestPending;
930  bool myForceNerCycle;
931  bool myNerChange;
932  bool myTransmitLaggardLBTS;
933  DtList mySyncConstrained;
934  unsigned long myNerCycle;
935  DtFederateHandle myNerFederate;
936  DtFederateHandle myLagNerFederate;
937  DtList myTempTimePool;
938  DtRtiApiUniquePtrTime myPositiveInfinity;
939  DtRtiApiUniquePtrTime mySaveTime;
940  DtRtiApiUniquePtrTime myNerLbts;
941  DtRtiApiUniquePtrTime myLagNerLbts;
942 #endif
943 
944  vrlmod::DtThreadedObject* myDistributorThread;
945  DtAsyncFileDistributorRunnable* myDistributor;
946  static const std::vector<DtString> theEmptyStringSet;
947  bool myDistributeFedFile;
948  bool myCrcCheckFedFile;
949  unsigned long myInitiatorID;
950  int myStrictNameReservation;
952  bool myAllowNetworkTesting;
954  bool myNetworkTestingEnabled;
955  bool myModulesArrived;
956 
957  DtClock myClock;
958 
959  unsigned int myNumberFederatesAllowed;
960 
961 protected:
962 
963  static DtFedExecCreator theCreator;
964  //DtFedReaderFactory myFedReaderFactory;
965  DtFedReader13 * myFedReader13;
966  DtFedReader1516 * myFedReader1516;
967  DtFedReader1516e * myFedReader1516e;
968  DtFedReader1516_4 * myFedReader1516_2025;
969 
970 private:
971 
972  static const DtString nullStr;
973  static const DtFederateHandle theFederationShadowHandle;
974  bool myFullFedFileDistribution;
975 
976 };
977 
DtFedFileRequestMsgEvent
Definition: distributorThreadEvents.h:221
DtFedExec::myDefaultWait
int myDefaultWait
Definition: fedex.h:902
DtFedExec::myReconnectFailedCallbacks
DtList myReconnectFailedCallbacks
Definition: fedex.h:908
DtFedExec::myNumberFederatesAllowed
unsigned int myNumberFederatesAllowed
Definition: fedex.h:959
DtSyncPointQueryMsg
Definition: syncPointQueryMsg.h:31
DtFedExec::myCreationFedFilesCRCs
std::vector< unsigned int > myCreationFedFilesCRCs
Definition: fedex.h:847
DtFedExec::myFedReader13
DtFedReader13 * myFedReader13
Definition: fedex.h:965
DtFedExec::myConnectionsJoinProcessed
std::set< unsigned long > myConnectionsJoinProcessed
Definition: fedex.h:869
DtFedExecCreator
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)
DtFedExec creator prototype.
Definition: fedex.h:91
DtFedExec::myFedType
MAKRti::DtFomType myFedType
Definition: fedex.h:848
DtAliveMsg
Definition: aliveMsg.h:24
DtFedExec::myMomModuleCrc
unsigned int myMomModuleCrc
Definition: fedex.h:846
DtSaveFinishedResult
DtSaveFinishedResult
Definition: savFinMsg.h:21
DtFedExec::DtFedExReservedNameSet
std::set< std::string > DtFedExReservedNameSet
Definition: fedex.h:913
DtFedExec::myCrcOfFedFile
unsigned int myCrcOfFedFile
Definition: fedex.h:835
DtJoinConfirmMsg
Definition: joinConfMsg.h:24
DtFedExec::myRestoreFederatesByOld
DtFederateHandleInfoMap myRestoreFederatesByOld
Definition: fedex.h:882
DtFedExec::myAwaitingCreateUpload
bool myAwaitingCreateUpload
Definition: fedex.h:896
DtFedExec::myCreatorConnId
unsigned long myCreatorConnId
Definition: fedex.h:897
DtFedExec::myAllowNetworkTesting
bool myAllowNetworkTesting
Whether network testing is enabled or completely disabled by the RID.
Definition: fedex.h:952
DtRIDParameters
This class manages the RTI&#39;s start-up configuration using both MTL variables and functions.
Definition: RIDparams.h:87
DtLogicalTimeFactory
Definition: fedTimeFactory.h:73
DtSyncPt
Definition: syncPt.h:24
DtFedExec::myMomModule
DtString myMomModule
Definition: fedex.h:845
DtFedExec::myFomModulesNameToCrcMap
std::map< DtString, unsigned int > myFomModulesNameToCrcMap
Definition: fedex.h:852
DtFedExec::myModulesArrived
bool myModulesArrived
Definition: fedex.h:955
DtFedExec
Definition: fedex.h:117
DtJoinMsg
Definition: joinMsg.h:27
DtFedExec::myInitiatedSaveFederates
DtFederateHandleStdSet myInitiatedSaveFederates
Definition: fedex.h:878
DtFedExec::myInitiatorID
unsigned long myInitiatorID
Definition: fedex.h:949
DtOwnershipMsg
Definition: ownerMsg.h:45
DtFedExec::myDistributeFedFile
bool myDistributeFedFile
Definition: fedex.h:947
DtFedExec::myRestore
bool myRestore
Definition: fedex.h:876
DtFedExec::myNetworkTestingEnabled
bool myNetworkTestingEnabled
Whether network testing has been toggled on/off by the assistant.
Definition: fedex.h:954
DtFomModuleDistExecMsg
Definition: fomModuleDistExecMsg.h:26
DtFedExec::myResponseInterval
float myResponseInterval
to obtain response retransmission interval
Definition: fedex.h:873
DtSaveResponseFlag
DtSaveResponseFlag
Definition: savRespMsg.h:22
DtSyncHashlist
Definition: syncHashlist.h:21
DtFedExec::mySavePath
DtString mySavePath
Definition: fedex.h:884
DtFedExec::nullStr
static const DtString nullStr
Definition: fedex.h:972
DtSaveCompleteMsg
Definition: savCompMsg.h:22
DtFedExec::myDesignatedFederate
DtFederateHandle myDesignatedFederate
Definition: fedex.h:859
DtFedExec::mySavePending
bool mySavePending
Definition: fedex.h:885
DtHlaVersionId
DtHlaVersionId
Definition: rtiVersion.h:51
DtFederateHandleSet
Definition: fedHandleSet.h:61
DtFedExec::myFedExName
DtString myFedExName
Definition: fedex.h:839
DtFedExec::myFedHandlesInUse
std::vector< bool > myFedHandlesInUse
Definition: fedex.h:837
DtFedExec::myFomToReadStatusMap
std::map< DtString, DtFedReadStatus > myFomToReadStatusMap
Definition: fedex.h:891
DtFedExec::mySaveBegun
bool mySaveBegun
Definition: fedex.h:886
DtFedExec::myFederateTimeoutInterval
float myFederateTimeoutInterval
Definition: fedex.h:860
DtFedExec::theFederationShadowHandle
static const DtFederateHandle theFederationShadowHandle
Definition: fedex.h:973
DtFedExec::myClock
DtClock myClock
Definition: fedex.h:957
DtFedExec::myJoinFomModules
std::map< unsigned long, std::vector< DtString > * > myJoinFomModules
Definition: fedex.h:855
DtFedExec::DtFedExFederateReservedNameMap
std::map< DtFederateHandle, DtFedExReservedNameSet > DtFedExFederateReservedNameMap
Definition: fedex.h:915
DtFedExec::myFedSynchronizedCallbacks
DtList myFedSynchronizedCallbacks
Definition: fedex.h:909
DtFedExec::myAwaitingJoinUpload
std::set< unsigned long > myAwaitingJoinUpload
Definition: fedex.h:898
DtResignMsg
Definition: resignMsg.h:36
DtRtiApiTime
RTI_API::LogicalTime DtRtiApiTime
Typedefs for RTI API types that frequently require conditional precompile directives.
Definition: rtiApiTypes.h:91
DtFedExec::myFedReader1516_2025
DtFedReader1516_4 * myFedReader1516_2025
Definition: fedex.h:968
DtFedExec::myFederateHdlsByName
std::map< MAKRti::DtString, DtFederateHandle > myFederateHdlsByName
Definition: fedex.h:842
DtResignDirectiveMsg
Definition: resignDirectiveMsg.h:24
DtFedExec::myDistributor
DtAsyncFileDistributorRunnable * myDistributor
Definition: fedex.h:945
DtFedExec::myCrcCheckFedFile
bool myCrcCheckFedFile
Definition: fedex.h:948
DtFedExec::myFedRequests
std::map< unsigned long, bool > myFedRequests
Definition: fedex.h:894
DtFedExec::myTimeout
int myTimeout
Definition: fedex.h:901
DtFedExec::myFederatesByName
DtFederateNameInfoMap myFederatesByName
Definition: fedex.h:841
DtFedExec::myCreateFomModules
std::vector< DtString > myCreateFomModules
Definition: fedex.h:854
DtFedExec::myFomModules
std::vector< DtString > myFomModules
Definition: fedex.h:849
DtFomModuleRequestMsg
Sent by Federates to request fed file from RtiExec.
Definition: fomModuleRequestMsg.h:24
DtJoinResponseMsg::errorCodes
errorCodes
error codes for the errorValue flag
Definition: joinRespMsg.h:32
DtRestoreRequestMsg
Definition: resReqMsg.h:23
DtReserveNameMsg
Definition: reserveNameMsg.h:25
DtFederate
Definition: federate.h:39
DtFedExec::myFom
DtFomClassMgr * myFom
Definition: fedex.h:856
DtFedExec::myReconnectSucceededCallbacks
DtList myReconnectSucceededCallbacks
Definition: fedex.h:907
DtFomToReadStatusPair
std::pair< DtString, DtFedReadStatus > DtFomToReadStatusPair
Definition: fedex.h:115
DtFedExec::myFomModulesSet
std::set< DtString > myFomModulesSet
Definition: fedex.h:853
DtFedExec::myFedReader1516
DtFedReader1516 * myFedReader1516
Definition: fedex.h:966
DtRtiMsg::fedExName
virtual const MAKRti::DtString fedExName() const
These two functions should be avoided in favor of isForExec().
DtFedExec::myFedReader1516e
DtFedReader1516e * myFedReader1516e
Definition: fedex.h:967
DtFedExec::myUseDestinationMetadata
bool myUseDestinationMetadata
Definition: fedex.h:838
DtFedExec::theCreator
static DtFedExecCreator theCreator
Definition: fedex.h:963
DtFedExec::myFedexFileToFedTgtMap
std::map< const DtString, DtFomClassMgr > myFedexFileToFedTgtMap
Definition: fedex.h:890
DtFederateHandleCbFn
void(* DtFederateHandleCbFn)(DtFederateHandle handle, void *usr)
Callback prototype about unknown federates (e.g., reconnect failed)
Definition: fedex.h:99
DtRestoreCompleteMsg
Definition: resComMsg.h:22
DtFedExec::myRestoreFederatesByNew
DtFederateHandleInfoMap myRestoreFederatesByNew
Definition: fedex.h:883
DtConnectionMgr
Instances of DtConnectionMgr manage the communication objects that the RTI will use to either communi...
Definition: connectMgr.h:67
DtFederateHandle
DtHandle DtFederateHandle
Definition: internalTypes.h:46
DtAbortSaveMsg
Definition: saveAbortMsg.h:22
DtSyncPointMsg
Definition: syncPointMsg.h:46
DtRidFileTester
Compares a rid file.
Definition: ridFileTester.h:25
DtFedExec::myJoiningFederatesByID
std::map< unsigned long, DtFedJoinInfo * > myJoiningFederatesByID
Definition: fedex.h:867
DtTransferRidParamsMsg
Sent by Federates to request testing of the RID file from RtiExec.
Definition: transferRidParamsMsg.h:30
DtRequestedModulesArrivedEvent
Definition: distributorThreadEvents.h:205
DtAbortRestoreMsg
Definition: restoreAbortMsg.h:22
DtFedExec::myFullFedFileDistribution
bool myFullFedFileDistribution
Definition: fedex.h:974
DtReleaseMultiNameMsg
Definition: releaseMultiNameMsg.h:25
DtCreateResponseFlag
DtCreateResponseFlag
Definition: creRespMsg.h:23
DtFedExec::mySpRegisterCallbacks
DtList mySpRegisterCallbacks
Definition: fedex.h:911
DtEndRestoreResult
DtEndRestoreResult
Definition: resEndMsg.h:21
DtFomClassMgr
Definition: fomMgr.h:49
DtFedExec::myPendingSaveFederates
DtFederateHandleStdSet myPendingSaveFederates
Definition: fedex.h:877
DtFedExec::myDisconnectCallbacks
DtList myDisconnectCallbacks
Definition: fedex.h:906
DtFedExec::myAllowResignActionOverride
bool myAllowResignActionOverride
Definition: fedex.h:863
DtRtiExec
Definition: exec.h:148
DtFedExec::myFedExHandle
int myFedExHandle
Definition: fedex.h:858
DtRtiApiUniquePtrTime
DtRtiApiUniquePtr< DtRtiApiTime > DtRtiApiUniquePtrTime
Definition: rtiApiTypes.h:96
DtFedExec::myResignAction
DtResignAction myResignAction
Definition: fedex.h:861
DtFedExec::myNumberResponseAttempts
int myNumberResponseAttempts
Response interval from params is divided by this number.
Definition: fedex.h:871
DtFomModuleDistributionMsg
Definition: fomModuleDistributionMsg.h:25
DtFedExec::myFreeFedHandle
int myFreeFedHandle
Definition: fedex.h:836
DtSaveTimeAdvanceMsg
Definition: savTimeAdvMsg.h:21
DtQueryRestoreStatusMsg
Definition: queryRestoreStatusMsg.h:22
DtFederateCbFn
void(* DtFederateCbFn)(DtFederate *federate, void *usr)
Callback prototype about known federates (e.g., joined/resigned/reconnect/disconnect) ...
Definition: fedex.h:96
DtReserveMultiNameMsg
Definition: reserveMultiNameMsg.h:25
DtFedExec::mySyncList
DtSyncHashlist mySyncList
Definition: fedex.h:844
DtSaveBegunMsg
Definition: savBegMsg.h:22
DtAsyncFileDistributorRunnable
Distributes fomModule files from initiating federate to RtiExec and then from RtiExec to all joining ...
Definition: asynchronousFileDistributor.h:33
DtFedExec::mySavingFederate
DtFederateHandle mySavingFederate
Definition: fedex.h:880
DtInitiatedSaveMsg
Definition: initiatedSaveMsg.h:21
DtFedExec::myRtiexec
DtRtiExec * myRtiexec
Definition: fedex.h:834
DtSaveRequestMsg
Definition: savReqMsg.h:23
DtFedExec::myTakenFiles
std::map< DtString, DtFileInformation * > myTakenFiles
Definition: fedex.h:888
DtFedExec::myFederateReservedNames
DtFedExFederateReservedNameMap myFederateReservedNames
Definition: fedex.h:917
DtRestoreBegunMsg
Definition: resBegMsg.h:28
DtFedExec::myPendingRestoreFederates
DtFederateHandleStdSet myPendingRestoreFederates
Definition: fedex.h:881
DtFederateNameInfoMap
std::map< DtString, DtFederate * > DtFederateNameInfoMap
Federate name -&gt; Federate info map.
Definition: fedex.h:111
DtFedExec::myFullyCreated
bool myFullyCreated
Definition: fedex.h:899
DtFedExTakeFileEvent
Definition: distributorThreadEvents.h:238
DtRtiApiFederateRestoreStatusVector
RTI_API::FederateRestoreStatusVector DtRtiApiFederateRestoreStatusVector
Definition: rtiApiTypes.h:108
rti1516_2025::FederateHandleSaveStatusPairVector
std::vector< FederateHandleSaveStatusPair > FederateHandleSaveStatusPairVector
Definition: Typedefs.h:60
DtFedExec::myResignCallbacks
DtList myResignCallbacks
Definition: fedex.h:905
DtFedExec::mySaveLabel
DtString mySaveLabel
Definition: fedex.h:879
DtFileToFedTgtPair
std::pair< const DtString, DtFomClassMgr > DtFileToFedTgtPair
Definition: fedex.h:113
DtJoinResponseMsg::DT_NO_ERROR
Definition: joinRespMsg.h:33
DtFedExec::myJoinCallbacks
DtList myJoinCallbacks
Definition: fedex.h:904
DtRtiApiTimeInterval
RTI_API::LogicalTimeInterval DtRtiApiTimeInterval
Definition: rtiApiTypes.h:92
DtSyncPointStatus
DtSyncPointStatus
Definition: syncPointMsg.h:36
vlThreadedObject.h
Defines a ThreadedObject which can run a DtRunnable object in a thread.
DtFedExec::myFederates
DtFederateHandleInfoMap myFederates
Definition: fedex.h:840
DtFedExec::myReservedNames
DtFedExReservedNameSet myReservedNames
Definition: fedex.h:916
DtSyncPointCbFn
void(* DtSyncPointCbFn)(DtSyncPt *pt, void *usr)
Synchronization point registered/synchronized callback prototype.
Definition: fedex.h:102
DtSyncMsgType
DtSyncMsgType
Definition: syncPointMsg.h:25
DtFedExec::myStrictNameReservation
int myStrictNameReservation
Definition: fedex.h:950
DtSyncPointAchievedCbFn
void(* DtSyncPointAchievedCbFn)(DtFederate *who, DtSyncPt *pt, void *usr)
Synchronization point achieved callback prototype.
Definition: fedex.h:105
DtQuerySaveStatusMsg
Definition: querySaveStatusMsg.h:22
DtRtiAssistantExecClient
The client connection to the RTI Assistant for the rtiexec.
Definition: rtiAssistantExecClient.h:23
DtFedExec::theEmptyStringSet
static const std::vector< DtString > theEmptyStringSet
Definition: fedex.h:946
DtFederateHandleStdSet
std::set< DtFederateHandle > DtFederateHandleStdSet
Definition: internalTypes.h:47
DtReportFederationMembersMsg::DtFederateList
std::vector< DtFederateNameTypePair > DtFederateList
Definition: reportFederationMembersMsg.h:24
DtFedExec::myNumFederates
int myNumFederates
Definition: fedex.h:843
DtResignReason
DtResignReason
Definition: resignMsg.h:26
DT_DLL_EXEC
#define DT_DLL_EXEC
Definition: rtiMsConfig.h:152
DtRtiMsg::fedExHandle
virtual int fedExHandle() const
Get the federation execution identifier as a handle Returns 0 if the identifier is being represented ...
DtFedExec::myDistributorThread
vrlmod::DtThreadedObject * myDistributorThread
DtTIME.
Definition: fedex.h:944
DtResignResponse
DtResignResponse
Definition: resignRespMsg.h:12
DtFedExec::mySpAchievedCallbacks
DtList mySpAchievedCallbacks
Definition: fedex.h:910
DtFederateHandleInfoMap
std::map< DtFederateHandle, DtFederate * > DtFederateHandleInfoMap
Federate handle -&gt; Federate info map.
Definition: fedex.h:108
DtFedExec::myJoiningFederates
std::map< DtFederateHandle, DtFedJoinInfo * > myJoiningFederates
List of joining federates waiting to be processed and confirmed.
Definition: fedex.h:866
DtFedExec::mySave
bool mySave
Definition: fedex.h:875
vrlmod::DtThreadedObject
Definition: vlThreadedObject.h:45
Document ID: Generated on Wed Jul 8 16:20:32 EDT 2026 from SVN revision 291616
Copyright © 2005-2025 MAK Technologies Inc. All Rights Reserved (www.mak.com)