VR-Link API Documentation for DIS
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
exerciseConnHLA.h
Go to the documentation of this file.
1 /*********************************************************************
2 ** Copyright (c) 1992-2025 MAK Technologies, Inc
3 ** All rights reserved.
4 *********************************************************************/
8 
9 #ifndef exerciseConnHLA_H_
10 #define exerciseConnHLA_H_
11 
12 #if DtHLA
13 
14 #include "baseExerciseConn.h"
15 #include "callbacks.h"
16 #include "rprFomMapper.h"
17 #include "netnFomMapper.h"
18 #include "rtiCompatibility.h"
19 #include "eventId.h"
20 #include "vrlFederateAmbassador.h"
21 #include "vrlRtiAmbassador.h"
22 #include "exerciseConnInitializerHLA.h"
23 #include "vrlinkStateStateRepository.h"
24 
25 #include <matrix/geodeticCoord.h>
26 #include <vlutil/vlVersion.h>
27 #include "userTagModifiers.h"
28 
29 
30 class DtInteraction;
31 class DtInteractionFactory;
32 class DtHlaObjectFactory;
33 class DtInteractionManager;
34 class DtHlaObjectManager;
35 class DtStateMsg;
36 class DtVrlFederateAmbassador;
37 class DtFom;
38 class DtFilename;
39 class DtDynamicLibrary;
40 class DtFomMapper;
41 class DtVRLinkStateManager;
42 
43 
44 
61 class DT_DLL_VL DtExerciseConn : public DtBaseExerciseConn
62 {
63 
64 public:
65 
66  typedef DtVrlFederateAmbassador* (*DtFedAmbCreator)();
67  typedef DtFomMapper* (*DtFomMapperCreator)(void* usr);
68  typedef void (*DtFomMapperDeletor)(DtFomMapper*);
69 
70  typedef void (*DtRtiErrorCb)(const char* label, void* usr);
71 
74  typedef DtVrlRtiAmbassador* (*DtRtiAmbCreator)(const std::vector<std::wstring>&);
75 
76 #if DtHLA_1516
77  typedef DtTime (*DtLogicalTimeToVrlTimeConverter) (const RTI::LogicalTime &theLogicalTime);
78  typedef std::unique_ptr<RTI::LogicalTime>(*DtVrlTimeToLogicalTimeConverter) (const DtTime &time);
79 #else
80  typedef DtTime (*DtFedTimeToVrlTimeConverter) (const RTI::FedTime &theFedTIme);
81  typedef RTI::FedTime* (*DtVrlTimeToFedTimeConverter) (const DtTime &time);
82 #endif
83 
93  enum InitializationStatus {
94  DtINIT_SUCCESS = 0,
95  DtCOULD_NOT_CREATE_RTIAMB = 1,
96  DtCOULD_NOT_CREATE_FEDEX = 2,
97  DtCOULD_NOT_JOIN_FEDEX = 3,
98  DtCOULD_NOT_OPEN_FED = 4,
99  DtCOULD_NOT_PARSE_FED = 5,
100  DtCOULD_NOT_FIND_FOMMAPPER = 6,
101  DtERROR_OPENING_FOMMAPPER_LIB = 7,
102  DtCOULD_NOT_CONNECT_RTIAMB = 8
103 
104  };
105 
106 public:
107 
110  DtExerciseConn(const DtExerciseConnInitializer& init, InitializationStatus* status = 0);
111 
123  DtExerciseConn(const char* execName,
124  const char* federateType,
125  DtFomMapper* mapper = defaultFomMapper(),
126  const char* fedFileName = 0,
127  InitializationStatus* status = 0
128  );
129 
137  DtExerciseConn(const char* execName,
138  const char* federateType,
139  const char* dsoName,
140  const char* fedFileName = 0,
141  void* fomMapInitData = 0,
142  InitializationStatus* status = 0
143  );
144 
145 #if DtHLA_1516_EVOLVED
146 
147 
152 
163  DtExerciseConn(const char* execName,
164  const char* federateName,
165  const char* federateType,
166  const DtString& fedFile,
167  DtFomMapper* mapper = defaultFomMapper(),
168  const DtString mimModule = "",
169  const std::vector<DtString>& fomModules = std::vector<DtString>(),
170  InitializationStatus* status = 0 );
171 
172 
177 
184  DtExerciseConn(const char* execName,
185  const char* federateName,
186  const char* federateType,
187  const DtString& fedFile,
188  const char* dsoName,
189  void* fomMapInitData = 0,
190  const DtString mimModule = "",
191  const std::vector<DtString>& fomModules = std::vector<DtString>(),
192  InitializationStatus* status = 0 );
193 #endif
194 
196  virtual ~DtExerciseConn();
197 
198 private:
199 
201  DtExerciseConn(const DtExerciseConn& orig);
202 
204  DtExerciseConn& operator=(const DtExerciseConn& orig);
205 
206 public:
207 
217  virtual void setReflecting();
218 
220  virtual bool reflecting() const;
221 
228  virtual void setPassiveMode();
229 
231  virtual bool passiveMode() const;
232 
236 
237  virtual void setDefaultOwnershipHandler(DtOwnershipHandler* ownershipHandler);
238  virtual DtOwnershipHandler* defaultOwnershipHandler();
240 
252  virtual void setReflectRemoteUpdatesIntoPubFlag(bool onff);
253 
255  virtual bool reflectRemoteUpdatesIntoPubFlag() const;
256 
261  virtual void setReflectingThroughRti();
262 
264  virtual bool reflectingThroughRti() const;
265 
275  virtual void ignoreAdvisories();
276 
278  virtual bool usingAdvisories() const;
279 
280  virtual void setRemoveObjectOnAttOutOfScope(bool remove);
281 
288  virtual bool enabledGenericAttributes() const;
289 
290 #if DtHLA_1516_EVOLVED
291  void listFederationExecutions();
293 #endif
294 
298  virtual void send(const DtStateMsg& msg);
299 
305  virtual void send(const DtInteraction& msg);
306 
310 #if DtHLA_1516
311  virtual void send(const DtInteraction& msg,
312  const RTI::RegionHandleSet* region);
313 #else
314  virtual void send(const DtInteraction& msg,
315  const RTI::Region* region);
316 #endif
317 
322  virtual void sendStamped(const DtStateMsg& msg);
323 
328  virtual void sendStamped(const DtInteraction& msg);
329 
333  virtual void sendStampedWithRegion(const DtInteraction& msg,
334  DtDDMRegionSP region);
335 
340 #if DtHLA_1516
341  virtual void sendStamped(const DtInteraction& msg,
342  const RTI::RegionHandleSet* region);
343 #else
344  virtual void sendStamped(const DtInteraction& msg,
345  const RTI::Region* region);
346 #endif
347 
350  virtual DtTime currentTimeForStamping();
351 
366  virtual int drainInput(DtTime maxTime = -1, DtTime minTime = 0.0);
367 
369  virtual void setObjectIdForEventId(const DtGlobalObjectDesignator& id);
370 
372  virtual const DtEventID& nextEventId();
373 
376  virtual DtVrlRtiAmbassador* rtiAmb();
377 
380  virtual DtVrlFederateAmbassador* fedAmb();
381 
383  virtual RTI::FederateHandle fedHandle() const;
384 
386  virtual const DtString& fedType() const;
387 
388 #if DtHLA_1516_EVOLVED
389  virtual const DtString& fedName() const;
392 #endif
393 
395  virtual const DtString& execName() const;
396 
398  virtual bool isUsingMakRti() const;
399 
403  virtual DtString rtiName() const;
404 
408  virtual DtString rtiVersion() const;
409 
412  virtual DtString rtiError() const;
413 
415  virtual DtFom* fom();
416 
418  virtual DtInteractionFactory* interactionFactory();
419 
421  virtual DtHlaObjectFactory* objectFactory();
422 
424  virtual DtFomMapper* fomMapper() const;
425 
427  virtual DtHlaObjectManager* hlaObjectManager();
428 
430  virtual void setTimeStampType(DtTimeStampType relOrAbs);
431 
433  virtual DtTimeStampType timeStampType() const;
434 
439  virtual void addInteractionCallback(RTI::InteractionClassHandle h,
440  DtReceiveInteractionCb cb,
441  void* usr,
442  DtDDMRegionSP region = DtDDMRegionSP());
443 
448  virtual void addInteractionCallbackByName(const char* className,
449  DtReceiveInteractionCb cb,
450  void* usr,
451  DtDDMRegionSP region = DtDDMRegionSP());
452 
457  virtual void removeInteractionCallback(RTI::InteractionClassHandle h,
458  DtReceiveInteractionCb cb,
459  void* usr,
460  DtDDMRegionSP region = DtDDMRegionSP());
461 
466  virtual void removeInteractionCallbackByName(const char* className,
467  DtReceiveInteractionCb cb,
468  void* usr, DtDDMRegionSP region = DtDDMRegionSP());
469 
472  virtual void addDiscoverObjectCallback(RTI::ObjectClassHandle h,
473  DtDiscoverObjectCb cb,
474  void* usr);
475 
479  virtual void removeDiscoverObjectCallback(RTI::ObjectClassHandle h,
480  DtDiscoverObjectCb cb,
481  void* usr);
482 
485  virtual void addRemoveObjectCallback(
486 #if DtHLA_1516
487  RTI::ObjectInstanceHandle id,
488 #else
489  RTI::ObjectHandle id,
490 #endif
491  DtRemoveObjectCb cb,
492  void* usr);
493 
497  virtual void removeRemoveObjectCallback(
498 #if DtHLA_1516
499  RTI::ObjectInstanceHandle id,
500 #else
501  RTI::ObjectHandle id,
502 #endif
503  DtRemoveObjectCb cb,
504  void* usr);
505 
509  virtual void setDestroyFedExecFlag(bool flag);
510 
512  virtual bool destroyFedExecFlag();
513 
517  virtual void setReplyingToSynchronizationPoints(bool yesNo);
518 
520  virtual bool replyingToSynchronizationPoints();
521 
524  virtual void replyToSynchronizationPoint(const char* label);
525 
530  virtual void setAutoSubscribeFlag(bool flag);
531 
533  virtual bool autoSubscribeFlag() const;
534 
537  virtual void setSendFedTime(bool flag);
538 
540  virtual bool sendFedTime() const;
541 
549  virtual void setUseGeographicDdm(bool flag);
550 
553  virtual bool useGeographicDdm() const;
554 
555  virtual void setDeleteOnOutOfScope(bool yesNo);
556 
557  virtual bool deleteOnOutOfScope() const;
558 
559 #if DtHLA_1516
560  virtual RTI::LogicalTimeFactory *logicalTimeFactory() const;
562 
563 #endif
564 
567  virtual void registerSynchronizationPoint(const DtString& label);
568 
570  virtual void registerSynchronizationPoint(
571  const DtString& label,
572 #if DtHLA_1516
573  const RTI::VariableLengthData& tag);
574 #else
575  const DtString& tag);
576 #endif
577 
579  virtual void addFederateSaveCb(const DtString& label,
580  DtFederateSaveCb func, void* usr);
581  virtual void addFederateSaveCb(DtFederateSaveCb func, void* usr);
582 
584  virtual void addFederateRestoreCb(const DtString& label,
585  DtFederateSaveCb func, void* usr);
586  virtual void addFederateRestoreCb(DtFederateSaveCb func, void* usr);
587 
589  virtual void removeFederateSaveCb(const DtString& label,
590  DtFederateSaveCb func, void* usr);
591  virtual void removeFederateSaveCb(DtFederateSaveCb func, void* usr);
592 
594  virtual void removeFederateRestoreCb(const DtString& label,
595  DtFederateSaveCb func, void* usr);
596  virtual void removeFederateRestoreCb(DtFederateSaveCb func, void* usr);
597 
600  virtual void addSynchPointRegistrationSucceededCb(const DtString& label,
601  DtSynchPointCb func, void* usr);
602 
604  virtual void addSynchPointRegistrationSucceededCb(DtSynchPointCb func,
605  void* usr);
606 
609  virtual void removeSynchPointRegistrationSucceededCb(const DtString& label,
610  DtSynchPointCb func, void* usr);
611 
613  virtual void removeSynchPointRegistrationSucceededCb(DtSynchPointCb func,
614  void* usr);
615 
617  virtual void addSynchPointRegistrationFailedCb(const DtString& label,
618  DtSynchPointCb func, void* usr);
619 
621  virtual void addSynchPointRegistrationFailedCb(DtSynchPointCb func,
622  void* usr);
623 
625  virtual void removeSynchPointRegistrationFailedCb(const DtString& label,
626  DtSynchPointCb func, void* usr);
627 
629  virtual void removeSynchPointRegistrationFailedCb(DtSynchPointCb func,
630  void* usr);
631 
633  virtual void addFederationSynchedCb(const DtString& label,
634  DtSynchPointCb func, void* usr);
635 
637  virtual void addFederationSynchedCb(DtSynchPointCb func,
638  void* usr);
639 
641  virtual void removeFederationSynchedCb(const DtString& label,
642  DtSynchPointCb func, void* usr);
643 
645  virtual void removeFederationSynchedCb(DtSynchPointCb func,
646  void* usr);
647 
652 
653  virtual void addRtiErrorCb(const DtString& label, DtRtiErrorCb func,
654  void* usr);
655  virtual void removeRtiErrorCb(const DtString& label, DtRtiErrorCb func,
656  void* usr);
657  virtual void addRtiErrorCb(DtRtiErrorCb func, void* usr);
658  virtual void removeRtiErrorCb(DtRtiErrorCb func, void* usr);
660 
661 #if DtHLA_1516_EVOLVED
662  virtual void addConnectionLostCb(DtConnectionLostCb func,
664  void* usr);
666  virtual void removeConnectionLostCb(DtConnectionLostCb func, void *usr);
667 #endif
668 
672  virtual void addAnnounceSynchPointCb(const DtString& label,
673  DtAnnounceSynchPointCb func, void* usr);
674 
678  virtual void addAnnounceSynchPointCb(DtAnnounceSynchPointCb func,
679  void* usr);
680 
682  virtual void removeAnnounceSynchPointCb(const DtString& label,
683  DtAnnounceSynchPointCb func, void* usr);
684 
686  virtual void removeAnnounceSynchPointCb(DtAnnounceSynchPointCb func,
687  void* usr);
688 
691  virtual void setDdmPlayBoxLowerBound(const DtGeodeticCoord& bound);
692 
695  virtual void setDdmPlayBoxUpperBound(const DtGeodeticCoord& bound);
696 
699  virtual const DtGeodeticCoord& ddmPlayBoxLowerBound() const;
700 
703  virtual const DtGeodeticCoord& ddmPlayBoxUpperBound() const;
704 
713  virtual void setObjectTagModifier(const DtString& className,
714  DtObjectTagModifierSP modifier, bool applyToSubClasses = true);
715 
724  virtual void setInteractionTagModifier(const DtString& className,
725  DtInteractionTagModifierSP modifier, bool applyToSubClasses = true);
726 
738 
739  virtual void setGetValueMethod( DtExerciseConnInitializer::DtGetValueMethod getValueMethodChoice );
740  virtual DtExerciseConnInitializer::DtGetValueMethod getValueMethod( ) const;
742 
744  virtual void setExecutionStatus(DtVRLExecutionStatus status);
745 
747  virtual bool isInitialized() const;
748 
749 public:
750 
751 #if DtHLA_1516
752  static void setLogicalTimeFactoryFactoryParameter(std::wstring);
756 
758  static std::wstring logicalTimeFactoryFactoryParameter();
759 #endif
760  static void setFedAmbCreator(DtFedAmbCreator creator);
764 
766  static DtFedAmbCreator fedAmbCreator();
767 
771  static void setRtiAmbCreator(DtRtiAmbCreator creator);
772 
774  static DtRtiAmbCreator rtiAmbCreator();
775 
780  static void overrideRidParameters(const std::map<DtString, DtString>& ridParams);
781 
790  static void setFomMapperCreator(DtFomMapperCreator creator,
791  void* usr = 0);
792 
794  static DtFomMapperCreator fomMapperCreator();
795 
797  static DtFomMapper* defaultFomMapper();
798 
806 #if DtHLA_1516
807  static void setLogicalTimeToVrlTimeConverter(DtLogicalTimeToVrlTimeConverter func);
808  static DtLogicalTimeToVrlTimeConverter logicalTimeToVrlTimeConverter();
809 #else
810  static void setFedTimeToVrlTimeConverter(DtFedTimeToVrlTimeConverter func);
811  static DtFedTimeToVrlTimeConverter fedTimeToVrlTimeConverter();
812 #endif
813 
820 #if DtHLA_1516
821  static void setVrlTimeToLogicalTimeConverter(DtVrlTimeToLogicalTimeConverter func);
822  static DtVrlTimeToLogicalTimeConverter vrlTimeToLogicalTimeConverter();
823 #else
824  static void setVrlTimeToFedTimeConverter(DtVrlTimeToFedTimeConverter func);
825  static DtVrlTimeToFedTimeConverter vrlTimeToFedTimeConverter();
826 #endif
827 
834 #if DtHLA_1516
835  static DtTime defaultDtLogicalTimeToVrlTimeConverter( const RTI::LogicalTime &time);
836 #else
837  static DtTime defaultDtFedTimeToVrlTimeConverter( const RTI::FedTime &time);
838 #endif
839 
841 #if DtHLA_1516
842  static std::unique_ptr<RTI::LogicalTime> defaultVrlTimeToLogicalTimeConverter(
843  const DtTime &time);
844 #else
845  static RTI::FedTime* defaultVrlTimeToFedTimeConverter(const DtTime &time);
846 #endif
847 
849  static DtString vrlinkVersion();
850 
854  virtual bool callRtiErrorCallback(DtString &label);
855 
856 protected:
857 
858  // Check if the RTI version supports 64-bit alignment for getValuePointer.
860  bool checkRtiVersionForPointerAlignment();
861 
863  void initializeConnection(InitializationStatus* result);
864 
867  void initializeFomMapper(const char* dsoName, void* fomMapInitData,
868  InitializationStatus* result);
869 
873  void getFuncsFromSharedLib(DtDynamicLibrary& dso,
874  DtFomMapperCreator* creator,
875  DtFomMapperDeletor* deletor);
876 
877 
880  void handleFedFile(const DtString& fedFileName);
881 
886  int initFom(InitializationStatus* result);
887 
891  int createRtiAmb(InitializationStatus* result);
892 
898  int connectRtiAmb(InitializationStatus* result);
899 
904  int createFedEx(InitializationStatus* result);
905 
908  int createFedAmb(InitializationStatus* result);
909 
913  int joinFedEx(InitializationStatus* result);
914 
918  bool fedFileExists(const DtFilename &name) const;
919 
920 #if DtHLA_1516_EVOLVED
921  void setFomModules(const std::vector<DtString>& modules);
924 
926  void resignAndDisconnect();
927 #endif
928 
932 #if DtHLA_1516
933  virtual void rtiSend(DtInteraction& msg, RTI::InteractionClassHandle handle,
934  const RTI::RegionHandleSet* region);
935 #else
936  virtual void rtiSend(DtInteraction& msg, RTI::InteractionClassHandle handle,
937  const RTI::Region* region);
938 #endif
939 
941 #if DtHLA_1516
942  virtual void selfReflectInteraction(DtInteraction& msg, RTI::InteractionClassHandle handle,
943  const RTI::RegionHandleSet* region);
944 #else
945  virtual void selfReflectInteraction(DtInteraction& msg, RTI::InteractionClassHandle handle,
946  const RTI::Region* region);
947 #endif
948 
949 protected:
950 
952  static void replyToSyncPointCallback(void* usr);
953 
954 protected:
955 
956  struct DtGeneralRtiErrorCbInfo
957  {
958  DtRtiErrorCb cbFunction;
959  void* userData;
960  };
961 
962  struct DtLabelledRtiErrorCbInfo
963  {
964  DtString label;
965  DtRtiErrorCb cbFunction;
966  void* userData;
967  };
968 
969  DtString myExecName;
970 
971  DtString myFedType;
972 #if DtHLA_1516_EVOLVED
973  DtString myFedName;
978 #endif
979 #if DtHLA_4
980  std::unique_ptr<RTI::LogicalTimeFactory> myLogicalTimeFactory;
981 #elif DtHLA_1516
982  std::unique_ptr<RTI::LogicalTimeFactory> myLogicalTimeFactory;
983 #endif
984  DtVrlRtiAmbassador* myRtiAmb;
985  RTI::FederateHandle myFedHandle;
986  DtVrlFederateAmbassador* myFedAmb;
987 
988  DtFom* myFom;
989 
990  DtHlaObjectManager* myHlaObjectManager;
991  DtInteractionManager* myInteractionManager;
992  DtOwnershipHandler* myOwnershipHandler;
993 
994  DtFomMapper* myFomMapper;
995  DtDynamicLibrary *myFomMapperDso;
996  DtFomMapperCreator myDsoCreator;
997  DtFomMapperDeletor myDsoDeletor;
998 
999  DtEventID myCurrentEventId;
1000  DtTimeStampType myRelOrAbs;
1001 
1002  bool myDestroyFedExFlag;
1003  bool myUseFomMapperDeletor;
1004 
1005  bool myGenericAttributes;
1006  bool myPassiveMode;
1007  bool myReflecting;
1008  bool myReflectRemoteUpdatesIntoPubFlag;
1009  bool myReflectingThroughRti;
1010  bool myReplyingToSynchronizationPoints;
1011  bool myUsingAdvisories;
1012  bool myAutoSubscribeFlag;
1013  bool mySendFedTimeFlag;
1014  DtExerciseConnInitializer::DtGetValueMethod myGetValueMethod;
1015  bool myPauseOnSaveRestore;
1016 
1017  bool myUseGeographicDdm;
1018  bool myDeleteOnOutOfScope;
1019 #if DtHLA_1516_EVOLVED
1020  bool myIsConnected;
1022 #endif
1023 
1025  DtString myRtiError;
1026 
1028  DtString myFedFile;
1029 
1030 #if DtHLA_1516_EVOLVED
1031  std::vector<std::wstring> myFomModules;
1032  std::wstring myMimFomModule;
1033 
1034  std::wstring myLocalSettingsDesignator;
1035 #elif DtHLA_1516
1036  std::vector<std::wstring> myRtiArguments;
1037 #endif
1038 
1039 #if DtHLA_1516
1040  RTI::VariableLengthData myTag;
1041 #else
1042  DtString myTag;
1043 #endif
1044 
1048  DtGeodeticCoord myDdmPlayBoxLowerBound;
1049 
1053  DtGeodeticCoord myDdmPlayBoxUpperBound;
1054 
1055  std::list<DtGeneralRtiErrorCbInfo> myRtiErrorCbList;
1056  std::list<DtLabelledRtiErrorCbInfo> myLabRtiErrorCbList;
1057 
1058  DtVRLinkStateManager* myVrlStateManager;
1059 
1060 protected:
1061 
1062  static std::wstring myLogicalTimeFactFactParam;
1063  static DtFedAmbCreator theFedAmbCreator;
1064  static DtRtiAmbCreator theRtiAmbCreator;
1065  static DtFomMapperCreator theFomMapperCreator;
1066  static DtFomMapper* theDefaultFomMapper;
1067  static void* theFomMapInitData;
1068 #if DtHLA_1516
1069  static DtVrlTimeToLogicalTimeConverter theVrlTimeToLogicalTimeConverter;
1070  static DtLogicalTimeToVrlTimeConverter theLogicalTimeToVrlTimeConverter;
1071 #else
1072  static DtVrlTimeToFedTimeConverter theVrlTimeToFedTimeConverter;
1073  static DtFedTimeToVrlTimeConverter theFedTimeToVrlTimeConverter;
1074 #endif
1075 
1076 };
1077 
1078 inline DtVrlRtiAmbassador* DtExerciseConn::rtiAmb()
1079 {
1080  return myRtiAmb;
1081 }
1082 
1083 inline DtVrlFederateAmbassador* DtExerciseConn::fedAmb()
1084 {
1085  return myFedAmb;
1086 }
1087 
1088 inline DtHlaObjectManager* DtExerciseConn::hlaObjectManager()
1089 {
1090  return myHlaObjectManager;
1091 }
1092 
1093 inline DtFom* DtExerciseConn::fom()
1094 {
1095  return myFom;
1096 }
1097 
1098 inline RTI::FederateHandle DtExerciseConn::fedHandle() const
1099 {
1100  return myFedHandle;
1101 }
1102 
1103 #if DtHLA_1516_EVOLVED
1104 inline const DtString& DtExerciseConn::fedName() const
1105 {
1106  return myFedName;
1107 }
1108 #endif
1109 
1110 inline const DtString& DtExerciseConn::fedType() const
1111 {
1112  return myFedType;
1113 }
1114 
1115 inline const DtString& DtExerciseConn::execName() const
1116 {
1117  return myExecName;
1118 }
1119 
1120 
1121 inline void DtExerciseConn::setSendFedTime(bool flag)
1122 {
1123  mySendFedTimeFlag = flag;
1124 }
1125 
1126 inline bool DtExerciseConn::sendFedTime() const
1127 {
1128  return mySendFedTimeFlag;
1129 }
1130 
1131 inline void DtExerciseConn::setUseGeographicDdm(bool flag)
1132 {
1133  myUseGeographicDdm = flag;
1134 }
1135 
1136 inline bool DtExerciseConn::useGeographicDdm() const
1137 {
1138  return myUseGeographicDdm;
1139 }
1140 
1141 inline void DtExerciseConn::setDeleteOnOutOfScope(bool yesNo)
1142 {
1143  myDeleteOnOutOfScope = yesNo;
1144 }
1145 
1146 inline bool DtExerciseConn::deleteOnOutOfScope() const
1147 {
1148  return myDeleteOnOutOfScope;
1149 }
1150 
1151 #endif
1152 #endif
1153 
DtInteraction
DtInteraction is an base class for representing DIS PDUs which don&#39;t have state.
Definition: interactionDIS.h:24
exerciseConnInitializerHLA.h
Contains the HLA DtExerciseConnInitializer class declaration.
DtExerciseConn
Instances of DtExerciseConn are used to provide an application&#39;s interface or connection to the netwo...
Definition: exerciseConnDIS.h:62
vrlFederateAmbassador.h
A protocol independent (HLA13/HLA1516/HLA1516e/HLA1516_2025) file for the VR-Link FedAmb...
DT_DLL_VL
#define DT_DLL_VL
Definition: vlMachineTypes.h:108
DtExerciseConnInitializer
Instances of DtExerciseConnInitializer are used to provide the DtExerciseConn with initialization dat...
Definition: exerciseConnInitializerDIS.h:36
DtBaseExerciseConn::operator=
DtBaseExerciseConn & operator=(const DtBaseExerciseConn &)
Assignment Operator – Not Implemented.
DtBaseExerciseConn
DtBaseExerciseConn is an abstract base class.
Definition: baseExerciseConn.h:31
geodeticCoord.h
This file provides a definition of GeodeticCoords and several helper functions.
DtGeodeticCoord
Instances of DtGeodeticCoord are used to explicitly represent Geodetic coordinates.
Definition: geodeticCoord.h:30
vlVersion.h
This file declares macros which specify the VR-Link version.
DtBaseExerciseConn::sendStamped
virtual void sendStamped(const DtStateMsg &msg)=0
Send a state message to the network which has been time stamped with the current time.
rprFomMapper.h
Contains the DtRprFomMapper class declaration.
DtBaseExerciseConn::send
virtual void send(const DtStateMsg &msg)=0
Send a state message to the network.
DtEventId
Represents Events in DIS.
Definition: eventId.h:154
DtEntityIdentifier
Instances of DtEntityIdentifier are used as a unique ID for entities in DIS.
Definition: entityIdentifier.h:31
DtFilename
Instances of DtFilename are DtStrings which convert filenames to the native format.
Definition: vlFilename.h:20
netnFomMapper.h
Contains the DtNetnFomMapper class declaration.
DtOwnershipHandler
This is a base class meant to encapsulate user callbacks on ownership management services.
Definition: ownershipHandlerDIS.h:39
DtDynamicLibrary
DtDynamicLibrary provides an operating independent way to manipulate dynamically loaded libraries...
Definition: vlDynamic.h:23
DtTimeStampType
DtTimeStampType
Definition: vlTimeStampType.h:16
DtTime
DtReal DtTime
A definition of DtTime.
Definition: vlTime.h:19
eventId.h
Contains the DtEventId class declaration.
DtString
Instances of DtString are used to represent strings.
Definition: vlString.h:36
vrlRtiAmbassador.h
This file provides protocol independence for the DtVrlRtiAmbassador class.
baseExerciseConn.h
This file provides a declaration of the class DtBaseExerciseConn.
DtStateMsg
Instances of DtStateMsg are used to represent state data communicated via the network in a DIS (as op...
Definition: stateMsgDIS.h:21
callbacks.h
This file is used as a convenience to group RTI related callbacks together.
userTagModifiers.h
This file contains declarations of the classes DtObjectTagModifier and DtInteractionTagModifier.
Document ID: Generated on Thu Oct 16 00:12:25 EDT 2025 from SVN revision 280738
Copyright © 1992-2025 MAK Technologies. All Rights Reserved (www.mak.com)