MAK RTIspy API Documentation for HLA Evolved
 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 #ifndef DtFedExec_H_
13 #define DtFedExec_H_
14 
15 #include <rtiMsConfig.h>
16 #include <vlutil/vlString.h>
17 #include <vlutil/vlUtil.h>
18 #include "vlThreadedObject.h"
19 #include <rtiApiTypes.h>
20 #include <connection.h>
21 #include <resignMsg.h>
22 #include <fomMgr.h>
23 
24 #include "federate.h"
25 #include "timeInfoList.h"
26 #include "asynchronousFileDistributor.h"
27 #include "execCmds.h"
28 #include "distributorThreadEvents.h"
29 
30 #include <joinRespMsg.h>
31 #include <savRespMsg.h>
32 #include <syncPointMsg.h>
33 #include <savFinMsg.h>
34 #include <resEndMsg.h>
35 #include <resignRespMsg.h>
36 #include <creRespMsg.h>
37 
38 #include "mtl/fedReader13.h"
39 #include "mtl/fedReader1516.h"
40 #include "mtl/fedReader1516e.h"
41 #include <mtl/fomSorter.h>
42 
43 
44 class DtRidFileTester;
45 
46 class DtFederateHandleSet;
47 class DtLogicalTimeFactory;
48 class DtRIDParameters;
49 class DtSyncPt;
50 class DtTimeInfo;
51 
52 class DtAliveMsg;
53 class DtTransferRidParamsMsg;
54 class DtConstrainedSyncMsg;
55 class DtDisableMsg;
56 class DtEnableRegulationMsg;
57 class DtEnableConstrainedMsg;
58 class DtJoinConfirmMsg;
59 class DtJoinMsg;
60 class DtNextEventRequestMsg;
61 class DtOwnershipMsg;
62 class DtResignMsg;
63 class DtRestoreBegunMsg;
64 class DtRestoreCompleteMsg;
65 class DtRestoreRequestMsg;
66 class DtAbortRestoreMsg;
67 class DtSaveBegunMsg;
68 class DtSaveCompleteMsg;
69 class DtSaveRequestMsg;
70 class DtSaveRequestTsoMsg;
71 class DtAbortSaveMsg;
72 class DtInitiatedSaveMsg;
73 class DtSaveTimeAdvanceMsg;
74 class DtSyncPointMsg;
75 class DtSyncPointQueryMsg;
76 class DtTimeAdvanceRequestMsg;
77 class DtReserveNameMsg;
78 class DtQuerySaveStatusMsg;
79 class DtQueryRestoreStatusMsg;
80 class DtFedExec;
81 class DtFedJoinInfo;
82 class DtRtiAssistantExecClient;
83 class DtReserveMultiNameMsg;
84 class DtReleaseMultiNameMsg;
85 class DtFomModuleDistExecMsg;
86 
87 #ifdef DtIFSPEC1516
88 #define RTINAMESPACE rti1516
89 #elif defined(DtIFSPEC1516E)
90 #define RTINAMESPACE rti1516e
91 #else
92 // TODO Unimplemented for HLA 1.3
93 #endif
94 
96 typedef DtFedExec* (*DtFedExecCreator)(DtConnectionMgr* connMgr,
97  const std::vector<unsigned int> & crcs,
98  DtString const & fedExName,
99  std::string const & timeImplName,
100  MAKRti::DtFomType fedType,
101  const DtString& momModuleName,
102  const std::vector<DtString>& fedFileName,
103  int fedExHandle,
104  DtRIDParameters* params,
105  unsigned int momModuleCrc);
106 
107 
109 typedef void (*DtFederateCbFn)(DtFederate* federate, void* usr);
110 
112 typedef void (*DtFederateCbFn)(DtFederate* handle, void* usr );
113 
115 typedef void (*DtSyncPointCbFn)(DtSyncPt* pt, void* usr);
116 
118 typedef void (*DtSyncPointAchievedCbFn)(DtFederate* who, DtSyncPt* pt, void* usr);
119 
121 typedef std::map<DtFederateHandle, DtFederate*> DtFederateHandleInfoMap;
122 
124 typedef std::map<DtString, DtFederate*> DtFederateNameInfoMap;
125 
126 typedef std::pair< const DtString, DtFomClassMgr > DtFileToFedTgtPair;
127 
128 typedef std::pair<DtString, DtFedReadStatus> DtFomToReadStatusPair;
129 
130 class DT_DLL_EXEC DtFedExec
131 {
132 
133 protected:
134 
136  DtFedExec(DtConnectionMgr* connMgr,
137  const std::vector<unsigned int> & crcs, DtString const & fedExName,
138  std::string const & timeImplName, MAKRti::DtFomType fedType,
139  const DtString& momModuleName,
140  const std::vector<DtString >& modules,
141  int fedExHandle, DtRIDParameters* params, unsigned int momModuleCrc);
142 
143 public:
144 
146  virtual ~DtFedExec();
147 
149  virtual DtConnectionMgr* connectMgr();
150 
152  virtual DtLogicalTimeFactory* fedTimeFactory();
153 
155  virtual const DtString& fedExName() const;
156 
158  virtual int fedExHandle() const;
159 
162  virtual const DtString& fedFileName() const;
163 
165  virtual const std::vector<DtString>& fomModules() const;
166 
168  virtual bool fullyCreated() const;
169 
171  virtual void setFullyCreated(bool val);
172 
174  virtual unsigned long creatorID() const;
175 
177  virtual void createDistributor( const unsigned long initiatingFedID,
178  const DtString& momModuleName,
179  const std::vector<DtString>& fomModules );
180 
182  virtual int numFederates() const;
183 
186  virtual DtFederate* getFederate(DtFederateHandle handle);
187 
190  virtual DtFederateHandle federateHandleOfConnection(unsigned long connId) const;
191 
193  virtual void disconnectFederate( DtFederate* fed );
194 
196  virtual bool removeFederateConnection(unsigned long id);
197 
202  virtual bool restoreFederateConnection( DtFederateHandle handle,
203  unsigned long newConnId, unsigned long& oldConnId);
204 
206  virtual void reconnectFederateSucceeded( DtFederate* fed );
207 
209  virtual void reconnectFederateFailed( DtFederate* fed );
210 
212  virtual bool resignFederate(DtFederateHandle handle,
213  DtResignAction action, DtResignReason reason );
214 
221  virtual void resetClockForHeartBeat();
222 
224  virtual bool tick();
225 
227  virtual void printFederates();
228 
230  virtual void addFederateJoinedCallback(DtFederateCbFn fn, void* usr);
231 
233  virtual void removeFederateJoinedCallback(DtFederateCbFn fn, void* usr);
234 
236  virtual void addFederateResignedCallback(DtFederateCbFn fn, void* usr);
237 
239  virtual void removeFederateResignedCallback(DtFederateCbFn fn, void* usr);
240 
243  virtual void addSyncPtRegisteredCallback(DtSyncPointCbFn fn, void* usr);
244 
247  virtual void removeSyncPtRegisteredCallback(DtSyncPointCbFn fn, void* usr);
248 
251  virtual void addSyncPtAchievedCallback(DtSyncPointAchievedCbFn fn, void* usr);
252 
255  virtual void removeSyncPtAchievedCallback(DtSyncPointAchievedCbFn fn, void* usr);
256 
259  virtual void addFederationSynchronizedCallback(DtSyncPointCbFn fn, void* usr);
260 
263  virtual void removeFederationSynchronizedCallback(DtSyncPointCbFn fn, void* usr);
264 
266  virtual void addFederateDisconnectedCallback(DtFederateCbFn fn, void* usr );
267 
269  virtual void removeFederateDisconnectedCallback(DtFederateCbFn fn, void* usr );
270 
271  //Register callbacks for federate reconnect.
272  virtual void addFederateReconnectSucceededCallback(DtFederateCbFn fn, void* usr );
273 
274  //Unregister callbacks for federate reconnect.
275  virtual void removeFederateReconnectSucceededCallback(DtFederateCbFn fn, void* usr );
276 
277  //Register callbacks for federate reconnect.
278  virtual void addFederateReconnectFailedCallback(DtFederateCbFn fn, void* usr );
279 
280  // Unregister callbacks for federate reconnect.
281  virtual void removeFederateReconnectFailedCallback(DtFederateCbFn fn, void* usr );
282 
284  void multFileReceivedCb(const DtFomModuleDistributionMsg& msg);
285 
287  void multFileRequestedCb(const DtFomModuleRequestMsg& msg);
288 
290  void pushFomModuleToJoinedFederates(DtFederate* newFederate,
291  DtString fileName,
292  unsigned int fileSize,
293  const char* fileBuffer );
294 
296  void pushFomModuleToSingleFederate(DtFederateHandle recipient,
297  DtString fileName,
298  unsigned int fileSize,
299  const char* fileBuffer );
300 
302  virtual void processRequestedModulesArrived( const DtRequestedModulesArrivedEvent& e );
303 
305  virtual void processFedFileRequestMsg( const DtFedFileRequestMsgEvent& e);
306 
308  virtual void processFileTransfer(const DtFedExTakeFileEvent& e);
309 
311  virtual DtFederateHandleInfoMap const& federates() const;
312 
313 #ifdef DtTIME
314  virtual const DtTimeInfoList* regulatingFederates() const;
316 
318  virtual const DtTimeInfoList* constrainedFederates() const;
319 #endif
320 
322  virtual void disableNetworkTesting();
323 
325  virtual void enableNetworkTesting();
326 
328  virtual void changeLatencyTestMode( DtFederateHandle handle, bool runTest,
329  bool continuous, bool haltContinuous, bool observing,
330  unsigned int interactionPeriod, unsigned int numInteractions,
331  unsigned int payloadBytes );
332 
334  virtual bool transferRidParams(DtFederateHandle handle, const DtString& ridString);
335 
336 public:
337 
340 
341  static void processJoinMsg(const DtJoinMsg& msg, void* usr);
342  static void processJoinConfirm(const DtJoinConfirmMsg& msg, void* usr);
343  static void processAlive(const DtAliveMsg& msg,void* usr);
344  static void processResign(const DtResignMsg& msg, void* usr);
345  static void processSyncPoint(const DtSyncPointMsg& msg, void* usr);
346  static void processSyncPointQuery(const DtSyncPointQueryMsg& msg, void* usr);
347  static void processSaveRequest(const DtSaveRequestMsg& msg, void* usr);
348  static void processInitiatedSave(const DtInitiatedSaveMsg& msg, void* usr);
349  static void processSaveComplete(const DtSaveCompleteMsg& msg, void* usr);
350  static void processSaveBegun(const DtSaveBegunMsg& msg, void* usr);
351  static void processAbortSave(const DtAbortSaveMsg& msg, void* usr);
352  static void processRestoreRequest(const DtRestoreRequestMsg& msg, void* usr);
353  static void processRestoreBegun(const DtRestoreBegunMsg& msg, void* usr);
354  static void processRestoreComplete(const DtRestoreCompleteMsg& msg,
355  void* usr);
356  static void processAbortRestore(const DtAbortRestoreMsg& msg, void* usr);
357  static void processOwnership(const DtOwnershipMsg& msg, void* usr);
358  static void processReserveName(DtReserveNameMsg const& msg, void* usr);
359  static void processReserveMultiName(DtReserveMultiNameMsg const& msg, void* usr);
360  static void processReleaseMultiName(DtReleaseMultiNameMsg const& msg, void* usr);
361  static void processQuerySaveStatus(DtQuerySaveStatusMsg const& msg,
362  void* usr);
363  static void processQueryRestoreStatus(DtQueryRestoreStatusMsg const& msg,
364  void* usr);
365 #ifdef DtTIME
366  static void processSaveTimeAdvance(const DtSaveTimeAdvanceMsg& msg, void* usr);
367  static void processSaveRequestTso(const DtSaveRequestTsoMsg& msg, void* usr);
368  static void processEnableRegulation(const DtEnableRegulationMsg& msg,
369  void* usr);
370  static void processEnableConstrained(const DtEnableConstrainedMsg& msg,
371  void* usr);
372  static void processTimeAdvanceRequest(const DtTimeAdvanceRequestMsg& msg,
373  void* usr);
374  static void processDisable(const DtDisableMsg& msg, void* usr);
375  static void processConstrainedSync(const DtConstrainedSyncMsg& msg,
376  void* usr);
377  static void processNextEventRequest(const DtNextEventRequestMsg& msg,
378  void* usr);
379 #endif
380 
381 
383  static void multFileReceivedExecCb(const DtFomModuleDistExecMsg& msg, void* usr);
384 
386  static void multFileReceivedCb( const DtFomModuleDistributionMsg& msg, void* usr );
387 
389  static void multFileRequestedCb( const DtFomModuleRequestMsg& msg, void* usr );
390 
392  static DtFedExec* create(DtConnectionMgr* connMgr,
393  const std::vector<unsigned int> & crcs,
394  DtString const & fedExName,
395  std::string const & timeImplName,
396  MAKRti::DtFomType fedType,
397  DtString const& momModuleName,
398  const std::vector<DtString>& fomModules,
399  int fedExHandle,
400  DtRIDParameters* params,
401  unsigned int momModuleCrc);
402 
406  static void setCreatorFunction(DtFedExecCreator creator);
407 
408  static void init( DtRtiAssistantExecClient* assistant );
409 
410 protected:
411 
413  virtual const std::map< unsigned long, std::vector<DtString>*>& joinFomModules() const;
414 
415  virtual std::vector<DtString>& joinFomModulesForConnection(unsigned long connID) const;
416 
418  virtual const std::vector<DtString>& createFomModules() const;
419 
422 
423  virtual void processJoinMsg(const DtJoinMsg& msg);
424  virtual bool handleJoinFailureCases( const DtJoinMsg &msg );
425  virtual void requestFedFileUpload( const DtJoinMsg& msg );
426 
427  virtual void processJoinConfirm(const DtJoinConfirmMsg& msg);
428  virtual void processAlive(const DtAliveMsg& msg);
429  virtual void processResign(const DtResignMsg& msg);
430  virtual void processSyncPoint(const DtSyncPointMsg& msg);
431  virtual void processSyncPointQuery(const DtSyncPointQueryMsg& msg);
432  virtual void processSaveRequest(const DtSaveRequestMsg& msg);
433  virtual void processInitiatedSave(const DtInitiatedSaveMsg& msg);
434  virtual void processSaveComplete(const DtSaveCompleteMsg& msg);
435  virtual void processSaveBegun(const DtSaveBegunMsg& msg);
436  virtual void processAbortSave(const DtAbortSaveMsg& msg);
437  virtual void processRestoreRequest(const DtRestoreRequestMsg& msg);
438  virtual void processRestoreBegun(const DtRestoreBegunMsg& msg);
439  virtual void processRestoreComplete(const DtRestoreCompleteMsg& msg);
440  virtual void processAbortRestore(const DtAbortRestoreMsg& msg);
441  virtual void processOwnership(const DtOwnershipMsg& msg);
442  virtual void processReserveName(DtReserveNameMsg const& msg);
443  virtual void processReserveMultiName(DtReserveMultiNameMsg const& msg);
444  virtual void processReleaseMultiName(DtReleaseMultiNameMsg const& msg);
445  virtual void processQuerySaveStatus(DtQuerySaveStatusMsg const& msg);
446  virtual void processQueryRestoreStatus(DtQueryRestoreStatusMsg const& msg);
447 
448 #ifdef DtTIME
449  virtual void processEnableRegulation(const DtEnableRegulationMsg& msg);
450  virtual void processEnableConstrained(const DtEnableConstrainedMsg& msg);
451  virtual void processTimeAdvanceRequest(const DtTimeAdvanceRequestMsg& msg);
452  virtual void processDisable(const DtDisableMsg& msg);
453  virtual void processConstrainedSync( const DtConstrainedSyncMsg& msg);
454  virtual void processSaveRequestTso(const DtSaveRequestTsoMsg& msg);
455  virtual void processSaveTimeAdvance(const DtSaveTimeAdvanceMsg& msg);
456  virtual void processNextEventRequest(const DtNextEventRequestMsg& msg);
457 #endif
458 
460 
462  virtual void processRegisterSyncPoint(const DtSyncPointMsg& msg);
463 
465  virtual void processAchievedSyncPoint(const DtSyncPointMsg& msg);
466 
468  virtual void createSyncPoint(const DtSyncPointMsg& msg);
469 
471  virtual void processSyncPtAchievedCallbacks(DtSyncPt* point,
472  DtFederate* federate);
473 
475  virtual void processFederationSynchronizedCallbacks(DtSyncPt* point);
476 
480  virtual bool synchronized(DtSyncPt* point,
481  DtFederateHandleSet& unsuccessfulSet) const;
482 
484  virtual void sendSyncPointReport(const DtSyncPointQueryMsg& msg);
485 
487  virtual void sendSyncPointStatusReport(const DtSyncPointQueryMsg& msg);
488 
490  virtual DtFederate* addFederate(
491  const char* federateType, const char* federateName, DtFederateHandle handle,
492  unsigned long connHandle, int astntCompId, const char* fedHostName,
493  MAKRti::DtInetAddr host, DtHlaVersionId hlaVersion);
494 
497  virtual DtFederate* createFederate(
498  const char* federateType, const char* federateName,
499  DtFederateHandle handle, unsigned long connHandle, int astntCompId,
500  const char* fedHostname, MAKRti::DtInetAddr host,
501  DtHlaVersionId hlaVersion);
502 
504  virtual bool isMember(DtFederateHandle handle) const;
505 
508  virtual bool deleteFederate(DtFederateHandle handle);
509 
511 
513  virtual void readCreateFoms( DtFomClassMgr* topLvlTgt,
514  std::vector<DtString>& fomFiles, DtCreateResponseFlag& response,
515  DtString& errorResponseString, DtFedReadStatus& status,
516  DtFomSorter* myFomSorter );
517 
519  virtual void readJoinFoms( std::vector<DtString>& fomFiles,
520  DtJoinResponseMsg::errorCodes& response, DtString& errorResponseString,
521  DtFedReadStatus& status, DtFomSorter* myFomSorter );
522 
524  virtual bool processCreateReady();
525 
528  virtual bool processJoin(unsigned long connID, const DtFedJoinInfo* fedInfo);
529 
531  virtual void processJoinReady();
532 
534  virtual void destroyDistributor();
535 
537  virtual DtAsyncFileDistributorRunnable* distributor() const;
538 
544  virtual unsigned int numberFederatesAllowed(unsigned int numPartners) const;
545 
547  virtual void resetControl();
548 
550  virtual bool tickDistributor();
551 
553  virtual bool processEvents();
554 
555 protected:
556 
557 
558  DtFedReader * getReader(DtFomType theFomType);
559  DtFedReader * getReader( DtFomType theFomType, DtFomClassMgr* target);
560 
561  void populateWithUnknownFoms(std::vector<DtString> & mods, std::vector<DtString> & requestedMods);
562  bool isFomAvailable(const DtString & fomName);
563  bool doesCrcMatchKnownFomModuleCrc( const DtString & fomName, unsigned int myTakenFomCrc );
564 
566  virtual bool fedFileReady(const MAKRti::DtString& fileName) const;
567 
569  virtual bool fedFilesReady( const std::vector<MAKRti::DtString>* fileNames ) const;
570 
572  virtual bool addJoinFomModuleForConnection( unsigned long connId,
573  const std::vector<MAKRti::DtString>& modulesFromJoinRequest );
574 
576  virtual void removeJoinFomModuleForConnection( unsigned long connID );
577 
579 
581  virtual void tickSaveRestore();
582 
585  virtual void tickJoin();
586 
589  virtual void tickFederates();
590 
593 
594  virtual void sendSyncPointMsg(
595  DtSyncMsgType kind, int id,
596  DtSyncPointStatus status,
597  const char* name,
598  RTINAMESPACE::VariableLengthData const* theTag = NULL,
599  const DtFederateHandleSet* set = NULL,
600  const DtFederateHandleSet* unsuccessfulSet = NULL);
601 
602  virtual void sendResignMsg(
603  const char* name, DtFederateHandle fedHandle,
604  DtResignAction action, DtResignReason reason,
605  const DtTimeInfo* timeInfo );
606  virtual void sendEnableDisableNetworkTestingMsg(
607  const char* name, bool enabled );
608  virtual void sendTransferRidParamsMsg(
609  const char* name, DtFederateHandle fedHandle, const DtString& paramString);
610  virtual void sendJoinResponseMsg(unsigned long destinationIDValue,
611  unsigned short requestID, unsigned int crcOfFedFile, DtFederateHandle handle,
612  const char* federateName, int fedExHandle, const char* fedExName,
613  const DtString& momModule, const std::vector<MAKRti::DtString>& modules,
614  unsigned long flags, bool allowNetworkTesting, bool enableNetworkTesting,
615  DtHlaVersionId hlaVers,
616  DtJoinResponseMsg::errorCodes errorValue = DtJoinResponseMsg::DT_NO_ERROR,
617  const DtString& errorString = DtString::nullString());
618  virtual void sendResignResponseMsgIfNecessary( const DtResignMsg& msg, DtResignResponse response, DtFederateHandle fedHandle );
619  virtual void sendSaveInitiateMsg(const char* labelVal);
620  virtual void sendSaveInitiateConstrainedMsg(const char* labelVal);
621  virtual void sendSaveResponse(DtFederateHandle fedHandle,
622  unsigned long requestID, const char* labelVal,
623  DtSaveResponseFlag response);
624  virtual void sendDesignatedFederate(DtFederateHandle fedHandle);
625  virtual void sendNameReservedMsg(DtFederateHandle requestingFederate,
626  char const* objectName, bool result);
627  virtual void sendMultiNameReservedMsg( DtFederateHandle requestingFederate,
628  std::set< std::wstring > const & objectNames,
629  bool result );
630 
631  virtual void sendRestoreStatus(DtFederateHandle requestingFederate,
632  RTINAMESPACE::FederateRestoreStatusVector const & restoreStatusList);
633 
634  virtual void sendSaveStatus(DtFederateHandle requestingFederate,
635  RTINAMESPACE::FederateHandleSaveStatusPairVector const & saveStatusList);
636 
637 #ifdef DtTIME
638  virtual void sendRegulationEnabledMsg(
639  DtFederateHandle handle,
640  DtRtiApiTime const & time);
641  virtual void sendConstrainedEnabledMsg(
642  DtFederateHandle handle,
643  DtRtiApiTime const & time,
644  DtRtiApiTime const & lbts);
645  virtual void sendLbtsMsg(DtFederateHandle laggardFederate,
646  DtRtiApiTime const & lbtsVal,
647  DtRtiApiTime const & lagLbtsVal);
648  virtual void sendNerLbtsMsg(
649  unsigned long nerCycle, DtFederateHandle laggardFederate,
650  bool nerPending, bool lagNerPending,
651  DtRtiApiTime const & lbtsVal,
652  DtRtiApiTime const & lagLbtsVal);
653  virtual void sendSyncConstrainedMsg();
654  virtual void sendResumeConstrainedMsg(DtFederateHandle laggardFederate,
655  DtRtiApiTime const & lbtsVal,
656  DtRtiApiTime const & lagLbtsVal);
657  virtual void sendSaveTimeMsg(char const* label,
658  DtRtiApiTime const & saveTime);
659 #endif
660 
661 
662  virtual void retireSyncPoint(const char* name);
665 
668  virtual void announceAllSyncPoints(DtFederateHandle hand);
669 
671  virtual void checkTimedSave();
672 
674  virtual void initiateSave(const char* label);
675 
678  virtual bool save( const char* label );
679 
682  virtual int initializeRestore( const char* label );
683 
686  virtual bool restore( const char* label );
687 
689  virtual void endSave(DtSaveFinishedResult result);
690 
692  virtual void endRestore(DtEndRestoreResult restoreResult);
693 
696  virtual DtString& getSaveFileName(const char* label, MAKRti::DtString& fileName,
697  bool extendName=true);
698 
701  virtual DtString& getRestoreFileName(const char* label, MAKRti::DtString& fileName);
702 
703 #ifdef DtTIME
704  virtual void resignFederateTime(DtFederateHandle federateHandle);
706 
708  void disableFederateTimeRegulation(DtFederateHandle federateHandle);
709 
711  void removeRegulatingEntry(DtTimeInfo* entry);
712 
714  virtual void checkPendingConstrained(DtRtiApiTime const & lbts);
715 
717  virtual void checkPendingConstrained(DtTimeInfo* entry,
718  DtRtiApiTime const & lbts);
719 
722  virtual bool becomeConstrained(DtTimeInfo* entry);
723 
726  void adjustRegulatingEntry(DtTimeInfo* entry,
727  DtRtiApiTime const & time,
728  DtRtiApiTimeInterval const & lookahead,
729  bool isTimeAvailable);
730 
732  void checkNerCycle(DtFederateHandle fedHandle);
733 
735  virtual void processEnableRegulation(DtFederateHandle federateHandle,
736  DtRtiApiTime const & time,
737  DtRtiApiTimeInterval const & lookahead);
738 
741  virtual void processPendingRegulation(DtFederateHandle federateHandle,
742  DtRtiApiTime const & time,
743  DtRtiApiTimeInterval const & lookahead);
744 
746  virtual DtRtiApiTime& getTempTime();
752  virtual void putTempTime(DtRtiApiTime& timePtr);
754  virtual void destroyTempTimePool();
756 
758  virtual DtFederateHandle minLbtsFederate() const;
759 
761  virtual DtRtiApiTime const & minLbts() const;
762 
764  virtual DtRtiApiTime const & lagLbts() const;
765 
768  virtual bool minTimeAvailable() const;
769 
772  virtual bool lagTimeAvailable() const;
773 
775  virtual DtFederateHandle minNerLbtsFederate() const;
776 
778  virtual DtRtiApiTime const & minNerLbts() const;
779 
781  virtual DtFederateHandle lagNerLbtsFederate() const;
782 
784  virtual DtRtiApiTime const & lagNerLbts() const;
785 
787  virtual bool minNerPending() const;
788 
790  virtual bool lagNerPending() const;
791 
793  virtual void setSaveTime(DtRtiApiTime const & timeVal);
794 
796  virtual DtRtiApiTime const & saveTime() const;
797 
799  virtual unsigned int federateHandleSlot(DtFederateHandle handle) const;
800 
802  virtual bool isFederateHandleSlotInUse(DtFederateHandle handle) const;
803 
805  virtual void setFederateHandleSlotInUse(DtFederateHandle handle, bool isInUse);
806 
807 #endif
808 
811  virtual int getNextFreeFedHandle();
812 
813 
815  DtFedExec();
816 
818  DtFedExec(const DtFedExec& orig);
819  DtFedExec& operator=(DtFedExec const& orig);
820 
821 protected:
822  DtConnectionMgr* myConnectionMgr;
823  unsigned int myCrcOfFedFile;
824  int myFreeFedHandle;
825  std::vector<bool> myFedHandlesInUse;
826  bool myUseDestinationMetadata;
827  DtString myFedExName;
828  DtFederateHandleInfoMap myFederates;
829  DtFederateNameInfoMap myFederatesByName;
830  std::map< MAKRti::DtString, DtFederateHandle > myFederateHdlsByName;
831  int myNumFederates;
832  DtSyncHashlist mySyncList;
833  DtString myMomModule;
834  unsigned int myMomModuleCrc;
835  std::vector<unsigned int> myCreationFedFilesCRCs;
836  MAKRti::DtFomType myFedType;
837  std::vector<DtString> myFomModules;
838  // ! This will be a Map with the keys being a FOM module name, and the value being its CRC.
839  // ! This map is populated at create and join
840  std::map<DtString, unsigned int> myFomModulesNameToCrcMap;
841  std::set<DtString> myFomModulesSet;
842  std::vector<DtString> myCreateFomModules;
843  std::map<unsigned long, std::vector<DtString>* >myJoinFomModules;
844  DtFomClassMgr* myFom;
845  int myFedExHandle;
846  DtFederateHandle myDesignatedFederate;
847  float myFederateTimeoutInterval;
848 
849  std::set< unsigned long > myConnectionsProcessJoined;
850 
852  std::map<DtFederateHandle, DtFedJoinInfo*> myJoiningFederates;
853  std::map<unsigned long, DtFedJoinInfo*> myJoiningFederatesByID;
855  int myNumberResponseAttempts;
857  float myResponseInterval;
858 
859  bool mySave;
860  bool myRestore;
861  std::set<DtFederateHandle> myPendingSaveFederates;
862  DtFederateHandleStdSet myInitiatedSaveFederates;
863  DtString mySaveLabel;
864  DtFederateHandle mySavingFederate;
865  std::set<DtFederateHandle> myPendingRestoreFederates;
866  DtFederateHandleInfoMap myRestoreFederatesByOld;
867  DtFederateHandleInfoMap myRestoreFederatesByNew;
868  DtString mySavePath;
869  bool mySavePending;
870  bool mySaveBegun;
871  // When files are received from distributor, store them here until requester takes them.
872  std::map<DtString, DtFileInformation*> myTakenFiles;
873  // When FOMs are read, map FOM filename to fed target here.
874  std::map< const DtString, DtFomClassMgr > myFedexFileToFedTgtMap;
875  std::map<DtString, DtFedReadStatus> myFomToReadStatusMap;
876 
877  bool myAwaitingCreateUpload;
878  unsigned long myCreatorConnId;
879  std::set< unsigned long> myAwaitingJoinUpload;
880  bool myFullyCreated;
881 
882  int myTimeout;
883  int myDefaultWait;
884  int myFomModuleSorting;
885 
886  DtList myJoinCallbacks;
887  DtList myResignCallbacks;
888  DtList myDisconnectCallbacks;
889  DtList myReconnectSucceededCallbacks;
890  DtList myReconnectFailedCallbacks;
891  DtList myFedSynchronizedCallbacks;
892  DtList mySpAchievedCallbacks;
893  DtList mySpRegisterCallbacks;
894 
895  typedef std::set<std::string> DtFedExReservedNameSet;
896  typedef std::map< DtFederateHandle, DtFedExReservedNameSet >
897  DtFedExFederateReservedNameMap;
898  DtFedExReservedNameSet myReservedNames;
899  DtFedExFederateReservedNameMap myFederateReservedNames;
900 
901 #ifdef DtTIME
902  DtLogicalTimeFactory* myLogicalTimeFactory;
903  DtTimeInfoList myRegulatingFederates;
904  DtTimeInfoList myConstrainedFederates;
905  DtTimeInfoList myPendingConstrained;
906  DtTimeInfoList myPendingTar;
907  DtTimeInfoList myPendingRegulation;
908  DtTimeInfoList myNerLbtsList;
909  DtTimeInfoList myNerRequested;
910  DtTimeInfoList myPendingNerResponses;
911  bool myNewNerRequestPending;
912  bool myForceNerCycle;
913  bool myNerChange;
914  bool myTransmitLaggardLBTS;
915  DtList mySyncConstrained;
916  unsigned long myNerCycle;
917  DtFederateHandle myNerFederate;
918  DtFederateHandle myLagNerFederate;
919  DtList myTempTimePool;
920  std::auto_ptr<DtRtiApiTime> myPositiveInfinity;
921  std::auto_ptr<DtRtiApiTime> mySaveTime;
922  std::auto_ptr<DtRtiApiTime> myNerLbts;
923  std::auto_ptr<DtRtiApiTime> myLagNerLbts;
924 #endif
925 
926  vrlmod::DtThreadedObject* myDistributorThread;
927  DtAsyncFileDistributorRunnable* myDistributor;
928  static const std::vector<DtString> theEmptyStringSet;
929  bool myDistributeFedFile;
930  bool myCrcCheckFedFile;
931  unsigned long myInitiatorID;
932  int myStrictNameReservation;
934  bool myAllowNetworkTesting;
936  bool myNetworkTestingEnabled;
937 
938  DtClock myClock;
939 
940  unsigned int myNumberFederatesAllowed;
941 
942 protected:
943 
944  static DtFedExecCreator theCreator;
945  //DtFedReaderFactory myFedReaderFactory;
946  DtFedReader13 * myFedReader13;
947  DtFedReader1516 * myFedReader1516;
948  DtFedReader1516e * myFedReader1516e;
949 
950 private:
951 
952  static const DtString nullStr;
953  bool myFullFedFileDistribution;
954 
955 };
956 
957 
958 
959 #endif
960 
DtFedExec::myConnectionsProcessJoined
std::set< unsigned long > myConnectionsProcessJoined
Definition: fedex.h:849
DtFedFileRequestMsgEvent
Definition: distributorThreadEvents.h:221
DtFedExec::myDefaultWait
int myDefaultWait
Definition: fedex.h:883
DtFedExec::myPendingRestoreFederates
std::set< DtFederateHandle > myPendingRestoreFederates
Definition: fedex.h:865
DtFedExec::myReconnectFailedCallbacks
DtList myReconnectFailedCallbacks
Definition: fedex.h:890
DtFedExec::myNumberFederatesAllowed
unsigned int myNumberFederatesAllowed
Definition: fedex.h:940
DtSyncPointQueryMsg
Definition: syncPointQueryMsg.h:31
DtFedExec::myCreationFedFilesCRCs
std::vector< unsigned int > myCreationFedFilesCRCs
Definition: fedex.h:835
DtFedExec::myFedReader13
DtFedReader13 * myFedReader13
Definition: fedex.h:946
DtFedExec::myFedType
MAKRti::DtFomType myFedType
Definition: fedex.h:836
DtAliveMsg
Definition: aliveMsg.h:24
DtFedExec::myMomModuleCrc
unsigned int myMomModuleCrc
Definition: fedex.h:834
DtSaveFinishedResult
DtSaveFinishedResult
Definition: savFinMsg.h:21
DtFedExec::DtFedExReservedNameSet
std::set< std::string > DtFedExReservedNameSet
Definition: fedex.h:895
DtFedExec::myCrcOfFedFile
unsigned int myCrcOfFedFile
Definition: fedex.h:823
DtJoinConfirmMsg
Definition: joinConfMsg.h:24
DtFedExec::myRestoreFederatesByOld
DtFederateHandleInfoMap myRestoreFederatesByOld
Definition: fedex.h:866
DtFedExec::myAwaitingCreateUpload
bool myAwaitingCreateUpload
Definition: fedex.h:877
DtFedExec::myCreatorConnId
unsigned long myCreatorConnId
Definition: fedex.h:878
DtFedExec::myAllowNetworkTesting
bool myAllowNetworkTesting
Whether network testing is enabled or completely disabled by the RID.
Definition: fedex.h:934
DtRIDParameters
This class manages the RTI&#39;s start-up configuration using both MTL variables and functions.
Definition: RIDparams.h:87
DtLogicalTimeFactory
!DtIFSPEC1516
Definition: fedTimeFactory.h:190
DtSyncPt
Definition: syncPt.h:29
DtFedExec::myMomModule
DtString myMomModule
Definition: fedex.h:833
DtFedExec::myFomModulesNameToCrcMap
std::map< DtString, unsigned int > myFomModulesNameToCrcMap
Definition: fedex.h:840
DtFedExec
Definition: fedex.h:130
DtJoinMsg
Definition: joinMsg.h:27
DtFedExec::myInitiatedSaveFederates
DtFederateHandleStdSet myInitiatedSaveFederates
Definition: fedex.h:862
DtFedExec::myInitiatorID
unsigned long myInitiatorID
Definition: fedex.h:931
DtOwnershipMsg
Definition: ownerMsg.h:45
DtFedExec::myDistributeFedFile
bool myDistributeFedFile
Definition: fedex.h:929
DtFedExec::myRestore
bool myRestore
Definition: fedex.h:860
DtFedExec::myNetworkTestingEnabled
bool myNetworkTestingEnabled
Whether network testing has been toggled on/off by the assistant.
Definition: fedex.h:936
DtFomModuleDistExecMsg
Definition: fomModuleDistExecMsg.h:26
DtFedExec::myResponseInterval
float myResponseInterval
to obtain response retransmission interval
Definition: fedex.h:857
DtSaveResponseFlag
DtSaveResponseFlag
Definition: savRespMsg.h:22
DtSyncHashlist
Definition: syncHashlist.h:21
DtFedExec::mySavePath
DtString mySavePath
Definition: fedex.h:868
DtFedExec::nullStr
static const DtString nullStr
Definition: fedex.h:952
DtSaveCompleteMsg
Definition: savCompMsg.h:22
DtFedExec::myDesignatedFederate
DtFederateHandle myDesignatedFederate
Definition: fedex.h:846
DtFedExec::mySavePending
bool mySavePending
Definition: fedex.h:869
DtHlaVersionId
DtHlaVersionId
Definition: rtiVersion.h:41
DtFederateHandleSet
Definition: fedHandleSet.h:102
DtFedExec::myFedExName
DtString myFedExName
Definition: fedex.h:827
DtFedExec::myFomModuleSorting
int myFomModuleSorting
Definition: fedex.h:884
DtFedExec::myFedHandlesInUse
std::vector< bool > myFedHandlesInUse
Definition: fedex.h:825
DtFedExec::myFomToReadStatusMap
std::map< DtString, DtFedReadStatus > myFomToReadStatusMap
Definition: fedex.h:875
DtFedExec::mySaveBegun
bool mySaveBegun
Definition: fedex.h:870
DtFedExec::myFederateTimeoutInterval
float myFederateTimeoutInterval
Definition: fedex.h:847
DtFedExec::myClock
DtClock myClock
Definition: fedex.h:938
DtFedExec::myJoinFomModules
std::map< unsigned long, std::vector< DtString > * > myJoinFomModules
Definition: fedex.h:843
DtFedExec::DtFedExFederateReservedNameMap
std::map< DtFederateHandle, DtFedExReservedNameSet > DtFedExFederateReservedNameMap
Definition: fedex.h:897
DtFedExec::myFedSynchronizedCallbacks
DtList myFedSynchronizedCallbacks
Definition: fedex.h:891
DtFedExec::myAwaitingJoinUpload
std::set< unsigned long > myAwaitingJoinUpload
Definition: fedex.h:879
DtResignMsg
Definition: resignMsg.h:36
DtFedExec::myFederateHdlsByName
std::map< MAKRti::DtString, DtFederateHandle > myFederateHdlsByName
Definition: fedex.h:830
DtFedExec::myDistributor
DtAsyncFileDistributorRunnable * myDistributor
Definition: fedex.h:927
DtRtiApiTimeInterval
RTI::FedTime DtRtiApiTimeInterval
Definition: rtiApiTypes.h:50
DtFedExec::myCrcCheckFedFile
bool myCrcCheckFedFile
Definition: fedex.h:930
DtFedExec::myTimeout
int myTimeout
Definition: fedex.h:882
DtFedExec::myFederatesByName
DtFederateNameInfoMap myFederatesByName
Definition: fedex.h:829
DtFedExec::myPendingSaveFederates
std::set< DtFederateHandle > myPendingSaveFederates
Definition: fedex.h:861
DtFedExec::myCreateFomModules
std::vector< DtString > myCreateFomModules
Definition: fedex.h:842
DtFedExec::myFomModules
std::vector< DtString > myFomModules
Definition: fedex.h:837
DtFedExec::myConnectionMgr
DtConnectionMgr * myConnectionMgr
Definition: fedex.h:822
DtFomModuleRequestMsg
Sent by Federates to request fed file from RtiExec.
Definition: fomModuleRequestMsg.h:28
DtJoinResponseMsg::errorCodes
errorCodes
error codes for the errorValue flag
Definition: joinRespMsg.h:31
DtRestoreRequestMsg
Definition: resReqMsg.h:23
DtReserveNameMsg
Definition: reserveNameMsg.h:25
DtFederate
Definition: federate.h:39
DtFedExec::myFom
DtFomClassMgr * myFom
Definition: fedex.h:844
DtFedExec::myReconnectSucceededCallbacks
DtList myReconnectSucceededCallbacks
Definition: fedex.h:889
DtFomToReadStatusPair
std::pair< DtString, DtFedReadStatus > DtFomToReadStatusPair
Definition: fedex.h:128
DtFedExec::myFomModulesSet
std::set< DtString > myFomModulesSet
Definition: fedex.h:841
DtFedExec::myFedReader1516
DtFedReader1516 * myFedReader1516
Definition: fedex.h:947
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:948
DtFedExec::myUseDestinationMetadata
bool myUseDestinationMetadata
Definition: fedex.h:826
DtFedExec::theCreator
static DtFedExecCreator theCreator
Definition: fedex.h:944
DtFedExec::myFedexFileToFedTgtMap
std::map< const DtString, DtFomClassMgr > myFedexFileToFedTgtMap
Definition: fedex.h:874
DtRestoreCompleteMsg
Definition: resComMsg.h:22
DtFederateCbFn
void(* DtFederateCbFn)(DtFederate *federate, void *usr)
Federate joined/resigned callback prototype.
Definition: fedex.h:109
DtFedExec::myRestoreFederatesByNew
DtFederateHandleInfoMap myRestoreFederatesByNew
Definition: fedex.h:867
DtConnectionMgr
Instances of DtConnectionMgr manage the communication objects that the RTI will use to either communi...
Definition: connectMgr.h:60
DtFederateHandle
DtHandle DtFederateHandle
Definition: internalTypes.h:29
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:853
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:953
DtReleaseMultiNameMsg
Definition: releaseMultiNameMsg.h:25
DtCreateResponseFlag
DtCreateResponseFlag
Definition: creRespMsg.h:23
DtFedExec::mySpRegisterCallbacks
DtList mySpRegisterCallbacks
Definition: fedex.h:893
DtEndRestoreResult
DtEndRestoreResult
Definition: resEndMsg.h:21
DtFomClassMgr
Definition: fomMgr.h:53
DtFedExec::myDisconnectCallbacks
DtList myDisconnectCallbacks
Definition: fedex.h:888
DtFedExec::myFedExHandle
int myFedExHandle
Definition: fedex.h:845
rti1516e::FederateHandleSaveStatusPairVector
std::vector< FederateHandleSaveStatusPair > FederateHandleSaveStatusPairVector
Definition: Typedefs.h:65
DtFedExec::myNumberResponseAttempts
int myNumberResponseAttempts
Response interval from params is divided by this number.
Definition: fedex.h:855
DtFomModuleDistributionMsg
Definition: fomModuleDistributionMsg.h:25
DtFedExec::myFreeFedHandle
int myFreeFedHandle
Definition: fedex.h:824
DtSaveTimeAdvanceMsg
Definition: savTimeAdvMsg.h:21
DtQueryRestoreStatusMsg
Definition: queryRestoreStatusMsg.h:22
DtReserveMultiNameMsg
Definition: reserveMultiNameMsg.h:25
DtFedExec::mySyncList
DtSyncHashlist mySyncList
Definition: fedex.h:832
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:864
DtInitiatedSaveMsg
Definition: initiatedSaveMsg.h:21
DtSaveRequestMsg
Definition: savReqMsg.h:23
DtFedExec::myTakenFiles
std::map< DtString, DtFileInformation * > myTakenFiles
Definition: fedex.h:872
DtFedExec::myFederateReservedNames
DtFedExFederateReservedNameMap myFederateReservedNames
Definition: fedex.h:899
DtRestoreBegunMsg
Definition: resBegMsg.h:28
DtFederateNameInfoMap
std::map< DtString, DtFederate * > DtFederateNameInfoMap
Federate name -&gt; Federate info map.
Definition: fedex.h:124
DtFedExec::myFullyCreated
bool myFullyCreated
Definition: fedex.h:880
DtFedExTakeFileEvent
Definition: distributorThreadEvents.h:238
DtFedExec::myResignCallbacks
DtList myResignCallbacks
Definition: fedex.h:887
DtFedExec::mySaveLabel
DtString mySaveLabel
Definition: fedex.h:863
DtFileToFedTgtPair
std::pair< const DtString, DtFomClassMgr > DtFileToFedTgtPair
Definition: fedex.h:126
DtJoinResponseMsg::DT_NO_ERROR
Definition: joinRespMsg.h:32
DtFedExec::myJoinCallbacks
DtList myJoinCallbacks
Definition: fedex.h:886
DtSyncPointStatus
DtSyncPointStatus
Definition: syncPointMsg.h:36
vlThreadedObject.h
Defines a ThreadedObject which can run a DtRunnable object in a thread.
DtFedExecCreator
DtFedExec *(* DtFedExecCreator)(DtConnectionMgr *connMgr, 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:96
DtFedExec::myFederates
DtFederateHandleInfoMap myFederates
Definition: fedex.h:828
DtFedExec::myReservedNames
DtFedExReservedNameSet myReservedNames
Definition: fedex.h:898
DtSyncPointCbFn
void(* DtSyncPointCbFn)(DtSyncPt *pt, void *usr)
Synchronization point registered/synchronized callback prototype.
Definition: fedex.h:115
DtSyncMsgType
DtSyncMsgType
Definition: syncPointMsg.h:25
DtFedExec::myStrictNameReservation
int myStrictNameReservation
Definition: fedex.h:932
DtRtiApiTime
RTI::FedTime DtRtiApiTime
Typedefs for RTI API types that are frequently require conditional precompile directives.
Definition: rtiApiTypes.h:49
DtSyncPointAchievedCbFn
void(* DtSyncPointAchievedCbFn)(DtFederate *who, DtSyncPt *pt, void *usr)
Synchronization point achieved callback prototype.
Definition: fedex.h:118
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:928
rti1516e::FederateRestoreStatusVector
std::vector< FederateRestoreStatus > FederateRestoreStatusVector
Definition: Typedefs.h:83
DtFederateHandleStdSet
std::set< DtFederateHandle > DtFederateHandleStdSet
Definition: internalTypes.h:30
DtFedExec::myNumFederates
int myNumFederates
Definition: fedex.h:831
DtResignReason
DtResignReason
Definition: resignMsg.h:26
DT_DLL_EXEC
#define DT_DLL_EXEC
Definition: rtiMsConfig.h:123
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:926
DtResignResponse
DtResignResponse
Definition: resignRespMsg.h:12
DtFedExec::mySpAchievedCallbacks
DtList mySpAchievedCallbacks
Definition: fedex.h:892
DtFederateHandleInfoMap
std::map< DtFederateHandle, DtFederate * > DtFederateHandleInfoMap
Federate handle -&gt; Federate info map.
Definition: fedex.h:121
DtFedExec::myJoiningFederates
std::map< DtFederateHandle, DtFedJoinInfo * > myJoiningFederates
List of joining federates for which a join confirm is expected.
Definition: fedex.h:852
DtFedExec::mySave
bool mySave
Definition: fedex.h:859
vrlmod::DtThreadedObject
Definition: vlThreadedObject.h:45
Document ID: Generated on Mon Sep 7 15:40:32 EDT 2020 from SVN revision 217499
Copyright © 2005-2020 MAK Technologies Inc. All Rights Reserved (www.mak.com)