MAK RTIspy API Documentation for HLA 1516
 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 (*DtFederateCbFn)(DtFederate* 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,
191  unsigned long newConnId, unsigned long& oldConnId);
192 
194  virtual void reconnectFederateSucceeded( DtFederate* fed );
195 
197  virtual void reconnectFederateFailed( DtFederate* fed );
198 
200  virtual bool resignFederate(DtFederateHandle handle,
201  DtResignAction action, DtResignReason reason );
202 
209  virtual void resetClockForHeartBeat();
210 
212  virtual bool tick();
213 
215  virtual void printFederates();
216 
218  virtual void addFederateJoinedCallback(DtFederateCbFn fn, void* usr);
219 
221  virtual void removeFederateJoinedCallback(DtFederateCbFn fn, void* usr);
222 
224  virtual void addFederateResignedCallback(DtFederateCbFn fn, void* usr);
225 
227  virtual void removeFederateResignedCallback(DtFederateCbFn fn, void* usr);
228 
231  virtual void addSyncPtRegisteredCallback(DtSyncPointCbFn fn, void* usr);
232 
235  virtual void removeSyncPtRegisteredCallback(DtSyncPointCbFn fn, void* usr);
236 
239  virtual void addSyncPtAchievedCallback(DtSyncPointAchievedCbFn fn, void* usr);
240 
243  virtual void removeSyncPtAchievedCallback(DtSyncPointAchievedCbFn fn, void* usr);
244 
247  virtual void addFederationSynchronizedCallback(DtSyncPointCbFn fn, void* usr);
248 
251  virtual void removeFederationSynchronizedCallback(DtSyncPointCbFn fn, void* usr);
252 
254  virtual void addFederateDisconnectedCallback(DtFederateCbFn fn, void* usr );
255 
257  virtual void removeFederateDisconnectedCallback(DtFederateCbFn fn, void* usr );
258 
259  //Register callbacks for federate reconnect.
260  virtual void addFederateReconnectSucceededCallback(DtFederateCbFn fn, void* usr );
261 
262  //Unregister callbacks for federate reconnect.
263  virtual void removeFederateReconnectSucceededCallback(DtFederateCbFn fn, void* usr );
264 
265  //Register callbacks for federate reconnect.
266  virtual void addFederateReconnectFailedCallback(DtFederateCbFn fn, void* usr );
267 
268  // Unregister callbacks for federate reconnect.
269  virtual void removeFederateReconnectFailedCallback(DtFederateCbFn fn, void* usr );
270 
272  void multFileReceivedCb(const DtFomModuleDistributionMsg& msg);
273 
275  void multFileRequestedCb(const DtFomModuleRequestMsg& msg);
276 
278  void pushFomModuleToJoinedFederates(DtFederate* newFederate,
279  DtString fileName,
280  unsigned int fileSize,
281  const char* fileBuffer );
282 
284  void pushFomModuleToSingleFederate(DtFederateHandle recipient,
285  DtString fileName,
286  unsigned int fileSize,
287  const char* fileBuffer );
288 
290  virtual void processRequestedModulesArrived( const DtRequestedModulesArrivedEvent& e );
291 
293  virtual void processFedFileRequestMsg( const DtFedFileRequestMsgEvent& e);
294 
296  virtual void processFileTransfer(const DtFedExTakeFileEvent& e);
297 
299  virtual DtFederateHandleInfoMap const& federates() const;
300 
302  virtual void getFederateList(DtReportFederationMembersMsg::DtFederateList& federates) const;
303 
304 #ifdef DtTIME
305  virtual const DtTimeInfoList* regulatingFederates() const;
307 
309  virtual const DtTimeInfoList* constrainedFederates() const;
310 #endif
311 
313  virtual void disableNetworkTesting();
314 
316  virtual void enableNetworkTesting();
317 
319  virtual void changeLatencyTestMode( DtFederateHandle handle, bool runTest,
320  bool continuous, bool haltContinuous, bool observing,
321  unsigned int interactionPeriod, unsigned int numInteractions,
322  unsigned int payloadBytes );
323 
325  virtual bool transferRidParams(DtFederateHandle handle, const DtString& ridString);
326 
327 public:
328 
331 
332  static void processJoinMsg(const DtJoinMsg& msg, void* usr);
333  static void processJoinConfirm(const DtJoinConfirmMsg& msg, void* usr);
334  static void processAlive(const DtAliveMsg& msg,void* usr);
335  static void processResign(const DtResignMsg& msg, void* usr);
336  static void processResignDirective(const DtResignDirectiveMsg& msg, void* usr);
337  static void processSyncPoint(const DtSyncPointMsg& msg, void* usr);
338  static void processSyncPointQuery(const DtSyncPointQueryMsg& msg, void* usr);
339  static void processSaveRequest(const DtSaveRequestMsg& msg, void* usr);
340  static void processInitiatedSave(const DtInitiatedSaveMsg& msg, void* usr);
341  static void processSaveComplete(const DtSaveCompleteMsg& msg, void* usr);
342  static void processSaveBegun(const DtSaveBegunMsg& msg, void* usr);
343  static void processAbortSave(const DtAbortSaveMsg& msg, void* usr);
344  static void processRestoreRequest(const DtRestoreRequestMsg& msg, void* usr);
345  static void processRestoreBegun(const DtRestoreBegunMsg& msg, void* usr);
346  static void processRestoreComplete(const DtRestoreCompleteMsg& msg, void* usr);
347  static void processAbortRestore(const DtAbortRestoreMsg& msg, void* usr);
348  static void processOwnership(const DtOwnershipMsg& msg, void* usr);
349  static void processReserveName(DtReserveNameMsg const& msg, void* usr);
350  static void processReserveMultiName(DtReserveMultiNameMsg const& msg, void* usr);
351  static void processReleaseMultiName(DtReleaseMultiNameMsg const& msg, void* usr);
352  static void processQuerySaveStatus(DtQuerySaveStatusMsg const& msg, void* usr);
353  static void processQueryRestoreStatus(DtQueryRestoreStatusMsg const& msg, void* usr);
354 #ifdef DtTIME
355  static void processSaveTimeAdvance(const DtSaveTimeAdvanceMsg& msg, void* usr);
356  static void processSaveRequestTso(const DtSaveRequestTsoMsg& msg, void* usr);
357  static void processEnableRegulation(const DtEnableRegulationMsg& msg, void* usr);
358  static void processEnableConstrained(const DtEnableConstrainedMsg& msg, void* usr);
359  static void processTimeAdvanceRequest(const DtTimeAdvanceRequestMsg& msg, void* usr);
360  static void processDisable(const DtDisableMsg& msg, void* usr);
361  static void processConstrainedSync(const DtConstrainedSyncMsg& msg, void* usr);
362  static void processNextEventRequest(const DtNextEventRequestMsg& msg, void* usr);
363 #endif
364 
365 
367  static void multFileReceivedExecCb(const DtFomModuleDistExecMsg& msg, void* usr);
368 
370  static void multFileReceivedCb( const DtFomModuleDistributionMsg& msg, void* usr );
371 
373  static void multFileRequestedCb( const DtFomModuleRequestMsg& msg, void* usr );
374 
376  static DtFedExec* create(DtRtiExec* rtiexec, const std::vector<unsigned int> & crcs, DtString const & fedExName,
377  std::string const & timeImplName, MAKRti::DtFomType fedType, DtString const& momModuleName,
378  const std::vector<DtString>& fomModules, int fedExHandle, DtRIDParameters* params, unsigned int momModuleCrc);
379 
383  static void setCreatorFunction(DtFedExecCreator creator);
384 
385  static void init( DtRtiAssistantExecClient* assistant );
386 
387 protected:
388 
390  virtual const std::map< unsigned long, std::vector<DtString>*>& joinFomModules() const;
391 
392  virtual std::vector<DtString>& joinFomModulesForConnection(unsigned long connID) const;
393 
395  virtual const std::vector<DtString>& createFomModules() const;
396 
399 
400  virtual void processJoinMsg(const DtJoinMsg& msg);
401  virtual bool handleJoinFailureCases( const DtJoinMsg &msg );
402  virtual void requestFedFileUpload( const DtJoinMsg& msg );
403 
404  virtual void processJoinConfirm(const DtJoinConfirmMsg& msg);
405  virtual void processAlive(const DtAliveMsg& msg);
406  virtual void processResign(const DtResignMsg& msg);
407  virtual void processResignDirective(const DtResignDirectiveMsg& msg);
408  virtual void processSyncPoint(const DtSyncPointMsg& msg);
409  virtual void processSyncPointQuery(const DtSyncPointQueryMsg& msg);
410  virtual void processSaveRequest(const DtSaveRequestMsg& msg);
411  virtual void processInitiatedSave(const DtInitiatedSaveMsg& msg);
412  virtual void processSaveComplete(const DtSaveCompleteMsg& msg);
413  virtual void processSaveBegun(const DtSaveBegunMsg& msg);
414  virtual void processAbortSave(const DtAbortSaveMsg& msg);
415  virtual void processRestoreRequest(const DtRestoreRequestMsg& msg);
416  virtual void processRestoreBegun(const DtRestoreBegunMsg& msg);
417  virtual void processRestoreComplete(const DtRestoreCompleteMsg& msg);
418  virtual void processAbortRestore(const DtAbortRestoreMsg& msg);
419  virtual void processOwnership(const DtOwnershipMsg& msg);
420  virtual void processReserveName(DtReserveNameMsg const& msg);
421  virtual void processReserveMultiName(DtReserveMultiNameMsg const& msg);
422  virtual void processReleaseMultiName(DtReleaseMultiNameMsg const& msg);
423  virtual void processQuerySaveStatus(DtQuerySaveStatusMsg const& msg);
424  virtual void processQueryRestoreStatus(DtQueryRestoreStatusMsg const& msg);
425 
426 #ifdef DtTIME
427  virtual void processEnableRegulation(const DtEnableRegulationMsg& msg);
428  virtual void processEnableConstrained(const DtEnableConstrainedMsg& msg);
429  virtual void processTimeAdvanceRequest(const DtTimeAdvanceRequestMsg& msg);
430  virtual void processDisable(const DtDisableMsg& msg);
431  virtual void processConstrainedSync( const DtConstrainedSyncMsg& msg);
432  virtual void processSaveRequestTso(const DtSaveRequestTsoMsg& msg);
433  virtual void processSaveTimeAdvance(const DtSaveTimeAdvanceMsg& msg);
434  virtual void processNextEventRequest(const DtNextEventRequestMsg& msg);
435 #endif
436 
438 
440  virtual void processRegisterSyncPoint(const DtSyncPointMsg& msg);
441 
443  virtual void processAchievedSyncPoint(const DtSyncPointMsg& msg);
444 
446  virtual void createSyncPoint(const DtSyncPointMsg& msg);
447 
449  virtual void processSyncPtAchievedCallbacks(DtSyncPt* point,
450  DtFederate* federate);
451 
453  virtual void processFederationSynchronizedCallbacks(DtSyncPt* point);
454 
458  virtual bool synchronized(DtSyncPt* point,
459  DtFederateHandleSet& unsuccessfulSet) const;
460 
462  virtual void sendSyncPointReport(const DtSyncPointQueryMsg& msg);
463 
465  virtual void sendSyncPointStatusReport(const DtSyncPointQueryMsg& msg);
466 
468  virtual DtFederate* addFederate(
469  const char* federateType, const char* federateName, DtFederateHandle handle,
470  unsigned long connHandle, int astntCompId, const char* fedHostName,
471  MAKRti::DtInetAddr host, DtHlaVersionId hlaVersion);
472 
475  virtual DtFederate* createFederate(
476  const char* federateType, const char* federateName,
477  DtFederateHandle handle, unsigned long connHandle, int astntCompId,
478  const char* fedHostname, MAKRti::DtInetAddr host,
479  DtHlaVersionId hlaVersion);
480 
482  virtual bool isMember(DtFederateHandle handle) const;
483 
486  virtual bool deleteFederate(DtFederateHandle handle);
487 
489 
491  virtual DtFedReadStatus readCreateFom(DtFomClassMgr* target, const DtString& fomFile,
492  bool addToMap, DtCreateResponseFlag& response, DtString& errorResponseString);
493 
497  virtual DtFedReadStatus readCreateFoms(DtFomClassMgr* topLevelTarget, std::vector<DtString>& fomFiles,
498  DtCreateResponseFlag& response, DtString& errorResponseString);
499 
501  virtual DtFedReadStatus readJoinFom(DtFomClassMgr* target, const DtString& fomFile,
502  DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);
503 
506  virtual DtFedReadStatus readJoinFoms(std::vector<DtString>& fomFiles,
507  DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);
508 
510  virtual bool processCreateReady();
511 
514  virtual bool processJoin(unsigned long connID, const DtFedJoinInfo* fedInfo);
515 
518  virtual void processJoinReady();
519 
521  virtual void destroyDistributor();
522 
524  virtual DtAsyncFileDistributorRunnable* distributor() const;
525 
531  virtual unsigned int numberFederatesAllowed(unsigned int numPartners) const;
532 
534  virtual void resetControl();
535 
537  virtual bool tickDistributor();
538 
540  virtual bool processEvents();
541 
543  virtual bool areJoinFomModulesUploadedAndReady(unsigned long federateId);
544 
546  virtual DtCreateResponseFlag handleCreateResponse(DtFedReadStatus status, const DtFedReader* fedReader,
547  const DtString filename, DtString& errorResponse) const;
548 
550  virtual DtJoinResponseMsg::errorCodes handleJoinResponse(DtFedReadStatus status, const DtFedReader* fedReader,
551  const DtString filename, DtString& errorResponse) const;
552 
553 protected:
554 
555 
556  DtFedReader * getReader(DtFomType theFomType);
557  DtFedReader * getReader( DtFomType theFomType, DtFomClassMgr* target);
558 
559  void populateWithUnknownFoms(std::vector<DtString> & mods, std::vector<DtString> & requestedMods);
560  bool isFomAvailable(const DtString & fomName);
561  bool doesCrcMatchKnownFomModuleCrc( const DtString & fomName, unsigned int myTakenFomCrc );
562 
564  virtual bool fedFileReady(const MAKRti::DtString& fileName) const;
565 
567  virtual bool fedFilesReady( const std::vector<MAKRti::DtString>& fileNames ) const;
568 
570  virtual bool addJoinFomModuleForConnection( unsigned long connId,
571  const std::vector<MAKRti::DtString>& modulesFromJoinRequest );
572 
574  virtual void removeJoinFomModuleForConnection( unsigned long connID );
575 
577  virtual void updateNewClassesToJoinedFederates(DtFomClassMgr* target, DtFederateHandle joiningFederate);
578 
580  virtual void handleBadJoin(unsigned long connID, const DtFedJoinInfo* joinInfo, std::vector<DtString>& joinModules,
581  DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);
582 
584  virtual void readAndMergeJoiningFomModules(unsigned long connID, DtFomClassMgr* target,
585  DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString);
586 
588 
590  virtual void tickSaveRestore();
591 
594  virtual void tickJoin();
595 
598  virtual void tickFederates();
599 
602 
603  virtual void sendSyncPointMsg(
604  DtSyncMsgType kind, int id,
605  DtSyncPointStatus status,
606  const char* name,
607  RTI_API::VariableLengthData const* theTag = NULL,
608  const DtFederateHandleSet* set = NULL,
609  const DtFederateHandleSet* unsuccessfulSet = NULL);
610 
611  virtual void sendResignMsg(
612  const char* name, DtFederateHandle fedHandle,
613  DtResignAction action, DtResignReason reason,
614  const DtTimeInfo* timeInfo );
615  virtual void sendEnableDisableNetworkTestingMsg(
616  const char* name, bool enabled );
617  virtual void sendTransferRidParamsMsg(
618  const char* name, DtFederateHandle fedHandle, const DtString& paramString);
619  virtual void sendJoinResponseMsg(unsigned long destinationIDValue,
620  unsigned short requestID, unsigned int crcOfFedFile, DtFederateHandle handle,
621  const char* federateName, int fedExHandle, const char* fedExName,
622  const DtString& momModule, const std::vector<MAKRti::DtString>& modules,
623  unsigned long flags, bool allowNetworkTesting, bool enableNetworkTesting,
624  DtHlaVersionId hlaVers,
625  DtJoinResponseMsg::errorCodes errorValue = DtJoinResponseMsg::DT_NO_ERROR,
626  const DtString& errorString = DtString::nullString());
627  virtual void sendResignResponseMsgIfNecessary( const DtResignMsg& msg, DtResignResponse response, DtFederateHandle fedHandle );
628  virtual void sendSaveInitiateMsg(const char* labelVal);
629  virtual void sendSaveInitiateConstrainedMsg(const char* labelVal);
630  virtual void sendSaveResponse(DtFederateHandle fedHandle,
631  unsigned long requestID, const char* labelVal,
632  DtSaveResponseFlag response);
633  virtual void sendDesignatedFederate(DtFederateHandle fedHandle);
634  virtual void sendNameReservedMsg(DtFederateHandle requestingFederate,
635  char const* objectName, bool result);
636  virtual void sendMultiNameReservedMsg( DtFederateHandle requestingFederate,
637  std::set< std::wstring > const & objectNames,
638  bool result );
639 
640  virtual void sendRestoreStatus(DtFederateHandle requestingFederate,
641  DtRtiApiFederateRestoreStatusVector const & restoreStatusList);
642 
643  virtual void sendSaveStatus(DtFederateHandle requestingFederate,
644  RTI_API::FederateHandleSaveStatusPairVector const & saveStatusList);
645 
646 #ifdef DtTIME
647  virtual void sendRegulationEnabledMsg(
648  DtFederateHandle handle,
649  DtRtiApiTime const & time);
650  virtual void sendConstrainedEnabledMsg(
651  DtFederateHandle handle,
652  DtRtiApiTime const & time,
653  DtRtiApiTime const & lbts);
654  virtual void sendLbtsMsg(DtFederateHandle laggardFederate,
655  DtRtiApiTime const & lbtsVal,
656  DtRtiApiTime const & lagLbtsVal);
657  virtual void sendNerLbtsMsg(
658  unsigned long nerCycle, DtFederateHandle laggardFederate,
659  bool nerPending, bool lagNerPending,
660  DtRtiApiTime const & lbtsVal,
661  DtRtiApiTime const & lagLbtsVal);
662  virtual void sendSyncConstrainedMsg();
663  virtual void sendResumeConstrainedMsg(DtFederateHandle laggardFederate,
664  DtRtiApiTime const & lbtsVal,
665  DtRtiApiTime const & lagLbtsVal);
666  virtual void sendSaveTimeMsg(char const* label,
667  DtRtiApiTime const & saveTime);
668 #endif
669 
670 
671  virtual void retireSyncPoint(const char* name);
674 
677  virtual void announceAllSyncPoints(DtFederateHandle hand);
678 
680  virtual void checkTimedSave();
681 
683  virtual void initiateSave(const char* label);
684 
687  virtual bool save( const char* label );
688 
691  virtual int initializeRestore( const char* label );
692 
695  virtual bool restore( const char* label );
696 
698  virtual void endSave(DtSaveFinishedResult result);
699 
701  virtual void endRestore(DtEndRestoreResult restoreResult);
702 
705  virtual DtString& getSaveFileName(const char* label, MAKRti::DtString& fileName,
706  bool extendName=true);
707 
710  virtual DtString& getRestoreFileName(const char* label, MAKRti::DtString& fileName);
711 
712 #ifdef DtTIME
713  virtual void resignFederateTime(DtFederateHandle federateHandle);
715 
717  void disableFederateTimeRegulation(DtFederateHandle federateHandle);
718 
720  void removeRegulatingEntry(DtTimeInfo* entry);
721 
723  virtual void checkPendingConstrained(DtRtiApiTime const & lbts);
724 
726  virtual void checkPendingConstrained(DtTimeInfo* entry,
727  DtRtiApiTime const & lbts);
728 
731  virtual bool becomeConstrained(DtTimeInfo* entry);
732 
735  void adjustRegulatingEntry(DtTimeInfo* entry,
736  DtRtiApiTime const & time,
737  DtRtiApiTimeInterval const & lookahead,
738  bool isTimeAvailable);
739 
741  void checkNerCycle(DtFederateHandle fedHandle);
742 
744  virtual void processEnableRegulation(DtFederateHandle federateHandle,
745  DtRtiApiTime const & time,
746  DtRtiApiTimeInterval const & lookahead);
747 
750  virtual void processPendingRegulation(DtFederateHandle federateHandle,
751  DtRtiApiTime const & time,
752  DtRtiApiTimeInterval const & lookahead);
753 
755  virtual DtRtiApiTime& getTempTime();
761  virtual void putTempTime(DtRtiApiTime& timePtr);
763  virtual void destroyTempTimePool();
765 
767  virtual DtFederateHandle minLbtsFederate() const;
768 
770  virtual DtRtiApiTime const & minLbts() const;
771 
773  virtual DtRtiApiTime const & lagLbts() const;
774 
777  virtual bool minTimeAvailable() const;
778 
781  virtual bool lagTimeAvailable() const;
782 
784  virtual DtFederateHandle minNerLbtsFederate() const;
785 
787  virtual DtRtiApiTime const & minNerLbts() const;
788 
790  virtual DtFederateHandle lagNerLbtsFederate() const;
791 
793  virtual DtRtiApiTime const & lagNerLbts() const;
794 
796  virtual bool minNerPending() const;
797 
799  virtual bool lagNerPending() const;
800 
802  virtual void setSaveTime(DtRtiApiTime const & timeVal);
803 
805  virtual DtRtiApiTime const & saveTime() const;
806 
808  virtual unsigned int federateHandleSlot(DtFederateHandle handle) const;
809 
811  virtual bool isFederateHandleSlotInUse(DtFederateHandle handle) const;
812 
814  virtual void setFederateHandleSlotInUse(DtFederateHandle handle, bool isInUse);
815 
816 #endif
817 
819  virtual bool authorizeFederateOperation(const DtJoinMsg& msg, DtString& errorMessage);
820 
821 
824  virtual int getNextFreeFedHandle();
825 
826 
828  DtFedExec();
829 
831  DtFedExec(const DtFedExec& orig);
832  DtFedExec& operator=(DtFedExec const& orig);
833 
834 protected:
835  DtRtiExec* myRtiexec;
836  unsigned int myCrcOfFedFile;
837  int myFreeFedHandle;
838  std::vector<bool> myFedHandlesInUse;
839  bool myUseDestinationMetadata;
840  DtString myFedExName;
841  DtFederateHandleInfoMap myFederates;
842  DtFederateNameInfoMap myFederatesByName;
843  std::map< MAKRti::DtString, DtFederateHandle > myFederateHdlsByName;
844  int myNumFederates;
845  DtSyncHashlist mySyncList;
846  DtString myMomModule;
847  unsigned int myMomModuleCrc;
848  std::vector<unsigned int> myCreationFedFilesCRCs;
849  MAKRti::DtFomType myFedType;
850  std::vector<DtString> myFomModules;
851  // ! This will be a Map with the keys being a FOM module name, and the value being its CRC.
852  // ! This map is populated at create and join
853  std::map<DtString, unsigned int> myFomModulesNameToCrcMap;
854  std::set<DtString> myFomModulesSet;
855  std::vector<DtString> myCreateFomModules;
856  std::map<unsigned long, std::vector<DtString>* >myJoinFomModules;
857  DtFomClassMgr* myFom;
858 
859  int myFedExHandle;
860  DtFederateHandle myDesignatedFederate;
861  float myFederateTimeoutInterval;
862  DtResignAction myResignAction;
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  bool myFullFedFileDistribution;
974 
975 };
976 
rti1516::FederateHandleSaveStatusPairVector
std::vector< FederateHandleSaveStatusPair > FederateHandleSaveStatusPairVector
Definition: Typedefs.h:57
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:848
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:849
DtAliveMsg
Definition: aliveMsg.h:24
DtFedExec::myMomModuleCrc
unsigned int myMomModuleCrc
Definition: fedex.h:847
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:836
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:846
DtFedExec::myFomModulesNameToCrcMap
std::map< DtString, unsigned int > myFomModulesNameToCrcMap
Definition: fedex.h:853
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:860
DtFedExec::mySavePending
bool mySavePending
Definition: fedex.h:885
DtHlaVersionId
DtHlaVersionId
Definition: rtiVersion.h:50
DtFederateHandleSet
Definition: fedHandleSet.h:61
DtFedExec::myFedExName
DtString myFedExName
Definition: fedex.h:840
DtFedExec::myFedHandlesInUse
std::vector< bool > myFedHandlesInUse
Definition: fedex.h:838
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:861
DtFedExec::myClock
DtClock myClock
Definition: fedex.h:957
DtFedExec::myJoinFomModules
std::map< unsigned long, std::vector< DtString > * > myJoinFomModules
Definition: fedex.h:856
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:843
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:842
DtFedExec::myCreateFomModules
std::vector< DtString > myCreateFomModules
Definition: fedex.h:855
DtFedExec::myFomModules
std::vector< DtString > myFomModules
Definition: fedex.h:850
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:857
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:854
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:839
DtFedExec::theCreator
static DtFedExecCreator theCreator
Definition: fedex.h:963
DtFedExec::myFedexFileToFedTgtMap
std::map< const DtString, DtFomClassMgr > myFedexFileToFedTgtMap
Definition: fedex.h:890
DtRestoreCompleteMsg
Definition: resComMsg.h:22
DtFederateCbFn
void(* DtFederateCbFn)(DtFederate *federate, void *usr)
Federate joined/resigned callback prototype.
Definition: fedex.h:96
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:973
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:859
DtRtiApiUniquePtrTime
DtRtiApiUniquePtr< DtRtiApiTime > DtRtiApiUniquePtrTime
Definition: rtiApiTypes.h:96
DtFedExec::myResignAction
DtResignAction myResignAction
Definition: fedex.h:862
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:837
DtSaveTimeAdvanceMsg
Definition: savTimeAdvMsg.h:21
DtQueryRestoreStatusMsg
Definition: queryRestoreStatusMsg.h:22
DtReserveMultiNameMsg
Definition: reserveMultiNameMsg.h:25
DtFedExec::mySyncList
DtSyncHashlist mySyncList
Definition: fedex.h:845
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:835
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
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:841
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:844
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 Sun Jul 20 16:15:30 EDT 2025 from SVN revision 277985
Copyright © 2005-2025 MAK Technologies Inc. All Rights Reserved (www.mak.com)