MAK RTIspy API Documentation for HLA Evolved
 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 
26 #if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
27 #include "RTI/RTIambassador.h"
28 #include "RTI/LogicalTimeFactory.h"
29 #include "RTI/Enums.h"
30 #else
31 #ifdef DtIFSPEC13DLC
32 #include "RTI13.h"
33 #define RTI rti13
34 #else
35 #include "RTI.hh"
36 #endif
37 #endif
38 
39 class DtRtiSaveFile;
40 class DtFomClassMgr;
41 class DtRIDParameters;
42 class DtObjectMgr;
43 class DtInteractionMgr;
44 class DtTimeMgr;
45 class DtDataDistMgr;
46 class DtMomMgr;
47 class DtFederateHandleSet;
48 class DtLogicalTimeFactory;
49 class DtResignMsg;
50 class DtSaveInitiateMsg;
51 class DtSaveResponseMsg;
52 class DtSaveFinishedMsg;
53 class DtRestoreReplyMsg;
54 class DtRestoreInitiateMsg;
55 class DtRestoreEndMsg;
56 class DtRestoreMsg;
57 class DtFederateMgr;
58 class DtFedAmbWrapper;
59 class DtRtiAssistantLrcClient;
60 class DtAssistantExitMsg;
61 class DtAssistantLogEnableMsg;
62 class DtRtiAmbassadorBaseImplementor;
63 class DtTestManager;
64 class DtTestMgrFedAmbWrapper;
65 class DtEnableDisableNetworkTestingMsg;
66 class DtLatencyReportMsg;
67 class DtTestMgrStatusMsg;
68 class DtAssistantFederateSignalTickIntervalMsg;
69 class DtAssistantRidParamsMsg;
70 
71 namespace MAKRti
72 {
73  class DtFomSorter;
74 }
75 
87 
88 class DT_DLL_LRC DtFederateMgr
89 {
90 public:
92  typedef DtFederateMgr* (*DtFederateMgrCreator)(
93  DtRIDParameters* ridParams,
94  DtRtiAmbassadorBaseImplementor* ambImplPtr,
95  DtConnectionMgr* connMgr,
96  DtBoost::shared_ptr<DtRtiAssistantLrcClient> assistantClient);
97 
98  // Callback for PostTick
99  typedef void (*DtFedMgrPostTickCallbackFcn) (void*);
100  typedef std::pair< DtFedMgrPostTickCallbackFcn, void* > DtFedMgrPostTickCallbackInfo;
101  typedef std::map< MAKRti::DtString, DtFedMgrPostTickCallbackInfo > DtPostTickCallbackMap;
102  typedef std::map< MAKRti::DtString, DtFomClassMgr* > DtParsedFomsMap;
103  typedef std::map< MAKRti::DtString, std::pair< char*, int > > DtFileNameToDataMap;
104  typedef std::map< DtString, int > DtFomToComplexMap;
105  typedef std::map< DtString, DtString > DtFomNameToFileNameMap;
106  typedef std::map< DtString, DtString > DtFileNameToFomNameMap;
107  typedef std::multimap< int, DtString > DtComplexToFomsMMap;
108 
109 protected:
110 
112  DtFederateMgr(
113  DtRIDParameters* params,
114  DtRtiAmbassadorBaseImplementor* ambImplPtr,
115  DtConnectionMgr* connMgr,
116  DtBoost::shared_ptr<DtRtiAssistantLrcClient> assistantClient);
117 
118 public:
119 
121  virtual ~DtFederateMgr();
122 
123 private:
124 
126  DtFederateMgr(DtFederateMgr const& );
127 
129  DtFederateMgr& operator= (DtFederateMgr const& );
130 
131 public:
132 
134  virtual void createFederationExecution(
135  const char* executionName, const char* timeImplName,
136 #ifdef DtIFSPEC1516E
137  const std::vector<DtString>& fomModules,
138  const char* mimModule) = 0;
139 #else
140  const char* fed) = 0;
141 #endif
142 
144  virtual void destroyFederationExecution (
145  const char* executionName) = 0;
146 
147 #ifdef DtIFSPEC1516E
148  virtual void listFederationExecutions() = 0;
150 #endif
151 
153 #ifdef DtIFSPEC1516
154  virtual rti1516::FederateHandle joinFederationExecution(
155  const char* federateType,
156  const char* federationExecutionName,
157  rti1516::FederateAmbassador* federateAmbassador,
158  unsigned long flags) = 0;
159 #elif defined(DtIFSPEC1516E)
160  virtual rti1516e::FederateHandle joinFederationExecution(
161  const char* federateName,
162  const char* federateType,
163  const char* federationExecutionName,
164  const std::vector<DtString>& fomModules,
165  unsigned long flags) = 0;
166 #else
167  virtual RTI::FederateHandle joinFederationExecution (
168  const char* yourName,
169  const char* executionName,
170  RTI::FederateAmbassador* federateAmbassadorReference,
171  unsigned long flags) = 0;
172 #endif
173 
175 #ifdef DtIFSPEC1516
176  virtual void resignFederationExecution(
177  rti1516::ResignAction theAction);
178 #elif defined(DtIFSPEC1516E)
179  virtual void resignFederationExecution(
180  rti1516e::ResignAction theAction);
181 #else
182  virtual void resignFederationExecution(
183  RTI::ResignAction theAction);
184 #endif
185 
188  virtual bool automaticReserveObjectName(const char *);
189 
191 #ifdef DtIFSPEC1516
192  virtual void registerFederationSynchronizationPoint(
193  const char* label,
194  rti1516::VariableLengthData const & theTag) = 0;
195 #elif defined(DtIFSPEC1516E)
196  virtual void registerFederationSynchronizationPoint(
197  const char* label,
198  rti1516e::VariableLengthData const & theTag) = 0;
199 #else
200  virtual void registerFederationSynchronizationPoint(
201  const char* label,
202  const char* theTag) = 0;
203 #endif
204 
206  virtual void waitForResignResponse(bool serviceCall = true);
207 
209  virtual void waitForReserveNameResponse(bool serviceCall = true);
210 
212 #ifdef DtIFSPEC1516
213  virtual void registerFederationSynchronizationPoint(
214  const char* label,
215  rti1516::VariableLengthData const & theTag,
216  DtFederateHandleSet const& syncSet) = 0;
217 #elif defined(DtIFSPEC1516E)
218  virtual void registerFederationSynchronizationPoint(
219  const char* label,
220  rti1516e::VariableLengthData const & theTag,
221  DtFederateHandleSet const& syncSet) = 0;
222 #else
223  virtual void registerFederationSynchronizationPoint(
224  const char* label,
225  const char* theTag,
226  DtFederateHandleSet const& syncSet) = 0;
227 #endif
228 
230  virtual void synchronizationPointAchieved(const char* label, bool successfully=true) = 0;
231 
235  virtual MAKRti::DtString fedFileName(MAKRti::DtString execName);
236 
240  virtual MAKRti::DtString timeImplName(MAKRti::DtString execName);
241 
243  virtual void init();
244 
246 
247 #ifdef DtIFSPEC1516
248  virtual void setTopLevelAmbassador(rti1516::RTIambassador* ambPtr);
249 #elif defined(DtIFSPEC1516E)
250  virtual void setTopLevelAmbassador(rti1516e::RTIambassador* ambPtr,
251  rti1516e::FederateAmbassador* federateAmbassador);
252 #else
253  virtual void setTopLevelAmbassador(RTI::RTIambassador* ambPtr);
254 #endif
255 
256 
258  virtual bool tick();
259  virtual void pretick();
260  virtual void posttick();
261 
262  virtual void postTickCallbacks();
263 
264  virtual void addPostTickCallback(const MAKRti::DtString& label, const DtFedMgrPostTickCallbackInfo& cb);
265  virtual void removePostTickCallback(const MAKRti::DtString& label);
266 
267 #ifdef DtIFSPEC1516
268  virtual void requestFederationSave ( const char *label,
270  const rti1516::LogicalTime* time=NULL) =0;
271 
273  virtual void queryFederationSaveStatus()=0;
274 
276  virtual void queryFederationRestoreStatus()=0;
277 #elif defined(DtIFSPEC1516E)
278  virtual void requestFederationSave ( const char *label,
280  const rti1516e::LogicalTime* time=NULL) =0;
281 
283  virtual void queryFederationSaveStatus()=0;
284 
286  virtual void queryFederationRestoreStatus()=0;
287 
289  virtual void abortFederationSave () =0;
290 
292  virtual void abortFederationRestore () =0;
293 #else
294  virtual void requestFederationSave ( const char *label,
296  const RTI::FedTime* time=NULL) =0;
297 #endif
298 
300  virtual void federateSaveBegun () =0;
301 
303  virtual void federateSaveComplete () =0;
304 
306  virtual void federateSaveNotComplete () =0;
307 
309  virtual void requestFederationRestore ( const char *label) =0;
310 
312  virtual void federateRestoreComplete () =0;
313 
315  virtual void federateRestoreNotComplete () =0;
316 
318  virtual char* getTransportationName(MAKRti::DtTransportType transport);
319 
321  virtual char* getOrderName(MAKRti::DtOrderType order);
322 
324  virtual MAKRti::DtTransportType getTransportationHandle(MAKRti::DtString transport);
325 
327  virtual MAKRti::DtOrderType getOrderHandle(MAKRti::DtString order);
328 
330  virtual DtFederateHandle federateHandle() const;
331 
333  virtual MAKRti::DtString const & fedType() const;
334 
336  virtual MAKRti::DtString const & fedName() const;
337 
339  virtual MAKRti::DtString const & fedExName() const;
340 
342  virtual unsigned long fedExHandle() const;
343 
345  virtual bool isJoined() const;
346 
348 
349 #ifdef DtIFSPEC1516
350  rti1516::RTIambassador* rtiAmb();
351  rti1516::RTIambassador* rtiAmb() const;
352 #elif defined(DtIFSPEC1516E)
353  rti1516e::RTIambassador* rtiAmb();
354  rti1516e::RTIambassador* rtiAmb() const;
355 #else
356  RTI::RTIambassador* rtiAmb();
357  RTI::RTIambassador* rtiAmb() const;
358 #endif
359 
360 
362 
363 #ifdef DtIFSPEC1516
364  virtual rti1516::FederateAmbassador * federateAmbassador() const;
365 #elif defined(DtIFSPEC1516E)
366  virtual rti1516e::FederateAmbassador * federateAmbassador() const;
367 #else
368  virtual RTI::FederateAmbassador * federateAmbassador() const;
369 #endif
370 
371 
373  virtual DtConnectionMgr* connectMgr();
374  virtual DtConnectionMgr* connectMgr() const;
375 
377  virtual DtRIDParameters* params();
378  virtual DtRIDParameters* params() const;
379 
381  virtual DtFomClassMgr* fom();
382  virtual DtFomClassMgr* fom() const;
383 
385  virtual DtInteractionMgr* interMgr();
386  virtual DtInteractionMgr* interMgr() const;
387 
389  virtual DtTestManager* testMgr();
390  virtual DtTestManager* testMgr() const;
391 
393  virtual DtObjectMgr* objMgr();
394  virtual DtObjectMgr* objMgr() const;
395 
396 #ifdef DtTIME
397  virtual DtTimeMgr* timeMgr();
399  virtual DtTimeMgr* timeMgr() const;
400 #endif
401 
403  virtual DtLogicalTimeFactory* timeFactory();
404  virtual DtLogicalTimeFactory* timeFactory() const;
405 
406 #ifdef DtMOM
407  virtual DtMomMgr* momMgr();
409  virtual DtMomMgr* momMgr() const;
410 #endif
411 
412 #ifdef DDM
413  virtual DtDataDistMgr* ddmMgr();
415  virtual DtDataDistMgr* ddmMgr() const;
416 #endif
417 
419  virtual DtRtiAssistantLrcClient* assistantClient();
420  virtual DtRtiAssistantLrcClient* assistantClient() const;
421 
423  virtual bool isJoinedFederate(DtFederateHandle federateHandleValue) const;
424 
426  virtual bool forcedToResign() const;
427 
429  virtual void setMomResign();
430 
432  virtual void resetMomResign();
433 
435  virtual bool saveInitiated() const;
436 
438  virtual bool saveBegun() const;
439 
441  virtual bool restoreRequested() const;
442 
444  virtual bool restoreInitiated() const;
445 
447  virtual bool restoreBegun() const;
448 
450  virtual const MAKRti::DtString& restoreLabel() const;
451 
453  virtual const MAKRti::DtString& lastRestoreLabel() const;
454 
456  const MAKRti::DtString& currentFedFileName() const;
457  void setCurrentFedFileName( const MAKRti::DtString& );
458 
460  const MAKRti::DtString& mimName() const;
461  void setMimName( const MAKRti::DtString& );
462 
463 #ifdef DtIFSPEC1516E
464  void addFomModule( const MAKRti::DtString& name, char* buffer );
466 
468  const std::vector<std::wstring>& fomModuleNames() const;
469 
471  void addJoinFomModuleNames(const std::vector<MAKRti::DtString>& moduleNames);
472  const std::vector<std::wstring>& joinFomModuleNames() const;
473 
476  const char* fomModuleData(MAKRti::DtU32 moduleIndicator) const;
477 
480  const char* joinFomModuleData(MAKRti::DtU32 moduleIndicator) const;
481 
483  const char* mimData() const;
484 #endif
485 
487  const MAKRti::DtString& currentTimeImplName() const;
488  void setCurrentTimeImplName( const MAKRti::DtString& );
489 
491  virtual const MAKRti::DtString& saveLabel() const;
492  virtual void setSaveLabel(const MAKRti::DtString& value);
493 
495  virtual const MAKRti::DtString& lastSaveLabel() const;
496  virtual void setLastSaveLabel(const MAKRti::DtString& value);
497 
498 
500  virtual void testSaveProgress() = 0;
501 
504  virtual void initiateSave();
505 
508 #ifdef DtIFSPEC1516
509  virtual void initiateTimedSave(rti1516::LogicalTime const& saveTime);
510 #elif defined(DtIFSPEC1516E)
511  virtual void initiateTimedSave(rti1516e::LogicalTime const& saveTime);
512 #else
513  virtual void initiateTimedSave(RTI::FedTime const& saveTime);
514 #endif
515 
517  virtual bool save( DtRtiSaveFile& file ){ return true;};
518 
520  virtual bool restore( DtRtiSaveFile& file ){ return true;};
521 
527  virtual MAKRti::DtString& getSaveFileName(const char* label,
528  DtFederateHandle fedHandle, MAKRti::DtString& fileName,
529  bool extendName=true);
530 
536  virtual MAKRti::DtString& getRestoreFileName(const char* label,
537  DtFederateHandle fedHandle, MAKRti::DtString& fileName);
538 
540  virtual unsigned long tickCount() const;
541 
543  virtual bool isTicking() const;
544 
546  virtual void reportLatencyTestResults( const DtLatencyReportMsg& msg );
547 
549  virtual void reportLatencyTestStatus( const DtTestMgrStatusMsg& msg );
550 
551  unsigned long flags() const;
552 
553  DtResignAction automaticResignDirective() const;
554 
555 #ifdef DtIFSPEC1516E
556  virtual rti1516e::ResignAction getAutomaticResignDirective() const;
557 
560  virtual void setAutomaticResignDirective( const rti1516e::ResignAction action );
561 #endif
562 
564  virtual const MAKRti::DtString& getFederateNameFromHandle( DtFederateHandle handle );
565  virtual DtFederateHandle getFederateHandleFromName( const MAKRti::DtString& name );
566 
567 public:
568 
575  static DtFederateMgr* create(
576  DtRIDParameters* params,
577  DtRtiAmbassadorBaseImplementor* ambImplPtr,
578  DtConnectionMgr* connMgr,
579  DtBoost::shared_ptr<DtRtiAssistantLrcClient> assistantClient);
580 
583  static void setCreatorFunction(DtFederateMgrCreator fn);
584 
589  static void setInternalCreatorFunction(DtFederateMgrCreator fn);
590 
591 protected:
592 
596 
597 
599  virtual void processResign(const DtResignMsg& msg);
600 
602  virtual void processEnableDisableNetworkTesting( const DtEnableDisableNetworkTestingMsg& msg );
603 
605  virtual void processSaveInitiate(const DtSaveInitiateMsg& msg);
606 
608  virtual void processSaveResponse(const DtSaveResponseMsg& msg);
609 
611  virtual void processSaveFinished(const DtSaveFinishedMsg& msg);
612 
614  virtual void processRestoreReply(const DtRestoreReplyMsg& msg);
615 
617  virtual void processRestoreInitiate(const DtRestoreInitiateMsg& msg);
618 
620  virtual void processRestoreEnd(const DtRestoreEndMsg& msg);
621 
623  virtual void processRestore(const DtRestoreMsg& msg);
625 
629 
630  virtual void processAssistantResign(const DtAssistantExitMsg& msg);
632 
634  virtual void processAssistantEnableLogging(const DtAssistantLogEnableMsg& msg);
635 
637  virtual void processSignalTickInterval( const DtAssistantFederateSignalTickIntervalMsg& msg );
638 
640  virtual void processRidParamRequest( const DtAssistantRidParamsMsg& msg );
642 
643 #ifdef DtIFSPEC1516E
644  virtual void processResignDirective( const DtResignDirectiveMsg& msg );
646 #endif
647 
649  virtual void sendAlive();
650 
652  virtual void sendResignMsg(const char* fedExName,
653  DtFederateHandle fedHandle, DtResignAction action);
654 
656  void sendTickedMsg();
657 
659  virtual void applyRidParameters();
660 
665  virtual MAKRti::DtFilename fedFileNameToUse(MAKRti::DtString fileName, MAKRti::DtString executionName );
666 
667  //Add comments to each later
668  virtual int mapFomDepComplexity(DtString fomFileName);
669 
670  virtual void mapFomNameToFileName(std::vector<DtString>* fomFileNames);
671 
672  virtual void sortFomFileNames(std::vector<DtString>* fomFileNames);
673 
675  virtual void testReadFedFile(MAKRti::DtString fileName, MAKRti::DtString executionName);
676 
679  virtual void readFedFile(MAKRti::DtString fileName, MAKRti::DtString executionName);
680 
683  virtual void readFedFilePtr( const FILE* fp,
684  const MAKRti::DtString& fileName,
685  const MAKRti::DtString& executionName );
686 
689  virtual void addFedExNameMapping(const MAKRti::DtString& execName,
690  const MAKRti::DtString& timeImplName, const MAKRti::DtString& fed);
691 
692  virtual void addFomModuleNameMapping( const MAKRti::DtString executionName,
693  const std::vector<MAKRti::DtString>& modules);
694 
695  virtual void addFomModuleNameMapping( const MAKRti::DtString executionName,
696  const MAKRti::DtString& modules );
697 
699 #ifdef DtIFSPEC1516
700  virtual DtResignAction testResign(rti1516::ResignAction theAction);
701 #elif defined(DtIFSPEC1516E)
702  virtual DtResignAction testResign(rti1516e::ResignAction theAction);
703 #else
704  virtual DtResignAction testResign(RTI::ResignAction theAction);
705 #endif
706 
709  virtual void postJoinInit(
710  const char* federateType,
711  const char* executionName,
712  const char* federateName
713 #ifdef DtIFSPEC1516
714  , rti1516::FederateAmbassador* federateAmbassadorReference);
715 #elif defined(DtIFSPEC1516E)
716  );
717 #else
718  , RTI::FederateAmbassador* federateAmbassadorReference);
719 #endif
720 
721  virtual void postJoinConfirmInit();
722 
723 protected:
724 
728 
729 
731  static void processResign(const DtResignMsg& msg, void* usr);
732 
734  static void processEnableDisableNetworkTesting(const DtEnableDisableNetworkTestingMsg& msg, void* usr );
735 
737  static void processSaveInitiate(const DtSaveInitiateMsg& msg, void* usr);
738 
740  static void processSaveResponse(const DtSaveResponseMsg& msg, void* usr);
741 
743  static void processSaveFinished(const DtSaveFinishedMsg& msg, void* usr);
744 
746  static void processRestoreReply(const DtRestoreReplyMsg& msg, void* usr);
747 
749  static void processRestore(const DtRestoreMsg& msg, void* usr);
750 
752  static void processRestoreInitiate(const DtRestoreInitiateMsg& msg,
753  void* usr);
754 
756  static void processRestoreEnd(const DtRestoreEndMsg& msg, void* usr);
758 
759 
763 
764  static void processAssistantResign(const DtAssistantExitMsg& msg, void* usr);
766 
768  static void processAssistantEnableLogging(const DtAssistantLogEnableMsg& msg, void* usr);
769 
771  static void processSignalTickInterval( const DtAssistantFederateSignalTickIntervalMsg& msg, void* usr );
772 
774  static void processRidParamRequest( const DtAssistantRidParamsMsg& msg, void* usr );
776 
777 #ifdef DtIFSPEC1516E
778  static void processResignDirective( const DtResignDirectiveMsg& msg, void* usr );
780 #endif
781 
784 
785 
787  virtual void createObjectMgr();
788 
790  virtual void createInteractionMgr();
791 
793  virtual void createDdmMgr();
794 
796  virtual void createTimeMgr();
797 
799  virtual void createMomMgr();
800 
802  virtual void createTestMgr();
803 
805 
806 #ifdef DtIFSPEC1516
807  virtual MAKRti::DtResignAction convertResignAction(rti1516::ResignAction) const;
808  virtual rti1516::ResignAction convertResignAction(MAKRti::DtResignAction) const;
809 #elif defined(DtIFSPEC1516E)
810  virtual MAKRti::DtResignAction convertResignAction(rti1516e::ResignAction) const;
811  virtual rti1516e::ResignAction convertResignAction(MAKRti::DtResignAction) const;
812 #else
813  virtual MAKRti::DtResignAction convertResignAction(RTI::ResignAction) const;
814  virtual RTI::ResignAction convertResignAction(MAKRti::DtResignAction) const;
815 #endif
816 
817 public:
818 
819  //In order to correctly stop evokeCallback we need to know what has reached a
820  //federate Ambassador. So we are puttling this boolean here in order to do that
821  //Accessors should be made once we know this works.
822  bool myFedCallbackReached;
823 
824 protected:
825 
826  DtFedReader * getReader( DtFomType theFomType, DtFomClassMgr* target);
827  DtFedReader * getReader( DtFomType theFomType );
828  void addToParsedFomMap( DtFedReader * myFedReader, const MAKRti::DtString & fileNameToUse, DtFomClassMgr* fedTarget, unsigned long theCrc = 0);
829 
831 #ifdef DtIFSPEC1516
832  rti1516::RTIambassador* myRtiAmb;
833 #elif defined(DtIFSPEC1516E)
834  rti1516e::RTIambassador* myRtiAmb;
835 #else
836  RTI::RTIambassador* myRtiAmb;
837 #endif
838 
840  DtRtiAmbassadorBaseImplementor* myAmbImpl;
841 
844 
845 
847  DtConnectionMgr* myConnectMgr;
848 
850  DtFomClassMgr* myFom;
851 
853  DtInteractionMgr* myInterMgr;
854 
856  DtObjectMgr* myObjMgr;
857 
859  DtMomMgr* myMomMgr;
860 
861 #ifdef DDM
862  DtDataDistMgr* myDdmMgr;
864 #endif
865 #ifdef DtTIME
866  DtTimeMgr* myTimeMgr;
868 #endif
869 
870 
872  MAKRti::DtTime myResponseInterval;
873 
875  MAKRti::DtString myFedExName;
876 
878  unsigned long myFedExHandle;
879 
881  MAKRti::DtString myFedType;
882 
885  MAKRti::DtString myFedName;
886 
888  DtFederateHandle myFedHandle;
889 
891  MAKRti::DtString myCurrentFedFileName;
892 
894  MAKRti::DtString myMimName;
895 
897  MAKRti::DtString myCurrentTimeImplName;
898 
899 #ifdef DtIFSPEC1516E
900  std::vector<std::wstring> myFomModulesNames;
902  std::vector<std::wstring> myJoinFomModulesNames;
903  std::vector<char*> myFomModuleData;
904  unsigned myMimIndex;
905 #endif
906 
908  MAKRti::DtTime myLastHeartbeat;
909 
912  DtLogicalTimeFactory* myLogicalTimeFactory;
913 #if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
914 #else
915  RTI::FedTimeFactory myHlaTimeFactory;
916 #endif
917 
919  DtFedAmbWrapper* myPrinter;
920 
922  DtFedAmbWrapper* myFedAmbCatch;
923 
924 
926  DtRIDParameters* myParams;
927 
929  DtFedReader * myFedReader;
930  DtFedReader * myFedReader13;
931  DtFedReader * myFedReader1516;
932  DtFedReader * myFedReader1516e;
933 
937  MAKRti::DtList myMappingList;
938 
939  std::map<MAKRti::DtString, std::set<MAKRti::DtString> > myFedFileNames;
940 
942  DtParsedFomsMap myParsedFoms;
943 
944 #ifdef DtIFSPEC1516E
945  DtFileNameToDataMap myParsedFomModuleData;
947 #endif
948 
949  // make this FOM dependency, not DtString
950  DtComplexToFomsMMap myComplexToFomsMMap;
951  typedef std::pair<int, DtString> DtMMapPair;
952 
953  DtFomToComplexMap myFomToComplexMap;
954  typedef std::pair<DtString, int> DtFomCompPair;
955 
956  DtFomNameToFileNameMap myFomToFileMap;
957  typedef std::pair<DtString, DtString> DtFomFilePair;
958 
959  DtFileNameToFomNameMap myFileToFomMap;
960  typedef std::pair<DtString, DtString> DtFileFomPair;
961 
963  DtBoost::shared_ptr<DtRtiAssistantLrcClient> myAssistantClient;
964 
967 
968 
970  bool mySaveInitiated;
972  bool mySaveBegun;
974  bool myRestoreRequested;
976  bool myRestoreInitiated;
978  bool myRestoreBegun;
980  MAKRti::DtString mySaveLabel;
982  MAKRti::DtString myLastSaveLabel;
984  MAKRti::DtString myRestoreLabel;
986  MAKRti::DtString myLastRestoreLabel;
988 
990  bool myIgnoreForcedResign;
991 
993  bool myForcedToResign;
994 
996  bool myMomResign;
997 
999  bool myMomSaveEvokeCallbacks;
1000 
1002  bool myResignInProgress;
1003 
1005  MAKRti::DtClock myClock;
1006 
1008  unsigned long myTickCount;
1009 
1011  bool myIsTicking;
1012 
1014  bool myEnableFederateHeartbeat;
1015 
1016  unsigned long myFlags;
1017 
1018  DtTestManager* myTestMgr;
1019  bool myNetworkTestEnabled;
1020 
1022  float mySignalTickInterval;
1023 
1025  DtTime myLastTickTime;
1026 
1027  DtPostTickCallbackMap myPostTickCallbacks;
1028 
1029  MAKRti::DtFilename myStandardMimPath;
1030 
1031  // our list of Federate Names to Handles and vise-versa
1032  std::map< MAKRti::DtString, DtFederateHandle > myFederateNameToHandle;
1033  std::map< DtFederateHandle, MAKRti::DtString > myFederateHandleToName;
1034 
1036  MAKRti::DtResignAction myResignAction;
1037 
1038  DtFomSorter* myFomSorter;
1039 
1040 protected:
1042  static DtFederateMgrCreator theCreator;
1043 
1045  static DtFederateMgrCreator theInternalCreator;
1046 };
1047 
1048 #endif
1049 
1050 
1051 
DtFederateMgr::myFedReader
DtFedReader * myFedReader
Temporary internal reader used until changes made to VR-Link fed reader.
Definition: fedMgr.h:929
DtFederateMgr::DtFedMgrPostTickCallbackInfo
std::pair< DtFedMgrPostTickCallbackFcn, void * > DtFedMgrPostTickCallbackInfo
Definition: fedMgr.h:100
DtFederateMgr::myAmbImpl
DtRtiAmbassadorBaseImplementor * myAmbImpl
The federate&#39;s RTI Ambassador Implementor.
Definition: fedMgr.h:840
DtFederateMgr::DtFileNameToFomNameMap
std::map< DtString, DtString > DtFileNameToFomNameMap
Definition: fedMgr.h:106
DtFederateMgr::myFedName
MAKRti::DtString myFedName
Federate name.
Definition: fedMgr.h:885
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:926
DtFederateMgr::myCurrentTimeImplName
MAKRti::DtString myCurrentTimeImplName
Current time implementation name.
Definition: fedMgr.h:897
DtFederateMgr::DtComplexToFomsMMap
std::multimap< int, DtString > DtComplexToFomsMMap
Definition: fedMgr.h:107
LogicalTimeFactory.h
DtFederateMgr::DtFomToComplexMap
std::map< DtString, int > DtFomToComplexMap
Definition: fedMgr.h:104
RIDparams.h
DtFederateMgr::myFom
DtFomClassMgr * myFom
The FOM manager.
Definition: fedMgr.h:850
DtSaveResponseMsg
Definition: savRespMsg.h:29
DtFederateMgr::restore
virtual bool restore(DtRtiSaveFile &file)
Perform the actual restore.
Definition: fedMgr.h:520
DtTestMgrStatusMsg
The DtTestMgrStatusMsg defines a msg for a client to report the results of a latency test...
Definition: testMgrStatusMsg.h:36
DtFederateMgr::myFileToFomMap
DtFileNameToFomNameMap myFileToFomMap
Definition: fedMgr.h:959
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:960
DtFederateMgr::myFedFileNames
std::map< MAKRti::DtString, std::set< MAKRti::DtString > > myFedFileNames
Definition: fedMgr.h:939
DtFederateMgr::myParsedFoms
DtParsedFomsMap myParsedFoms
Map containing FOMs parsed into FedTargets.
Definition: fedMgr.h:942
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:922
DtFederateMgr::myMomSaveEvokeCallbacks
bool myMomSaveEvokeCallbacks
State of evoking callbacks prior to MOM resign.
Definition: fedMgr.h:999
rti1516e::LogicalTime
Definition: LogicalTime.h:35
DtFederateMgr::myInterMgr
DtInteractionMgr * myInterMgr
The interaction manager.
Definition: fedMgr.h:853
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:101
rti1516e::RTIambassador
A class provided by the HLA C++ Interface Specification which federates use to communicate with the R...
Definition: RTIambassador.h:35
DtFederateMgr::myFedCallbackReached
bool myFedCallbackReached
Definition: fedMgr.h:822
DtFederateMgr::myAssistantClient
DtBoost::shared_ptr< DtRtiAssistantLrcClient > myAssistantClient
Manages the connection to the RTI Assistant.
Definition: fedMgr.h:963
DtFederateHandleSet
Definition: fedHandleSet.h:102
DtFederateMgr::myFedExHandle
unsigned long myFedExHandle
Federation handle.
Definition: fedMgr.h:878
DtFederateMgr::myFomToFileMap
DtFomNameToFileNameMap myFomToFileMap
Definition: fedMgr.h:956
DtResignMsg
Definition: resignMsg.h:36
DtResignDirectiveMsg
Definition: resignDirectiveMsg.h:24
DtFederateMgr::myFomSorter
DtFomSorter * myFomSorter
Definition: fedMgr.h:1038
DtFederateMgr::DtFomFilePair
std::pair< DtString, DtString > DtFomFilePair
Definition: fedMgr.h:957
DtFederateMgr::myLastTickTime
DtTime myLastTickTime
The last tick time.
Definition: fedMgr.h:1025
DtFederateMgr::myFedReader1516e
DtFedReader * myFedReader1516e
Definition: fedMgr.h:932
DtFederateMgr::DtFileNameToDataMap
std::map< MAKRti::DtString, std::pair< char *, int > > DtFileNameToDataMap
Definition: fedMgr.h:103
DtFederateMgr::myMomResign
bool myMomResign
Indicates MOM caused resign.
Definition: fedMgr.h:996
rti1516e::VariableLengthData
Definition: VariableLengthData.h:34
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:951
DtFederateMgr::myTickCount
unsigned long myTickCount
Tick counter.
Definition: fedMgr.h:1008
DtFederateMgr::DtFomNameToFileNameMap
std::map< DtString, DtString > DtFomNameToFileNameMap
Definition: fedMgr.h:105
DtFederateMgr::myFedReader13
DtFedReader * myFedReader13
Definition: fedMgr.h:930
DtFederateMgr::myFedType
MAKRti::DtString myFedType
Federate type.
Definition: fedMgr.h:881
rti1516e::ResignAction
ResignAction
Definition: Enums.h:33
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:88
DtFederateMgr::myRestoreRequested
bool myRestoreRequested
Indicates restore requested.
Definition: fedMgr.h:974
DtFederateMgr::mySaveBegun
bool mySaveBegun
Indicates save begun.
Definition: fedMgr.h:972
DtFederateMgr::myLogicalTimeFactory
DtLogicalTimeFactory * myLogicalTimeFactory
Logical time factory Even if NULL, need to have this factory.
Definition: fedMgr.h:912
DtFederateMgr::myIsTicking
bool myIsTicking
indicates currently processing tick
Definition: fedMgr.h:1011
DtFederateMgr::myConnectMgr
DtConnectionMgr * myConnectMgr
The connection manager.
Definition: fedMgr.h:847
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:1045
DtFederateMgr::myLastHeartbeat
MAKRti::DtTime myLastHeartbeat
Time of last heartbeat.
Definition: fedMgr.h:908
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:976
DtFederateHandle
DtHandle DtFederateHandle
Definition: internalTypes.h:29
DtRestoreEndMsg
Definition: resEndMsg.h:31
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:953
DtFederateMgr::myComplexToFomsMMap
DtComplexToFomsMMap myComplexToFomsMMap
Definition: fedMgr.h:950
DtFederateMgr::myMimName
MAKRti::DtString myMimName
MIM name.
Definition: fedMgr.h:894
DtFomClassMgr
Definition: fomMgr.h:53
DtFederateMgr::myFlags
unsigned long myFlags
Definition: fedMgr.h:1016
DtFederateMgr::myIgnoreForcedResign
bool myIgnoreForcedResign
Prevents forcing duplicate resign.
Definition: fedMgr.h:990
DtFederateMgr::myFedHandle
DtFederateHandle myFedHandle
Federate handle.
Definition: fedMgr.h:888
DtFederateMgr::myRestoreBegun
bool myRestoreBegun
Indicates restore begun.
Definition: fedMgr.h:978
DtFederateMgr::mySignalTickInterval
float mySignalTickInterval
The Signal Tick Interval.
Definition: fedMgr.h:1022
DtFederateMgr::myResignInProgress
bool myResignInProgress
Indicates a resign is in progress.
Definition: fedMgr.h:1002
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:859
DtFederateMgr::myStandardMimPath
MAKRti::DtFilename myStandardMimPath
Definition: fedMgr.h:1029
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:986
DtFederateMgr::myFedReader1516
DtFedReader * myFedReader1516
Definition: fedMgr.h:931
DtFederateMgr::myFederateHandleToName
std::map< DtFederateHandle, MAKRti::DtString > myFederateHandleToName
Definition: fedMgr.h:1033
DtFederateMgr::myHlaTimeFactory
RTI::FedTimeFactory myHlaTimeFactory
Definition: fedMgr.h:915
DtFederateMgr::myRtiAmb
RTI::RTIambassador * myRtiAmb
The federate&#39;s RTI Ambassador.
Definition: fedMgr.h:836
DtFederateMgr::myObjMgr
DtObjectMgr * myObjMgr
The object manager.
Definition: fedMgr.h:856
DtFederateMgr::myResponseInterval
MAKRti::DtTime myResponseInterval
Interval to wait for response message during a message protocol.
Definition: fedMgr.h:872
DtFederateMgr::DtFomCompPair
std::pair< DtString, int > DtFomCompPair
Definition: fedMgr.h:954
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::myLastSaveLabel
MAKRti::DtString myLastSaveLabel
The last save label.
Definition: fedMgr.h:982
Enums.h
This file contains enumerations used by the interface.
DtFederateMgr::myFederateNameToHandle
std::map< MAKRti::DtString, DtFederateHandle > myFederateNameToHandle
Definition: fedMgr.h:1032
DtFederateMgr::DtParsedFomsMap
std::map< MAKRti::DtString, DtFomClassMgr * > DtParsedFomsMap
Definition: fedMgr.h:102
rti1516e::FederateAmbassador
An abstract base class which must be implemented, and used by a federate.
Definition: FederateAmbassador.h:32
DtFederateMgr::myMappingList
MAKRti::DtList myMappingList
List of federation execution names with FED files names and time implementation names.
Definition: fedMgr.h:937
RTIambassador.h
This file contains the rti1516e::RTIambassador class.
DtFederateMgr::myCurrentFedFileName
MAKRti::DtString myCurrentFedFileName
Current FED/FDD file name.
Definition: fedMgr.h:891
DtFederateMgr::save
virtual bool save(DtRtiSaveFile &file)
Perform the actual save.
Definition: fedMgr.h:517
DT_DLL_LRC
#define DT_DLL_LRC
Definition: rtiMsConfig.h:126
DtFederateMgr::myFedExName
MAKRti::DtString myFedExName
Federation execution name.
Definition: fedMgr.h:875
DtRtiSaveFile
Definition: saveFile.h:21
DtFederateMgr::mySaveLabel
MAKRti::DtString mySaveLabel
The save label.
Definition: fedMgr.h:980
DtFederateMgr::myTestMgr
DtTestManager * myTestMgr
Definition: fedMgr.h:1018
DtFederateMgr::myForcedToResign
bool myForcedToResign
Indicates forced resign occurred.
Definition: fedMgr.h:993
DtFederateMgr::myResignAction
MAKRti::DtResignAction myResignAction
The resign action.
Definition: fedMgr.h:1036
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:1014
DtFederateMgr::myClock
MAKRti::DtClock myClock
Clock for timing.
Definition: fedMgr.h:1005
DtFederateMgr::myPrinter
DtFedAmbWrapper * myPrinter
Prints data for federate ambassador calls.
Definition: fedMgr.h:919
DtFederateMgr::myRestoreLabel
MAKRti::DtString myRestoreLabel
The restore label.
Definition: fedMgr.h:984
DtFederateMgr::theCreator
static DtFederateMgrCreator theCreator
The plugin creator.
Definition: fedMgr.h:1042
DtFederateMgr::mySaveInitiated
bool mySaveInitiated
Indicates save initiated.
Definition: fedMgr.h:970
DtFederateMgr::myNetworkTestEnabled
bool myNetworkTestEnabled
Definition: fedMgr.h:1019
DtFederateMgr::myPostTickCallbacks
DtPostTickCallbackMap myPostTickCallbacks
Definition: fedMgr.h:1027
Document ID: Generated on Thu May 11 15:55:32 EDT 2023 from SVN revision 254743
Copyright © 2005-2020 MAK Technologies Inc. All Rights Reserved (www.mak.com)