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-2010 VT MAK
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 "rtiCompatibility.h"
18 #include "eventId.h"
19 #include "vrlFederateAmbassador.h"
20 #include "vrlRtiAmbassador.h"
21 #include "exerciseConnInitializerHLA.h"
22 #include "vrlinkStateStateRepository.h"
23 
24 #include <matrix/geodeticCoord.h>
25 #include <vlutil/vlVersion.h>
26 #include "userTagModifiers.h"
27 
28 
29 class DtInteraction;
30 class DtInteractionFactory;
31 class DtHlaObjectFactory;
32 class DtInteractionManager;
33 class DtHlaObjectManager;
34 class DtStateMsg;
35 class DtVrlFederateAmbassador;
36 class DtFom;
37 class DtFilename;
38 class DtDynamicLibrary;
39 class DtFomMapper;
40 class DtVRLinkStateManager;
41 
42 
43 
60 class DT_DLL_VL DtExerciseConn : public DtBaseExerciseConn
61 {
62 
63 public:
64 
65  typedef DtVrlFederateAmbassador* (*DtFedAmbCreator)();
66  typedef DtFomMapper* (*DtFomMapperCreator)(void* usr);
67  typedef void (*DtFomMapperDeletor)(DtFomMapper*);
68 
69  typedef void (*DtRtiErrorCb)(const char* label, void* usr);
70 
73  typedef DtVrlRtiAmbassador* (*DtRtiAmbCreator)(const std::vector<std::wstring>&);
74 
75 #if DtHLA_1516
76  typedef DtTime (*DtLogicalTimeToVrlTimeConverter) (const RTI::LogicalTime &theLogicalTime);
77  typedef std::auto_ptr<RTI::LogicalTime>(*DtVrlTimeToLogicalTimeConverter) (const DtTime &time);
78 #else
79  typedef DtTime (*DtFedTimeToVrlTimeConverter) (const RTI::FedTime &theFedTIme);
80  typedef RTI::FedTime* (*DtVrlTimeToFedTimeConverter) (const DtTime &time);
81 #endif
82 
92  enum InitializationStatus {
93  DtINIT_SUCCESS = 0,
94  DtCOULD_NOT_CREATE_RTIAMB = 1,
95  DtCOULD_NOT_CREATE_FEDEX = 2,
96  DtCOULD_NOT_JOIN_FEDEX = 3,
97  DtCOULD_NOT_OPEN_FED = 4,
98  DtCOULD_NOT_PARSE_FED = 5,
99  DtCOULD_NOT_FIND_FOMMAPPER = 6,
100  DtERROR_OPENING_FOMMAPPER_LIB = 7,
101  DtCOULD_NOT_CONNECT_RTIAMB = 8
102 
103  };
104 
105 public:
106 
109  DtExerciseConn(const DtExerciseConnInitializer& init, InitializationStatus* status = 0);
110 
122  DtExerciseConn(const char* execName,
123  const char* federateType,
124  DtFomMapper* mapper = DtRprFomMapper::create(0),
125  const char* fedFileName = 0,
126  InitializationStatus* status = 0
127  );
128 
136  DtExerciseConn(const char* execName,
137  const char* federateType,
138  const char* dsoName,
139  const char* fedFileName = 0,
140  void* fomMapInitData = 0,
141  InitializationStatus* status = 0
142  );
143 
144 #if DtHLA_1516_EVOLVED
145 
146 
151 
162  DtExerciseConn(const char* execName,
163  const char* federateName,
164  const char* federateType,
165  const DtString& fedFile,
166  DtFomMapper* mapper = DtRprFomMapper::create(0),
167  const DtString mimModule = "",
168  const std::vector<DtString>& fomModules = std::vector<DtString>(),
169  InitializationStatus* status = 0 );
170 
171 
176 
183  DtExerciseConn(const char* execName,
184  const char* federateName,
185  const char* federateType,
186  const DtString& fedFile,
187  const char* dsoName,
188  void* fomMapInitData = 0,
189  const DtString mimModule = "",
190  const std::vector<DtString>& fomModules = std::vector<DtString>(),
191  InitializationStatus* status = 0 );
192 #endif
193 
195  virtual ~DtExerciseConn();
196 
197 private:
198 
200  DtExerciseConn(const DtExerciseConn& orig);
201 
203  DtExerciseConn& operator=(const DtExerciseConn& orig);
204 
205 public:
206 
216  virtual void setReflecting();
217 
219  virtual bool reflecting() const;
220 
227  virtual void setPassiveMode();
228 
230  virtual bool passiveMode() const;
231 
235 
236  virtual void setDefaultOwnershipHandler(DtOwnershipHandler* ownershipHandler);
237  virtual DtOwnershipHandler* defaultOwnershipHandler();
239 
251  virtual void setReflectRemoteUpdatesIntoPubFlag(bool onff);
252 
254  virtual bool reflectRemoteUpdatesIntoPubFlag() const;
255 
260  virtual void setReflectingThroughRti();
261 
263  virtual bool reflectingThroughRti() const;
264 
274  virtual void ignoreAdvisories();
275 
277  virtual bool usingAdvisories() const;
278 
279  virtual void setRemoveObjectOnAttOutOfScope(bool remove);
280 
287  virtual bool enabledGenericAttributes() const;
288 
289 #if DtHLA_1516_EVOLVED
290  void listFederationExecutions();
292 #endif
293 
297  virtual void send(const DtStateMsg& msg);
298 
304  virtual void send(const DtInteraction& msg);
305 
309 #if DtHLA_1516
310  virtual void send(const DtInteraction& msg,
311  const RTI::RegionHandleSet* region);
312 #else
313  virtual void send(const DtInteraction& msg,
314  const RTI::Region* region);
315 #endif
316 
321  virtual void sendStamped(const DtStateMsg& msg);
322 
327  virtual void sendStamped(const DtInteraction& msg);
328 
332  virtual void sendStampedWithRegion(const DtInteraction& msg,
333  DtDDMRegionSP region);
334 
339 #if DtHLA_1516
340  virtual void sendStamped(const DtInteraction& msg,
341  const RTI::RegionHandleSet* region);
342 #else
343  virtual void sendStamped(const DtInteraction& msg,
344  const RTI::Region* region);
345 #endif
346 
349  virtual DtTime currentTimeForStamping();
350 
365  virtual int drainInput(DtTime maxTime = -1, DtTime minTime = 0.0);
366 
368  virtual void setObjectIdForEventId(const DtGlobalObjectDesignator& id);
369 
371  virtual const DtEventID& nextEventId();
372 
375  virtual DtVrlRtiAmbassador* rtiAmb();
376 
379  virtual DtVrlFederateAmbassador* fedAmb();
380 
382  virtual RTI::FederateHandle fedHandle() const;
383 
385  virtual const DtString& fedType() const;
386 
387 #if DtHLA_1516_EVOLVED
388  virtual const DtString& fedName() const;
391 #endif
392 
394  virtual const DtString& execName() const;
395 
397  virtual bool isUsingMakRti() const;
398 
402  virtual DtString rtiName() const;
403 
407  virtual DtString rtiVersion() const;
408 
411  virtual DtString rtiError() const;
412 
414  virtual DtFom* fom();
415 
417  virtual DtInteractionFactory* interactionFactory();
418 
420  virtual DtHlaObjectFactory* objectFactory();
421 
423  virtual DtFomMapper* fomMapper() const;
424 
426  virtual DtHlaObjectManager* hlaObjectManager();
427 
429  virtual void setTimeStampType(DtTimeStampType relOrAbs);
430 
432  virtual DtTimeStampType timeStampType() const;
433 
438  virtual void addInteractionCallback(RTI::InteractionClassHandle h,
439  DtReceiveInteractionCb cb,
440  void* usr,
441  DtDDMRegionSP region = DtDDMRegionSP());
442 
447  virtual void addInteractionCallbackByName(const char* className,
448  DtReceiveInteractionCb cb,
449  void* usr,
450  DtDDMRegionSP region = DtDDMRegionSP());
451 
456  virtual void removeInteractionCallback(RTI::InteractionClassHandle h,
457  DtReceiveInteractionCb cb,
458  void* usr,
459  DtDDMRegionSP region = DtDDMRegionSP());
460 
465  virtual void removeInteractionCallbackByName(const char* className,
466  DtReceiveInteractionCb cb,
467  void* usr, DtDDMRegionSP region = DtDDMRegionSP());
468 
471  virtual void addDiscoverObjectCallback(RTI::ObjectClassHandle h,
472  DtDiscoverObjectCb cb,
473  void* usr);
474 
478  virtual void removeDiscoverObjectCallback(RTI::ObjectClassHandle h,
479  DtDiscoverObjectCb cb,
480  void* usr);
481 
484  virtual void addRemoveObjectCallback(
485 #if DtHLA_1516
486  RTI::ObjectInstanceHandle id,
487 #else
488  RTI::ObjectHandle id,
489 #endif
490  DtRemoveObjectCb cb,
491  void* usr);
492 
496  virtual void removeRemoveObjectCallback(
497 #if DtHLA_1516
498  RTI::ObjectInstanceHandle id,
499 #else
500  RTI::ObjectHandle id,
501 #endif
502  DtRemoveObjectCb cb,
503  void* usr);
504 
508  virtual void setDestroyFedExecFlag(bool flag);
509 
511  virtual bool destroyFedExecFlag();
512 
516  virtual void setReplyingToSynchronizationPoints(bool yesNo);
517 
519  virtual bool replyingToSynchronizationPoints();
520 
523  virtual void replyToSynchronizationPoint(const char* label);
524 
529  virtual void setAutoSubscribeFlag(bool flag);
530 
532  virtual bool autoSubscribeFlag() const;
533 
536  virtual void setSendFedTime(bool flag);
537 
539  virtual bool sendFedTime() const;
540 
548  virtual void setUseGeographicDdm(bool flag);
549 
552  virtual bool useGeographicDdm() const;
553 
554  virtual void setDeleteOnOutOfScope(bool yesNo);
555 
556  virtual bool deleteOnOutOfScope() const;
557 
558 #if DtHLA_1516
559  virtual RTI::LogicalTimeFactory *logicalTimeFactory() const;
561 
562 #endif
563 
566  virtual void registerSynchronizationPoint(const DtString& label);
567 
569  virtual void registerSynchronizationPoint(
570  const DtString& label,
571 #if DtHLA_1516
572  const RTI::VariableLengthData& tag);
573 #else
574  const DtString& tag);
575 #endif
576 
578  virtual void addFederateSaveCb(const DtString& label,
579  DtFederateSaveCb func, void* usr);
580  virtual void addFederateSaveCb(DtFederateSaveCb func, void* usr);
581 
583  virtual void addFederateRestoreCb(const DtString& label,
584  DtFederateSaveCb func, void* usr);
585  virtual void addFederateRestoreCb(DtFederateSaveCb func, void* usr);
586 
588  virtual void removeFederateSaveCb(const DtString& label,
589  DtFederateSaveCb func, void* usr);
590  virtual void removeFederateSaveCb(DtFederateSaveCb func, void* usr);
591 
593  virtual void removeFederateRestoreCb(const DtString& label,
594  DtFederateSaveCb func, void* usr);
595  virtual void removeFederateRestoreCb(DtFederateSaveCb func, void* usr);
596 
599  virtual void addSynchPointRegistrationSucceededCb(const DtString& label,
600  DtSynchPointCb func, void* usr);
601 
603  virtual void addSynchPointRegistrationSucceededCb(DtSynchPointCb func,
604  void* usr);
605 
608  virtual void removeSynchPointRegistrationSucceededCb(const DtString& label,
609  DtSynchPointCb func, void* usr);
610 
612  virtual void removeSynchPointRegistrationSucceededCb(DtSynchPointCb func,
613  void* usr);
614 
616  virtual void addSynchPointRegistrationFailedCb(const DtString& label,
617  DtSynchPointCb func, void* usr);
618 
620  virtual void addSynchPointRegistrationFailedCb(DtSynchPointCb func,
621  void* usr);
622 
624  virtual void removeSynchPointRegistrationFailedCb(const DtString& label,
625  DtSynchPointCb func, void* usr);
626 
628  virtual void removeSynchPointRegistrationFailedCb(DtSynchPointCb func,
629  void* usr);
630 
632  virtual void addFederationSynchedCb(const DtString& label,
633  DtSynchPointCb func, void* usr);
634 
636  virtual void addFederationSynchedCb(DtSynchPointCb func,
637  void* usr);
638 
640  virtual void removeFederationSynchedCb(const DtString& label,
641  DtSynchPointCb func, void* usr);
642 
644  virtual void removeFederationSynchedCb(DtSynchPointCb func,
645  void* usr);
646 
651 
652  virtual void addRtiErrorCb(const DtString& label, DtRtiErrorCb func,
653  void* usr);
654  virtual void removeRtiErrorCb(const DtString& label, DtRtiErrorCb func,
655  void* usr);
656  virtual void addRtiErrorCb(DtRtiErrorCb func, void* usr);
657  virtual void removeRtiErrorCb(DtRtiErrorCb func, void* usr);
659 
660 #if DtHLA_1516_EVOLVED
661  virtual void addConnectionLostCb(DtConnectionLostCb func,
663  void* usr);
665  virtual void removeConnectionLostCb(DtConnectionLostCb func, void *usr);
666 #endif
667 
671  virtual void addAnnounceSynchPointCb(const DtString& label,
672  DtAnnounceSynchPointCb func, void* usr);
673 
677  virtual void addAnnounceSynchPointCb(DtAnnounceSynchPointCb func,
678  void* usr);
679 
681  virtual void removeAnnounceSynchPointCb(const DtString& label,
682  DtAnnounceSynchPointCb func, void* usr);
683 
685  virtual void removeAnnounceSynchPointCb(DtAnnounceSynchPointCb func,
686  void* usr);
687 
690  virtual void setDdmPlayBoxLowerBound(const DtGeodeticCoord& bound);
691 
694  virtual void setDdmPlayBoxUpperBound(const DtGeodeticCoord& bound);
695 
698  virtual const DtGeodeticCoord& ddmPlayBoxLowerBound() const;
699 
702  virtual const DtGeodeticCoord& ddmPlayBoxUpperBound() const;
703 
712  virtual void setObjectTagModifier(const DtString& className,
713  DtObjectTagModifierSP modifier, bool applyToSubClasses = true);
714 
723  virtual void setInteractionTagModifier(const DtString& className,
724  DtInteractionTagModifierSP modifier, bool applyToSubClasses = true);
725 
737 
738  virtual void setGetValueMethod( DtExerciseConnInitializer::DtGetValueMethod getValueMethodChoice );
739  virtual DtExerciseConnInitializer::DtGetValueMethod getValueMethod( ) const;
741 
743  virtual void setExecutionStatus(DtVRLExecutionStatus status);
744 
746  virtual bool isInitialized() const;
747 
748 public:
749 
750 #if DtHLA_1516
751  static void setLogicalTimeFactoryFactoryParameter(std::wstring);
755 
757  static std::wstring logicalTimeFactoryFactoryParameter();
758 #endif
759  static void setFedAmbCreator(DtFedAmbCreator creator);
763 
765  static DtFedAmbCreator fedAmbCreator();
766 
770  static void setRtiAmbCreator(DtRtiAmbCreator creator);
771 
773  static DtRtiAmbCreator rtiAmbCreator();
774 
779  static void overrideRidParameters(const std::map<DtString, DtString>& ridParams);
780 
789  static void setFomMapperCreator(DtFomMapperCreator creator,
790  void* usr = 0);
791 
793  static DtFomMapperCreator fomMapperCreator();
794 
802 #if DtHLA_1516
803  static void setLogicalTimeToVrlTimeConverter(DtLogicalTimeToVrlTimeConverter func);
804  static DtLogicalTimeToVrlTimeConverter logicalTimeToVrlTimeConverter();
805 #else
806  static void setFedTimeToVrlTimeConverter(DtFedTimeToVrlTimeConverter func);
807  static DtFedTimeToVrlTimeConverter fedTimeToVrlTimeConverter();
808 #endif
809 
816 #if DtHLA_1516
817  static void setVrlTimeToLogicalTimeConverter(DtVrlTimeToLogicalTimeConverter func);
818  static DtVrlTimeToLogicalTimeConverter vrlTimeToLogicalTimeConverter();
819 #else
820  static void setVrlTimeToFedTimeConverter(DtVrlTimeToFedTimeConverter func);
821  static DtVrlTimeToFedTimeConverter vrlTimeToFedTimeConverter();
822 #endif
823 
830 #if DtHLA_1516
831  static DtTime defaultDtLogicalTimeToVrlTimeConverter( const RTI::LogicalTime &time);
832 #else
833  static DtTime defaultDtFedTimeToVrlTimeConverter( const RTI::FedTime &time);
834 #endif
835 
837 #if DtHLA_1516
838  static std::auto_ptr<RTI::LogicalTime> defaultVrlTimeToLogicalTimeConverter(
839  const DtTime &time);
840 #else
841  static RTI::FedTime* defaultVrlTimeToFedTimeConverter(const DtTime &time);
842 #endif
843 
845  static DtString vrlinkVersion();
846 
850  virtual bool callRtiErrorCallback(DtString &label);
851 
852 protected:
853 
854  // Check if the RTI version supports 64-bit alignment for getValuePointer.
856  bool checkRtiVersionForPointerAlignment();
857 
859  void initializeConnection(InitializationStatus* result);
860 
863  void initializeFomMapper(const char* dsoName, void* fomMapInitData,
864  InitializationStatus* result);
865 
869  void getFuncsFromSharedLib(DtDynamicLibrary& dso,
870  DtFomMapperCreator* creator,
871  DtFomMapperDeletor* deletor);
872 
873 
876  void handleFedFile(const DtString& fedFileName);
877 
882  int initFom(InitializationStatus* result);
883 
887  int createRtiAmb(InitializationStatus* result);
888 
894  int connectRtiAmb(InitializationStatus* result);
895 
900  int createFedEx(InitializationStatus* result);
901 
904  int createFedAmb(InitializationStatus* result);
905 
909  int joinFedEx(InitializationStatus* result);
910 
914  bool fedFileExists(const DtFilename &name) const;
915 
916 #if DtHLA_1516_EVOLVED
917  void setFomModules(const std::vector<DtString>& modules);
920 
922  void resignAndDisconnect();
923 #endif
924 
928 #if DtHLA_1516
929  virtual void rtiSend(DtInteraction& msg, RTI::InteractionClassHandle handle,
930  const RTI::RegionHandleSet* region);
931 #else
932  virtual void rtiSend(DtInteraction& msg, RTI::InteractionClassHandle handle,
933  const RTI::Region* region);
934 #endif
935 
937 #if DtHLA_1516
938  virtual void selfReflectInteraction(DtInteraction& msg, RTI::InteractionClassHandle handle,
939  const RTI::RegionHandleSet* region);
940 #else
941  virtual void selfReflectInteraction(DtInteraction& msg, RTI::InteractionClassHandle handle,
942  const RTI::Region* region);
943 #endif
944 
945 protected:
946 
948  static void replyToSyncPointCallback(void* usr);
949 
950 protected:
951 
952  struct DtGeneralRtiErrorCbInfo
953  {
954  DtRtiErrorCb cbFunction;
955  void* userData;
956  };
957 
958  struct DtLabelledRtiErrorCbInfo
959  {
960  DtString label;
961  DtRtiErrorCb cbFunction;
962  void* userData;
963  };
964 
965  DtString myExecName;
966 
967  DtString myFedType;
968 #if DtHLA_1516_EVOLVED
969  DtString myFedName;
974 #endif
975 #if DtHLA_1516
976  std::auto_ptr<RTI::LogicalTimeFactory> myLogicalTimeFactory;
977 #endif
978  DtVrlRtiAmbassador* myRtiAmb;
979  RTI::FederateHandle myFedHandle;
980  DtVrlFederateAmbassador* myFedAmb;
981 
982  DtFom* myFom;
983 
984  DtHlaObjectManager* myHlaObjectManager;
985  DtInteractionManager* myInteractionManager;
986  DtOwnershipHandler* myOwnershipHandler;
987 
988  DtFomMapper* myFomMapper;
989  DtDynamicLibrary *myFomMapperDso;
990  DtFomMapperCreator myDsoCreator;
991  DtFomMapperDeletor myDsoDeletor;
992 
993  DtEventID myCurrentEventId;
994  DtTimeStampType myRelOrAbs;
995 
996  bool myDestroyFedExFlag;
997  bool myUseFomMapperDeletor;
998 
999  bool myGenericAttributes;
1000  bool myPassiveMode;
1001  bool myReflecting;
1002  bool myReflectRemoteUpdatesIntoPubFlag;
1003  bool myReflectingThroughRti;
1004  bool myReplyingToSynchronizationPoints;
1005  bool myUsingAdvisories;
1006  bool myAutoSubscribeFlag;
1007  bool mySendFedTimeFlag;
1008  DtExerciseConnInitializer::DtGetValueMethod myGetValueMethod;
1009  bool myPauseOnSaveRestore;
1010 
1011  bool myUseGeographicDdm;
1012  bool myDeleteOnOutOfScope;
1013 #if DtHLA_1516_EVOLVED
1014  bool myIsConnected;
1016 #endif
1017 
1019  DtString myRtiError;
1020 
1022  DtString myFedFile;
1023 
1024 #if DtHLA_1516_EVOLVED
1025  std::vector<std::wstring> myFomModules;
1026  std::wstring myMimFomModule;
1027 
1028  std::wstring myLocalSettingsDesignator;
1029 #elif DtHLA_1516
1030  std::vector<std::wstring> myRtiArguments;
1031 #endif
1032 
1033 #if DtHLA_1516
1034  RTI::VariableLengthData myTag;
1035 #else
1036  DtString myTag;
1037 #endif
1038 
1042  DtGeodeticCoord myDdmPlayBoxLowerBound;
1043 
1047  DtGeodeticCoord myDdmPlayBoxUpperBound;
1048 
1049  std::list<DtGeneralRtiErrorCbInfo> myRtiErrorCbList;
1050  std::list<DtLabelledRtiErrorCbInfo> myLabRtiErrorCbList;
1051 
1052  DtVRLinkStateManager* myVrlStateManager;
1053 
1054 protected:
1055 
1056  static std::wstring myLogicalTimeFactFactParam;
1057  static DtFedAmbCreator theFedAmbCreator;
1058  static DtRtiAmbCreator theRtiAmbCreator;
1059  static DtFomMapperCreator theFomMapperCreator;
1060  static void* theFomMapInitData;
1061 #if DtHLA_1516
1062  static DtVrlTimeToLogicalTimeConverter theVrlTimeToLogicalTimeConverter;
1063  static DtLogicalTimeToVrlTimeConverter theLogicalTimeToVrlTimeConverter;
1064 #else
1065  static DtVrlTimeToFedTimeConverter theVrlTimeToFedTimeConverter;
1066  static DtFedTimeToVrlTimeConverter theFedTimeToVrlTimeConverter;
1067 #endif
1068 
1069 };
1070 
1071 inline DtVrlRtiAmbassador* DtExerciseConn::rtiAmb()
1072 {
1073  return myRtiAmb;
1074 }
1075 
1076 inline DtVrlFederateAmbassador* DtExerciseConn::fedAmb()
1077 {
1078  return myFedAmb;
1079 }
1080 
1081 inline DtHlaObjectManager* DtExerciseConn::hlaObjectManager()
1082 {
1083  return myHlaObjectManager;
1084 }
1085 
1086 inline DtFom* DtExerciseConn::fom()
1087 {
1088  return myFom;
1089 }
1090 
1091 inline RTI::FederateHandle DtExerciseConn::fedHandle() const
1092 {
1093  return myFedHandle;
1094 }
1095 
1096 #if DtHLA_1516_EVOLVED
1097 inline const DtString& DtExerciseConn::fedName() const
1098 {
1099  return myFedName;
1100 }
1101 #endif
1102 
1103 inline const DtString& DtExerciseConn::fedType() const
1104 {
1105  return myFedType;
1106 }
1107 
1108 inline const DtString& DtExerciseConn::execName() const
1109 {
1110  return myExecName;
1111 }
1112 
1113 
1114 inline void DtExerciseConn::setSendFedTime(bool flag)
1115 {
1116  mySendFedTimeFlag = flag;
1117 }
1118 
1119 inline bool DtExerciseConn::sendFedTime() const
1120 {
1121  return mySendFedTimeFlag;
1122 }
1123 
1124 inline void DtExerciseConn::setUseGeographicDdm(bool flag)
1125 {
1126  myUseGeographicDdm = flag;
1127 }
1128 
1129 inline bool DtExerciseConn::useGeographicDdm() const
1130 {
1131  return myUseGeographicDdm;
1132 }
1133 
1134 inline void DtExerciseConn::setDeleteOnOutOfScope(bool yesNo)
1135 {
1136  myDeleteOnOutOfScope = yesNo;
1137 }
1138 
1139 inline bool DtExerciseConn::deleteOnOutOfScope() const
1140 {
1141  return myDeleteOnOutOfScope;
1142 }
1143 
1144 #endif
1145 #endif
1146 
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:61
vrlFederateAmbassador.h
A protocol independent (HLA13/HLA1516) 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
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:29
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 Mon Apr 25 03:39:01 EDT 2022 from SVN revision 242502
Copyright © 2005-2021 MAK Technologies. All Rights Reserved (www.mak.com)