MAK RTIspy API Documentation for HLA 1.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
fedMgr.h
Go to the documentation of this file.
1 /*******************************************************************************
2 ** Copyright (c) 1998 MaK Technologies, Inc.
3 ** All rights reserved.
4 *******************************************************************************/
5 /*******************************************************************************
6 ** $RCSfile: fedMgr.h,v $ $Revision: 1.96 $ $State: Exp $
7 *******************************************************************************/
8 
9 #ifndef fedMgr_H_
10 #define fedMgr_H_
11 
14 
15 #include <mtl/fedReader.h>
16 #include <vlutil/vlPrint.h>
17 #include <vlutil/vlTime.h>
18 #include <vlutil/vlString.h>
19 #include <vlutil/vlList.h>
20 #include <vlutil/vlSmartPointers.h>
21 #include <list>
22 #include "resignMsg.h"
23 #include "resignDirectiveMsg.h"
24 #include "RIDparams.h"
25 #include <mtl/fomSorter.h>
26 
27 #if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
28 #include "RTI/RTIambassador.h"
29 #include "RTI/LogicalTimeFactory.h"
30 #include "RTI/Enums.h"
31 #else
32 #ifdef DtIFSPEC13DLC
33 #include "RTI13.h"
34 #define RTI rti13
35 #else
36 #include "RTI.hh"
37 #endif
38 #endif
39 
40 class DtRtiSaveFile;
41 class DtFomClassMgr;
42 class DtRIDParameters;
43 class DtObjectMgr;
44 class DtInteractionMgr;
45 class DtTimeMgr;
46 class DtDataDistMgr;
47 class DtMomMgr;
48 class DtFederateHandleSet;
49 class DtLogicalTimeFactory;
50 class DtResignMsg;
51 class DtSaveInitiateMsg;
52 class DtSaveResponseMsg;
53 class DtSaveFinishedMsg;
54 class DtRestoreReplyMsg;
55 class DtRestoreInitiateMsg;
56 class DtRestoreEndMsg;
57 class DtRestoreMsg;
58 class DtFederateMgr;
59 class DtFedAmbWrapper;
60 class DtRtiAssistantLrcClient;
61 class DtAssistantExitMsg;
62 class DtAssistantLogEnableMsg;
63 class DtRtiAmbassadorBaseImplementor;
64 class DtTestManager;
65 class DtTestMgrFedAmbWrapper;
66 class DtEnableDisableNetworkTestingMsg;
67 class DtLatencyReportMsg;
68 class DtTestMgrStatusMsg;
69 class DtAssistantFederateSignalTickIntervalMsg;
70 class DtAssistantRidParamsMsg;
71 
83 
84 class DT_DLL_LRC DtFederateMgr
85 {
86 public:
88  typedef DtFederateMgr* (*DtFederateMgrCreator)(
89  DtRIDParameters* ridParams,
90  DtRtiAmbassadorBaseImplementor* ambImplPtr,
91  DtConnectionMgr* connMgr,
92  DtBoost::shared_ptr<DtRtiAssistantLrcClient> assistantClient);
93 
94  // Callback for PostTick
95  typedef void (*DtFedMgrPostTickCallbackFcn) (void*);
96  typedef std::pair< DtFedMgrPostTickCallbackFcn, void* > DtFedMgrPostTickCallbackInfo;
97  typedef std::map< MAKRti::DtString, DtFedMgrPostTickCallbackInfo > DtPostTickCallbackMap;
98  typedef std::map< MAKRti::DtString, DtFomClassMgr* > DtParsedFomsMap;
99  typedef std::map< MAKRti::DtString, std::pair< char*, int > > DtFileNameToDataMap;
100  typedef std::map< DtString, int > DtFomToComplexMap;
101  typedef std::map< DtString, DtString > DtFomNameToFileNameMap;
102  typedef std::map< DtString, DtString > DtFileNameToFomNameMap;
103  typedef std::multimap< int, DtString > DtComplexToFomsMMap;
104 
105 protected:
106 
108  DtFederateMgr(
109  DtRIDParameters* params,
110  DtRtiAmbassadorBaseImplementor* ambImplPtr,
111  DtConnectionMgr* connMgr,
112  DtBoost::shared_ptr<DtRtiAssistantLrcClient> assistantClient);
113 
114 public:
115 
117  virtual ~DtFederateMgr();
118 
119 private:
120 
122  DtFederateMgr(DtFederateMgr const& );
123 
125  DtFederateMgr& operator= (DtFederateMgr const& );
126 
127 public:
128 
130  virtual void createFederationExecution(
131  const char* executionName, const char* timeImplName,
132 #ifdef DtIFSPEC1516E
133  const std::vector<DtString>& fomModules,
134  const char* mimModule) = 0;
135 #else
136  const char* fed) = 0;
137 #endif
138 
140  virtual void destroyFederationExecution (
141  const char* executionName) = 0;
142 
143 #ifdef DtIFSPEC1516E
144  virtual void listFederationExecutions() = 0;
146 #endif
147 
149 #ifdef DtIFSPEC1516
150  virtual rti1516::FederateHandle joinFederationExecution(
151  const char* federateType,
152  const char* federationExecutionName,
153  rti1516::FederateAmbassador* federateAmbassador,
154  unsigned long flags) = 0;
155 #elif defined(DtIFSPEC1516E)
156  virtual rti1516e::FederateHandle joinFederationExecution(
157  const char* federateName,
158  const char* federateType,
159  const char* federationExecutionName,
160  const std::vector<DtString>& fomModules,
161  unsigned long flags) = 0;
162 #else
163  virtual RTI::FederateHandle joinFederationExecution (
164  const char* yourName,
165  const char* executionName,
166  RTI::FederateAmbassador* federateAmbassadorReference,
167  unsigned long flags) = 0;
168 #endif
169 
171 #ifdef DtIFSPEC1516
172  virtual void resignFederationExecution(
173  rti1516::ResignAction theAction);
174 #elif defined(DtIFSPEC1516E)
175  virtual void resignFederationExecution(
176  rti1516e::ResignAction theAction);
177 #else
178  virtual void resignFederationExecution(
179  RTI::ResignAction theAction);
180 #endif
181 
184  virtual bool automaticReserveObjectName(const char *);
185 
187 #ifdef DtIFSPEC1516
188  virtual void registerFederationSynchronizationPoint(
189  const char* label,
190  rti1516::VariableLengthData const & theTag) = 0;
191 #elif defined(DtIFSPEC1516E)
192  virtual void registerFederationSynchronizationPoint(
193  const char* label,
194  rti1516e::VariableLengthData const & theTag) = 0;
195 #else
196  virtual void registerFederationSynchronizationPoint(
197  const char* label,
198  const char* theTag) = 0;
199 #endif
200 
202  virtual void waitForResignResponse(bool serviceCall = true);
203 
205  virtual void waitForReserveNameResponse(bool serviceCall = true);
206 
208 #ifdef DtIFSPEC1516
209  virtual void registerFederationSynchronizationPoint(
210  const char* label,
211  rti1516::VariableLengthData const & theTag,
212  DtFederateHandleSet const& syncSet) = 0;
213 #elif defined(DtIFSPEC1516E)
214  virtual void registerFederationSynchronizationPoint(
215  const char* label,
216  rti1516e::VariableLengthData const & theTag,
217  DtFederateHandleSet const& syncSet) = 0;
218 #else
219  virtual void registerFederationSynchronizationPoint(
220  const char* label,
221  const char* theTag,
222  DtFederateHandleSet const& syncSet) = 0;
223 #endif
224 
226  virtual void synchronizationPointAchieved(const char* label, bool successfully=true) = 0;
227 
231  virtual MAKRti::DtString fedFileName(MAKRti::DtString execName);
232 
236  virtual MAKRti::DtString timeImplName(MAKRti::DtString execName);
237 
239  virtual void init();
240 
242 
243 #ifdef DtIFSPEC1516
244  virtual void setTopLevelAmbassador(rti1516::RTIambassador* ambPtr);
245 #elif defined(DtIFSPEC1516E)
246  virtual void setTopLevelAmbassador(rti1516e::RTIambassador* ambPtr,
247  rti1516e::FederateAmbassador* federateAmbassador);
248 #else
249  virtual void setTopLevelAmbassador(RTI::RTIambassador* ambPtr);
250 #endif
251 
252 
254  virtual bool tick();
255  virtual void pretick();
256  virtual void posttick();
257 
258  virtual void postTickCallbacks();
259 
260  virtual void addPostTickCallback(const MAKRti::DtString& label, const DtFedMgrPostTickCallbackInfo& cb);
261  virtual void removePostTickCallback(const MAKRti::DtString& label);
262 
263 #ifdef DtIFSPEC1516
264  virtual void requestFederationSave ( const char *label,
266  const rti1516::LogicalTime* time=NULL) =0;
267 
269  virtual void queryFederationSaveStatus()=0;
270 
272  virtual void queryFederationRestoreStatus()=0;
273 #elif defined(DtIFSPEC1516E)
274  virtual void requestFederationSave ( const char *label,
276  const rti1516e::LogicalTime* time=NULL) =0;
277 
279  virtual void queryFederationSaveStatus()=0;
280 
282  virtual void queryFederationRestoreStatus()=0;
283 
285  virtual void abortFederationSave () =0;
286 
288  virtual void abortFederationRestore () =0;
289 #else
290  virtual void requestFederationSave ( const char *label,
292  const RTI::FedTime* time=NULL) =0;
293 #endif
294 
296  virtual void federateSaveBegun () =0;
297 
299  virtual void federateSaveComplete () =0;
300 
302  virtual void federateSaveNotComplete () =0;
303 
305  virtual void requestFederationRestore ( const char *label) =0;
306 
308  virtual void federateRestoreComplete () =0;
309 
311  virtual void federateRestoreNotComplete () =0;
312 
314  virtual char* getTransportationName(MAKRti::DtTransportType transport);
315 
317  virtual char* getOrderName(MAKRti::DtOrderType order);
318 
320  virtual MAKRti::DtTransportType getTransportationHandle(MAKRti::DtString transport);
321 
323  virtual MAKRti::DtOrderType getOrderHandle(MAKRti::DtString order);
324 
326  virtual DtFederateHandle federateHandle() const;
327 
329  virtual MAKRti::DtString const & fedType() const;
330 
332  virtual MAKRti::DtString const & fedName() const;
333 
335  virtual MAKRti::DtString const & fedExName() const;
336 
338  virtual unsigned long fedExHandle() const;
339 
341  virtual bool isJoined() const;
342 
344 
345 #ifdef DtIFSPEC1516
346  rti1516::RTIambassador* rtiAmb();
347  rti1516::RTIambassador* rtiAmb() const;
348 #elif defined(DtIFSPEC1516E)
349  rti1516e::RTIambassador* rtiAmb();
350  rti1516e::RTIambassador* rtiAmb() const;
351 #else
352  RTI::RTIambassador* rtiAmb();
353  RTI::RTIambassador* rtiAmb() const;
354 #endif
355 
356 
358 
359 #ifdef DtIFSPEC1516
360  virtual rti1516::FederateAmbassador * federateAmbassador() const;
361 #elif defined(DtIFSPEC1516E)
362  virtual rti1516e::FederateAmbassador * federateAmbassador() const;
363 #else
364  virtual RTI::FederateAmbassador * federateAmbassador() const;
365 #endif
366 
367 
369  virtual DtConnectionMgr* connectMgr();
370  virtual DtConnectionMgr* connectMgr() const;
371 
373  virtual DtRIDParameters* params();
374  virtual DtRIDParameters* params() const;
375 
377  virtual DtFomClassMgr* fom();
378  virtual DtFomClassMgr* fom() const;
379 
381  virtual DtInteractionMgr* interMgr();
382  virtual DtInteractionMgr* interMgr() const;
383 
385  virtual DtTestManager* testMgr();
386  virtual DtTestManager* testMgr() const;
387 
389  virtual DtObjectMgr* objMgr();
390  virtual DtObjectMgr* objMgr() const;
391 
392 #ifdef DtTIME
393  virtual DtTimeMgr* timeMgr();
395  virtual DtTimeMgr* timeMgr() const;
396 #endif
397 
399  virtual DtLogicalTimeFactory* timeFactory();
400  virtual DtLogicalTimeFactory* timeFactory() const;
401 
402 #ifdef DtMOM
403  virtual DtMomMgr* momMgr();
405  virtual DtMomMgr* momMgr() const;
406 #endif
407 
408 #ifdef DDM
409  virtual DtDataDistMgr* ddmMgr();
411  virtual DtDataDistMgr* ddmMgr() const;
412 #endif
413 
415  virtual DtRtiAssistantLrcClient* assistantClient();
416  virtual DtRtiAssistantLrcClient* assistantClient() const;
417 
419  virtual bool isJoinedFederate(DtFederateHandle federateHandleValue) const;
420 
422  virtual bool forcedToResign() const;
423 
425  virtual void setMomResign();
426 
428  virtual void resetMomResign();
429 
431  virtual bool saveInitiated() const;
432 
434  virtual bool saveBegun() const;
435 
437  virtual bool restoreRequested() const;
438 
440  virtual bool restoreInitiated() const;
441 
443  virtual bool restoreBegun() const;
444 
446  virtual const MAKRti::DtString& restoreLabel() const;
447 
449  virtual const MAKRti::DtString& lastRestoreLabel() const;
450 
452  const MAKRti::DtString& currentFedFileName() const;
453  void setCurrentFedFileName( const MAKRti::DtString& );
454 
456  const MAKRti::DtString& mimName() const;
457  void setMimName( const MAKRti::DtString& );
458 
459 #ifdef DtIFSPEC1516E
460  void addFomModule( const MAKRti::DtString& name, char* buffer );
462 
464  const std::vector<std::wstring>& fomModuleNames() const;
465 
467  void addJoinFomModuleNames(const std::vector<MAKRti::DtString>& moduleNames);
468  const std::vector<std::wstring>& joinFomModuleNames() const;
469 
472  const char* fomModuleData(MAKRti::DtU32 moduleIndicator) const;
473 
476  const char* joinFomModuleData(MAKRti::DtU32 moduleIndicator) const;
477 
479  const char* mimData() const;
480 #endif
481 
483  const MAKRti::DtString& currentTimeImplName() const;
484  void setCurrentTimeImplName( const MAKRti::DtString& );
485 
487  virtual const MAKRti::DtString& saveLabel() const;
488  virtual void setSaveLabel(const MAKRti::DtString& value);
489 
491  virtual const MAKRti::DtString& lastSaveLabel() const;
492  virtual void setLastSaveLabel(const MAKRti::DtString& value);
493 
494 
496  virtual void testSaveProgress() = 0;
497 
500  virtual void initiateSave();
501 
504 #ifdef DtIFSPEC1516
505  virtual void initiateTimedSave(rti1516::LogicalTime const& saveTime);
506 #elif defined(DtIFSPEC1516E)
507  virtual void initiateTimedSave(rti1516e::LogicalTime const& saveTime);
508 #else
509  virtual void initiateTimedSave(RTI::FedTime const& saveTime);
510 #endif
511 
513  virtual bool save( DtRtiSaveFile& file ){ return true;};
514 
516  virtual bool restore( DtRtiSaveFile& file ){ return true;};
517 
523  virtual MAKRti::DtString& getSaveFileName(const char* label,
524  DtFederateHandle fedHandle, MAKRti::DtString& fileName,
525  bool extendName=true);
526 
532  virtual MAKRti::DtString& getRestoreFileName(const char* label,
533  DtFederateHandle fedHandle, MAKRti::DtString& fileName);
534 
536  virtual unsigned long tickCount() const;
537 
539  virtual bool isTicking() const;
540 
542  virtual void reportLatencyTestResults( const DtLatencyReportMsg& msg );
543 
545  virtual void reportLatencyTestStatus( const DtTestMgrStatusMsg& msg );
546 
547  unsigned long flags() const;
548 
549  DtResignAction automaticResignDirective() const;
550 
551 #ifdef DtIFSPEC1516E
552  virtual rti1516e::ResignAction getAutomaticResignDirective() const;
553 
556  virtual void setAutomaticResignDirective( const rti1516e::ResignAction action );
557 #endif
558 
560  virtual const MAKRti::DtString& getFederateNameFromHandle( DtFederateHandle handle );
561  virtual DtFederateHandle getFederateHandleFromName( const MAKRti::DtString& name );
562 
563 public:
564 
571  static DtFederateMgr* create(
572  DtRIDParameters* params,
573  DtRtiAmbassadorBaseImplementor* ambImplPtr,
574  DtConnectionMgr* connMgr,
575  DtBoost::shared_ptr<DtRtiAssistantLrcClient> assistantClient);
576 
579  static void setCreatorFunction(DtFederateMgrCreator fn);
580 
585  static void setInternalCreatorFunction(DtFederateMgrCreator fn);
586 
587 protected:
588 
592 
593 
595  virtual void processResign(const DtResignMsg& msg);
596 
598  virtual void processEnableDisableNetworkTesting( const DtEnableDisableNetworkTestingMsg& msg );
599 
601  virtual void processSaveInitiate(const DtSaveInitiateMsg& msg);
602 
604  virtual void processSaveResponse(const DtSaveResponseMsg& msg);
605 
607  virtual void processSaveFinished(const DtSaveFinishedMsg& msg);
608 
610  virtual void processRestoreReply(const DtRestoreReplyMsg& msg);
611 
613  virtual void processRestoreInitiate(const DtRestoreInitiateMsg& msg);
614 
616  virtual void processRestoreEnd(const DtRestoreEndMsg& msg);
617 
619  virtual void processRestore(const DtRestoreMsg& msg);
621 
625 
626  virtual void processAssistantResign(const DtAssistantExitMsg& msg);
628 
630  virtual void processAssistantEnableLogging(const DtAssistantLogEnableMsg& msg);
631 
633  virtual void processSignalTickInterval( const DtAssistantFederateSignalTickIntervalMsg& msg );
634 
636  virtual void processRidParamRequest( const DtAssistantRidParamsMsg& msg );
638 
639 #ifdef DtIFSPEC1516E
640  virtual void processResignDirective( const DtResignDirectiveMsg& msg );
642 #endif
643 
645  virtual void sendAlive();
646 
648  virtual void sendResignMsg(const char* fedExName,
649  DtFederateHandle fedHandle, DtResignAction action);
650 
652  void sendTickedMsg();
653 
655  virtual void applyRidParameters();
656 
661  virtual MAKRti::DtFilename fedFileNameToUse(MAKRti::DtString fileName, MAKRti::DtString executionName );
662 
663  //Add comments to each later
664  virtual int mapFomDepComplexity(DtString fomFileName);
665 
666  virtual void mapFomNameToFileName(std::vector<DtString>* fomFileNames);
667 
668  virtual void sortFomFileNames(std::vector<DtString>* fomFileNames);
669 
671  virtual void testReadFedFile(MAKRti::DtString fileName, MAKRti::DtString executionName);
672 
675  virtual void readFedFile(MAKRti::DtString fileName, MAKRti::DtString executionName);
676 
679  virtual void readFedFilePtr( const FILE* fp,
680  const MAKRti::DtString& fileName,
681  const MAKRti::DtString& executionName );
682 
685  virtual void addFedExNameMapping(const MAKRti::DtString& execName,
686  const MAKRti::DtString& timeImplName, const MAKRti::DtString& fed);
687 
688  virtual void addFomModuleNameMapping( const MAKRti::DtString executionName,
689  const std::vector<MAKRti::DtString>& modules);
690 
691  virtual void addFomModuleNameMapping( const MAKRti::DtString executionName,
692  const MAKRti::DtString& modules );
693 
695 #ifdef DtIFSPEC1516
696  virtual DtResignAction testResign(rti1516::ResignAction theAction);
697 #elif defined(DtIFSPEC1516E)
698  virtual DtResignAction testResign(rti1516e::ResignAction theAction);
699 #else
700  virtual DtResignAction testResign(RTI::ResignAction theAction);
701 #endif
702 
705  virtual void postJoinInit(
706  const char* federateType,
707  const char* executionName,
708  const char* federateName
709 #ifdef DtIFSPEC1516
710  , rti1516::FederateAmbassador* federateAmbassadorReference);
711 #elif defined(DtIFSPEC1516E)
712  );
713 #else
714  , RTI::FederateAmbassador* federateAmbassadorReference);
715 #endif
716 
717  virtual void postJoinConfirmInit();
718 
719 protected:
720 
724 
725 
727  static void processResign(const DtResignMsg& msg, void* usr);
728 
730  static void processEnableDisableNetworkTesting(const DtEnableDisableNetworkTestingMsg& msg, void* usr );
731 
733  static void processSaveInitiate(const DtSaveInitiateMsg& msg, void* usr);
734 
736  static void processSaveResponse(const DtSaveResponseMsg& msg, void* usr);
737 
739  static void processSaveFinished(const DtSaveFinishedMsg& msg, void* usr);
740 
742  static void processRestoreReply(const DtRestoreReplyMsg& msg, void* usr);
743 
745  static void processRestore(const DtRestoreMsg& msg, void* usr);
746 
748  static void processRestoreInitiate(const DtRestoreInitiateMsg& msg,
749  void* usr);
750 
752  static void processRestoreEnd(const DtRestoreEndMsg& msg, void* usr);
754 
755 
759 
760  static void processAssistantResign(const DtAssistantExitMsg& msg, void* usr);
762 
764  static void processAssistantEnableLogging(const DtAssistantLogEnableMsg& msg, void* usr);
765 
767  static void processSignalTickInterval( const DtAssistantFederateSignalTickIntervalMsg& msg, void* usr );
768 
770  static void processRidParamRequest( const DtAssistantRidParamsMsg& msg, void* usr );
772 
773 #ifdef DtIFSPEC1516E
774  static void processResignDirective( const DtResignDirectiveMsg& msg, void* usr );
776 #endif
777 
780 
781 
783  virtual void createObjectMgr();
784 
786  virtual void createInteractionMgr();
787 
789  virtual void createDdmMgr();
790 
792  virtual void createTimeMgr();
793 
795  virtual void createMomMgr();
796 
798  virtual void createTestMgr();
799 
801 
802 #ifdef DtIFSPEC1516
803  virtual MAKRti::DtResignAction convertResignAction(rti1516::ResignAction) const;
804  virtual rti1516::ResignAction convertResignAction(MAKRti::DtResignAction) const;
805 #elif defined(DtIFSPEC1516E)
806  virtual MAKRti::DtResignAction convertResignAction(rti1516e::ResignAction) const;
807  virtual rti1516e::ResignAction convertResignAction(MAKRti::DtResignAction) const;
808 #else
809  virtual MAKRti::DtResignAction convertResignAction(RTI::ResignAction) const;
810  virtual RTI::ResignAction convertResignAction(MAKRti::DtResignAction) const;
811 #endif
812 
813 public:
814 
815  //In order to correctly stop evokeCallback we need to know what has reached a
816  //federate Ambassador. So we are puttling this boolean here in order to do that
817  //Accessors should be made once we know this works.
818  bool myFedCallbackReached;
819 
820 protected:
821 
822  DtFedReader * getReader( DtFomType theFomType, DtFomClassMgr* target);
823  DtFedReader * getReader( DtFomType theFomType );
824  void addToParsedFomMap( DtFedReader * myFedReader, const MAKRti::DtString & fileNameToUse, DtFomClassMgr* fedTarget, unsigned long theCrc = 0);
825 
827 #ifdef DtIFSPEC1516
828  rti1516::RTIambassador* myRtiAmb;
829 #elif defined(DtIFSPEC1516E)
830  rti1516e::RTIambassador* myRtiAmb;
831 #else
832  RTI::RTIambassador* myRtiAmb;
833 #endif
834 
836  DtRtiAmbassadorBaseImplementor* myAmbImpl;
837 
840 
841 
843  DtConnectionMgr* myConnectMgr;
844 
846  DtFomClassMgr* myFom;
847 
849  DtInteractionMgr* myInterMgr;
850 
852  DtObjectMgr* myObjMgr;
853 
855  DtMomMgr* myMomMgr;
856 
857 #ifdef DDM
858  DtDataDistMgr* myDdmMgr;
860 #endif
861 #ifdef DtTIME
862  DtTimeMgr* myTimeMgr;
864 #endif
865 
866 
868  MAKRti::DtTime myResponseInterval;
869 
871  MAKRti::DtString myFedExName;
872 
874  unsigned long myFedExHandle;
875 
877  MAKRti::DtString myFedType;
878 
881  MAKRti::DtString myFedName;
882 
884  DtFederateHandle myFedHandle;
885 
887  MAKRti::DtString myCurrentFedFileName;
888 
890  MAKRti::DtString myMimName;
891 
893  MAKRti::DtString myCurrentTimeImplName;
894 
895 #ifdef DtIFSPEC1516E
896  std::vector<std::wstring> myFomModulesNames;
898  std::vector<std::wstring> myJoinFomModulesNames;
899  std::vector<char*> myFomModuleData;
900  unsigned myMimIndex;
901 #endif
902 
904  MAKRti::DtTime myLastHeartbeat;
905 
908  DtLogicalTimeFactory* myLogicalTimeFactory;
909 #if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
910 #else
911  RTI::FedTimeFactory myHlaTimeFactory;
912 #endif
913 
915  DtFedAmbWrapper* myPrinter;
916 
918  DtFedAmbWrapper* myFedAmbCatch;
919 
920 
922  DtRIDParameters* myParams;
923 
925  DtFedReader * myFedReader;
926  DtFedReader * myFedReader13;
927  DtFedReader * myFedReader1516;
928  DtFedReader * myFedReader1516e;
929 
933  MAKRti::DtList myMappingList;
934 
935  std::map<MAKRti::DtString, std::set<MAKRti::DtString> > myFedFileNames;
936 
938  DtParsedFomsMap myParsedFoms;
939 
940 #ifdef DtIFSPEC1516E
941  DtFileNameToDataMap myParsedFomModuleData;
943 #endif
944 
945  // make this FOM dependency, not DtString
946  DtComplexToFomsMMap myComplexToFomsMMap;
947  typedef std::pair<int, DtString> DtMMapPair;
948 
949  DtFomToComplexMap myFomToComplexMap;
950  typedef std::pair<DtString, int> DtFomCompPair;
951 
952  DtFomNameToFileNameMap myFomToFileMap;
953  typedef std::pair<DtString, DtString> DtFomFilePair;
954 
955  DtFileNameToFomNameMap myFileToFomMap;
956  typedef std::pair<DtString, DtString> DtFileFomPair;
957 
959  DtBoost::shared_ptr<DtRtiAssistantLrcClient> myAssistantClient;
960 
963 
964 
966  bool mySaveInitiated;
968  bool mySaveBegun;
970  bool myRestoreRequested;
972  bool myRestoreInitiated;
974  bool myRestoreBegun;
976  MAKRti::DtString mySaveLabel;
978  MAKRti::DtString myLastSaveLabel;
980  MAKRti::DtString myRestoreLabel;
982  MAKRti::DtString myLastRestoreLabel;
984 
986  bool myIgnoreForcedResign;
987 
989  bool myForcedToResign;
990 
992  bool myMomResign;
993 
995  bool myMomSaveEvokeCallbacks;
996 
998  bool myResignInProgress;
999 
1001  MAKRti::DtClock myClock;
1002 
1004  unsigned long myTickCount;
1005 
1007  bool myIsTicking;
1008 
1010  bool myEnableFederateHeartbeat;
1011 
1012  unsigned long myFlags;
1013 
1014  DtTestManager* myTestMgr;
1015  bool myNetworkTestEnabled;
1016 
1018  float mySignalTickInterval;
1019 
1021  DtTime myLastTickTime;
1022 
1023  DtPostTickCallbackMap myPostTickCallbacks;
1024 
1025  MAKRti::DtFilename myStandardMimPath;
1026 
1027  // our list of Federate Names to Handles and vise-versa
1028  std::map< MAKRti::DtString, DtFederateHandle > myFederateNameToHandle;
1029  std::map< DtFederateHandle, MAKRti::DtString > myFederateHandleToName;
1030 
1032  MAKRti::DtResignAction myResignAction;
1033 
1034  DtFomSorter myFomSorter;
1035 
1036 protected:
1038  static DtFederateMgrCreator theCreator;
1039 
1041  static DtFederateMgrCreator theInternalCreator;
1042 };
1043 
1044 #endif
1045 
1046 
1047 
DtFederateMgr::myFedReader
DtFedReader * myFedReader
Temporary internal reader used until changes made to VR-Link fed reader.
Definition: fedMgr.h:925
DtFederateMgr::DtFedMgrPostTickCallbackInfo
std::pair< DtFedMgrPostTickCallbackFcn, void * > DtFedMgrPostTickCallbackInfo
Definition: fedMgr.h:96
tick
virtual Boolean tick(TickTime minimum, TickTime maximum)
federateSaveNotComplete
virtual void federateSaveNotComplete()
DtFederateMgr::myAmbImpl
DtRtiAmbassadorBaseImplementor * myAmbImpl
The federate&#39;s RTI Ambassador Implementor.
Definition: fedMgr.h:836
DtFederateMgr::DtFileNameToFomNameMap
std::map< DtString, DtString > DtFileNameToFomNameMap
Definition: fedMgr.h:102
DtFederateMgr::myFedName
MAKRti::DtString myFedName
Federate name.
Definition: fedMgr.h:881
DtRtiAmbassadorBaseImplementor
This class is a base for the protocol specific DtRtiAmbassadorImplementor class.
Definition: ambImpBase.h:49
DtSaveFinishedMsg
Definition: savFinMsg.h:32
DtFederateMgr::myParams
DtRIDParameters * myParams
Initialization data.
Definition: fedMgr.h:922
DtFederateMgr::myCurrentTimeImplName
MAKRti::DtString myCurrentTimeImplName
Current time implementation name.
Definition: fedMgr.h:893
DtFederateMgr::DtComplexToFomsMMap
std::multimap< int, DtString > DtComplexToFomsMMap
Definition: fedMgr.h:103
requestFederationRestore
virtual void requestFederationRestore(const char *label)
DtFederateMgr::DtFomToComplexMap
std::map< DtString, int > DtFomToComplexMap
Definition: fedMgr.h:100
RIDparams.h
DtFederateMgr::myFom
DtFomClassMgr * myFom
The FOM manager.
Definition: fedMgr.h:846
RTI13.h
DtSaveResponseMsg
Definition: savRespMsg.h:29
DtFederateMgr::restore
virtual bool restore(DtRtiSaveFile &file)
Perform the actual restore.
Definition: fedMgr.h:516
DtTestMgrStatusMsg
The DtTestMgrStatusMsg defines a msg for a client to report the results of a latency test...
Definition: testMgrStatusMsg.h:36
rti13::ResignAction
ResignAction
Definition: RTItypes13.h:89
DtFederateMgr::myFileToFomMap
DtFileNameToFomNameMap myFileToFomMap
Definition: fedMgr.h:955
DtAssistantLogEnableMsg
The DtAssistantLogEnableMsg defines a wrapper for the RTI Assistant logging enable message used by th...
Definition: assistantLogEnableMsg.h:31
DtFederateMgr::DtFileFomPair
std::pair< DtString, DtString > DtFileFomPair
Definition: fedMgr.h:956
DtFederateMgr::myFedFileNames
std::map< MAKRti::DtString, std::set< MAKRti::DtString > > myFedFileNames
Definition: fedMgr.h:935
DtFederateMgr::myParsedFoms
DtParsedFomsMap myParsedFoms
Map containing FOMs parsed into FedTargets.
Definition: fedMgr.h:938
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
DtFederateMgr::myFedAmbCatch
DtFedAmbWrapper * myFedAmbCatch
Catches exceptions from federate ambassador calls.
Definition: fedMgr.h:918
DtFederateMgr::myMomSaveEvokeCallbacks
bool myMomSaveEvokeCallbacks
State of evoking callbacks prior to MOM resign.
Definition: fedMgr.h:995
DtFederateMgr::myInterMgr
DtInteractionMgr * myInterMgr
The interaction manager.
Definition: fedMgr.h:849
DtAssistantFederateSignalTickIntervalMsg
Definition: assistantFederateSignalIntervalMsg.h:27
DtRtiAssistantLrcClient
The client connection to the RTI Assistant for an LRC.
Definition: rtiAssistantLrcClient.h:32
DtFederateMgr::DtPostTickCallbackMap
std::map< MAKRti::DtString, DtFedMgrPostTickCallbackInfo > DtPostTickCallbackMap
Definition: fedMgr.h:97
rti1516e::RTIambassador
A class provided by the HLA C++ Interface Specification which federates use to communicate with the R...
DtFederateMgr::myFedCallbackReached
bool myFedCallbackReached
Definition: fedMgr.h:818
DtFederateMgr::myAssistantClient
DtBoost::shared_ptr< DtRtiAssistantLrcClient > myAssistantClient
Manages the connection to the RTI Assistant.
Definition: fedMgr.h:959
DtFederateHandleSet
Definition: fedHandleSet.h:102
DtFederateMgr::myFedExHandle
unsigned long myFedExHandle
Federation handle.
Definition: fedMgr.h:874
DtFederateMgr::myFomToFileMap
DtFomNameToFileNameMap myFomToFileMap
Definition: fedMgr.h:952
DtResignMsg
Definition: resignMsg.h:36
DtResignDirectiveMsg
Definition: resignDirectiveMsg.h:24
requestFederationSave
virtual void requestFederationSave(const char *label, const FedTime &theTime)
DtFederateMgr::DtFomFilePair
std::pair< DtString, DtString > DtFomFilePair
Definition: fedMgr.h:953
DtFederateMgr::myLastTickTime
DtTime myLastTickTime
The last tick time.
Definition: fedMgr.h:1021
DtFederateMgr::myFedReader1516e
DtFedReader * myFedReader1516e
Definition: fedMgr.h:928
joinFederationExecution
virtual FederateHandle joinFederationExecution(const char *yourName, const char *executionName, FederateAmbassadorPtr federateAmbassadorReference)
DtFederateMgr::DtFileNameToDataMap
std::map< MAKRti::DtString, std::pair< char *, int > > DtFileNameToDataMap
Definition: fedMgr.h:99
DtFederateMgr::myMomResign
bool myMomResign
Indicates MOM caused resign.
Definition: fedMgr.h:992
DtTestMgrFedAmbWrapper
DtTestMgrFedAmbWrapper is installed by the testManager and serves to catch testInteraction messages f...
Definition: testMgrFedAmbWrapper.h:42
DtFederateMgr::DtMMapPair
std::pair< int, DtString > DtMMapPair
Definition: fedMgr.h:947
DtFederateMgr::myTickCount
unsigned long myTickCount
Tick counter.
Definition: fedMgr.h:1004
DtFederateMgr::DtFomNameToFileNameMap
std::map< DtString, DtString > DtFomNameToFileNameMap
Definition: fedMgr.h:101
DtFederateMgr::myFedReader13
DtFedReader * myFedReader13
Definition: fedMgr.h:926
DtFederateMgr::myFedType
MAKRti::DtString myFedType
Federate type.
Definition: fedMgr.h:877
DtFederateMgr
Instances of DtFederateMgr process federation-level messages (such as create, destroy, join, resign, and sync points) and manages the objects responsible for handling general communication, objects, interactions, the FOM, MOM, and data distribution mmg.
Definition: fedMgr.h:84
DtFederateMgr::myRestoreRequested
bool myRestoreRequested
Indicates restore requested.
Definition: fedMgr.h:970
NULL
#define NULL
Definition: baseTypes13.h:8
DtFederateMgr::mySaveBegun
bool mySaveBegun
Indicates save begun.
Definition: fedMgr.h:968
DtFederateMgr::myLogicalTimeFactory
DtLogicalTimeFactory * myLogicalTimeFactory
Logical time factory Even if NULL, need to have this factory.
Definition: fedMgr.h:908
resignFederationExecution
virtual void resignFederationExecution(ResignAction theAction)
DtFederateMgr::myIsTicking
bool myIsTicking
indicates currently processing tick
Definition: fedMgr.h:1007
federateRestoreComplete
virtual void federateRestoreComplete()
DtFederateMgr::myConnectMgr
DtConnectionMgr * myConnectMgr
The connection manager.
Definition: fedMgr.h:843
DtLatencyReportMsg
The DtLatencyReportMsg defines a msg for a client to report the results of a latency test...
Definition: latencyReportMsg.h:37
DtConnectionMgr
Instances of DtConnectionMgr manage the communication objects that the RTI will use to either communi...
Definition: connectMgr.h:60
DtFederateMgr::theInternalCreator
static DtFederateMgrCreator theInternalCreator
The internal creator.
Definition: fedMgr.h:1041
DtFederateMgr::myLastHeartbeat
MAKRti::DtTime myLastHeartbeat
Time of last heartbeat.
Definition: fedMgr.h:904
DtInteractionMgr
Instances of DtInteractionMgr manage the sending and receiving of interactions.
Definition: interMgr.h:45
DtFederateMgr::myRestoreInitiated
bool myRestoreInitiated
Indicates restore initiated.
Definition: fedMgr.h:972
DtFederateHandle
DtHandle DtFederateHandle
Definition: internalTypes.h:29
DtRestoreEndMsg
Definition: resEndMsg.h:31
destroyFederationExecution
virtual void destroyFederationExecution(const char *executionName)
DtEnableDisableNetworkTestingMsg
This class defines a message sent between the exec and the assistant that enables and disables networ...
Definition: enableDisableNetworkTestingMsg.h:25
DtFederateMgr::myFomToComplexMap
DtFomToComplexMap myFomToComplexMap
Definition: fedMgr.h:949
DtFederateMgr::myComplexToFomsMMap
DtComplexToFomsMMap myComplexToFomsMMap
Definition: fedMgr.h:946
registerFederationSynchronizationPoint
virtual void registerFederationSynchronizationPoint(const char *label, const char *theTag)
DtFederateMgr::myMimName
MAKRti::DtString myMimName
MIM name.
Definition: fedMgr.h:890
DtFomClassMgr
Definition: fomMgr.h:53
DtFederateMgr::myFlags
unsigned long myFlags
Definition: fedMgr.h:1012
DtFederateMgr::myIgnoreForcedResign
bool myIgnoreForcedResign
Prevents forcing duplicate resign.
Definition: fedMgr.h:986
DtFederateMgr::myFedHandle
DtFederateHandle myFedHandle
Federate handle.
Definition: fedMgr.h:884
DtFederateMgr::myRestoreBegun
bool myRestoreBegun
Indicates restore begun.
Definition: fedMgr.h:974
DtFederateMgr::mySignalTickInterval
float mySignalTickInterval
The Signal Tick Interval.
Definition: fedMgr.h:1018
DtFederateMgr::myResignInProgress
bool myResignInProgress
Indicates a resign is in progress.
Definition: fedMgr.h:998
DtRestoreMsg
Definition: restoreMsg.h:23
DtObjectMgr
The object manager class processes the object management services.
Definition: objMgr.h:90
DtFederateMgr::myMomMgr
DtMomMgr * myMomMgr
The MOM manager.
Definition: fedMgr.h:855
DtFederateMgr::myStandardMimPath
MAKRti::DtFilename myStandardMimPath
Definition: fedMgr.h:1025
DtAssistantRidParamsMsg
The DtAssistantRidParamsMsg defines a wrapper for the RTI Assistant RID parameter message used by the...
Definition: assistantRidParamsMsg.h:33
DtFederateMgr::myLastRestoreLabel
MAKRti::DtString myLastRestoreLabel
The last restore label.
Definition: fedMgr.h:982
DtFederateMgr::myFedReader1516
DtFedReader * myFedReader1516
Definition: fedMgr.h:927
federateRestoreNotComplete
virtual void federateRestoreNotComplete()
createFederationExecution
virtual void createFederationExecution(const char *executionName, const char *FED)
DtFederateMgr::myFederateHandleToName
std::map< DtFederateHandle, MAKRti::DtString > myFederateHandleToName
Definition: fedMgr.h:1029
DtFederateMgr::myHlaTimeFactory
RTI::FedTimeFactory myHlaTimeFactory
Definition: fedMgr.h:911
DtFederateMgr::myRtiAmb
RTI::RTIambassador * myRtiAmb
The federate&#39;s RTI Ambassador.
Definition: fedMgr.h:832
DtFederateMgr::myObjMgr
DtObjectMgr * myObjMgr
The object manager.
Definition: fedMgr.h:852
DtFederateMgr::myResponseInterval
MAKRti::DtTime myResponseInterval
Interval to wait for response message during a message protocol.
Definition: fedMgr.h:868
federateSaveBegun
virtual void federateSaveBegun()
rti13::FederateHandle
ULong FederateHandle
Definition: RTItypes13.h:120
DtFederateMgr::DtFomCompPair
std::pair< DtString, int > DtFomCompPair
Definition: fedMgr.h:950
DtRestoreReplyMsg
Definition: resRepMsg.h:24
DtAssistantExitMsg
The DtAssistantExitMsg defines a wrapper for the RTI Assistant exit message used by the Assistant to ...
Definition: assistantExitMsg.h:32
DtFederateMgr::myFomSorter
DtFomSorter myFomSorter
Definition: fedMgr.h:1034
DtFederateMgr::myLastSaveLabel
MAKRti::DtString myLastSaveLabel
The last save label.
Definition: fedMgr.h:978
synchronizationPointAchieved
virtual void synchronizationPointAchieved(const char *label)
DtFederateMgr::myFederateNameToHandle
std::map< MAKRti::DtString, DtFederateHandle > myFederateNameToHandle
Definition: fedMgr.h:1028
DtFederateMgr::DtParsedFomsMap
std::map< MAKRti::DtString, DtFomClassMgr * > DtParsedFomsMap
Definition: fedMgr.h:98
rti1516e::FederateAmbassador
An abstract base class which must be implemented, and used by a federate.
DtFederateMgr::myMappingList
MAKRti::DtList myMappingList
List of federation execution names with FED files names and time implementation names.
Definition: fedMgr.h:933
DtFederateMgr::myCurrentFedFileName
MAKRti::DtString myCurrentFedFileName
Current FED/FDD file name.
Definition: fedMgr.h:887
getTransportationHandle
virtual TransportationHandle getTransportationHandle(const char *theName)
DtFederateMgr::save
virtual bool save(DtRtiSaveFile &file)
Perform the actual save.
Definition: fedMgr.h:513
DT_DLL_LRC
#define DT_DLL_LRC
Definition: rtiMsConfig.h:126
DtFederateMgr::myFedExName
MAKRti::DtString myFedExName
Federation execution name.
Definition: fedMgr.h:871
DtRtiSaveFile
Definition: saveFile.h:21
DtFederateMgr::mySaveLabel
MAKRti::DtString mySaveLabel
The save label.
Definition: fedMgr.h:976
DtFederateMgr::myTestMgr
DtTestManager * myTestMgr
Definition: fedMgr.h:1014
federateSaveComplete
virtual void federateSaveComplete()
DtFederateMgr::myForcedToResign
bool myForcedToResign
Indicates forced resign occurred.
Definition: fedMgr.h:989
DtFederateMgr::myResignAction
MAKRti::DtResignAction myResignAction
The resign action.
Definition: fedMgr.h:1032
getTransportationName
virtual char * getTransportationName(TransportationHandle theHandle)
DtSaveInitiateMsg
Definition: savInitMsg.h:23
DtTestManager
DtTestManager runs network connectivity tests between local RTI components.
Definition: testManager.h:66
DtRestoreInitiateMsg
Definition: resInitMsg.h:22
DtFederateMgr::myEnableFederateHeartbeat
bool myEnableFederateHeartbeat
is heartbeating enabled?
Definition: fedMgr.h:1010
DtFederateMgr::myClock
MAKRti::DtClock myClock
Clock for timing.
Definition: fedMgr.h:1001
DtFederateMgr::myPrinter
DtFedAmbWrapper * myPrinter
Prints data for federate ambassador calls.
Definition: fedMgr.h:915
DtFederateMgr::myRestoreLabel
MAKRti::DtString myRestoreLabel
The restore label.
Definition: fedMgr.h:980
DtFederateMgr::theCreator
static DtFederateMgrCreator theCreator
The plugin creator.
Definition: fedMgr.h:1038
DtFederateMgr::mySaveInitiated
bool mySaveInitiated
Indicates save initiated.
Definition: fedMgr.h:966
DtFederateMgr::myNetworkTestEnabled
bool myNetworkTestEnabled
Definition: fedMgr.h:1015
DtFederateMgr::myPostTickCallbacks
DtPostTickCallbackMap myPostTickCallbacks
Definition: fedMgr.h:1023
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)