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 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::auto_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::auto_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_1516
980  std::auto_ptr<RTI::LogicalTimeFactory> myLogicalTimeFactory;
981 #endif
982  DtVrlRtiAmbassador* myRtiAmb;
983  RTI::FederateHandle myFedHandle;
984  DtVrlFederateAmbassador* myFedAmb;
985 
986  DtFom* myFom;
987 
988  DtHlaObjectManager* myHlaObjectManager;
989  DtInteractionManager* myInteractionManager;
990  DtOwnershipHandler* myOwnershipHandler;
991 
992  DtFomMapper* myFomMapper;
993  DtDynamicLibrary *myFomMapperDso;
994  DtFomMapperCreator myDsoCreator;
995  DtFomMapperDeletor myDsoDeletor;
996 
997  DtEventID myCurrentEventId;
998  DtTimeStampType myRelOrAbs;
999 
1000  bool myDestroyFedExFlag;
1001  bool myUseFomMapperDeletor;
1002 
1003  bool myGenericAttributes;
1004  bool myPassiveMode;
1005  bool myReflecting;
1006  bool myReflectRemoteUpdatesIntoPubFlag;
1007  bool myReflectingThroughRti;
1008  bool myReplyingToSynchronizationPoints;
1009  bool myUsingAdvisories;
1010  bool myAutoSubscribeFlag;
1011  bool mySendFedTimeFlag;
1012  DtExerciseConnInitializer::DtGetValueMethod myGetValueMethod;
1013  bool myPauseOnSaveRestore;
1014 
1015  bool myUseGeographicDdm;
1016  bool myDeleteOnOutOfScope;
1017 #if DtHLA_1516_EVOLVED
1018  bool myIsConnected;
1020 #endif
1021 
1023  DtString myRtiError;
1024 
1026  DtString myFedFile;
1027 
1028 #if DtHLA_1516_EVOLVED
1029  std::vector<std::wstring> myFomModules;
1030  std::wstring myMimFomModule;
1031 
1032  std::wstring myLocalSettingsDesignator;
1033 #elif DtHLA_1516
1034  std::vector<std::wstring> myRtiArguments;
1035 #endif
1036 
1037 #if DtHLA_1516
1038  RTI::VariableLengthData myTag;
1039 #else
1040  DtString myTag;
1041 #endif
1042 
1046  DtGeodeticCoord myDdmPlayBoxLowerBound;
1047 
1051  DtGeodeticCoord myDdmPlayBoxUpperBound;
1052 
1053  std::list<DtGeneralRtiErrorCbInfo> myRtiErrorCbList;
1054  std::list<DtLabelledRtiErrorCbInfo> myLabRtiErrorCbList;
1055 
1056  DtVRLinkStateManager* myVrlStateManager;
1057 
1058 protected:
1059 
1060  static std::wstring myLogicalTimeFactFactParam;
1061  static DtFedAmbCreator theFedAmbCreator;
1062  static DtRtiAmbCreator theRtiAmbCreator;
1063  static DtFomMapperCreator theFomMapperCreator;
1064  static DtFomMapper* theDefaultFomMapper;
1065  static void* theFomMapInitData;
1066 #if DtHLA_1516
1067  static DtVrlTimeToLogicalTimeConverter theVrlTimeToLogicalTimeConverter;
1068  static DtLogicalTimeToVrlTimeConverter theLogicalTimeToVrlTimeConverter;
1069 #else
1070  static DtVrlTimeToFedTimeConverter theVrlTimeToFedTimeConverter;
1071  static DtFedTimeToVrlTimeConverter theFedTimeToVrlTimeConverter;
1072 #endif
1073 
1074 };
1075 
1076 inline DtVrlRtiAmbassador* DtExerciseConn::rtiAmb()
1077 {
1078  return myRtiAmb;
1079 }
1080 
1081 inline DtVrlFederateAmbassador* DtExerciseConn::fedAmb()
1082 {
1083  return myFedAmb;
1084 }
1085 
1086 inline DtHlaObjectManager* DtExerciseConn::hlaObjectManager()
1087 {
1088  return myHlaObjectManager;
1089 }
1090 
1091 inline DtFom* DtExerciseConn::fom()
1092 {
1093  return myFom;
1094 }
1095 
1096 inline RTI::FederateHandle DtExerciseConn::fedHandle() const
1097 {
1098  return myFedHandle;
1099 }
1100 
1101 #if DtHLA_1516_EVOLVED
1102 inline const DtString& DtExerciseConn::fedName() const
1103 {
1104  return myFedName;
1105 }
1106 #endif
1107 
1108 inline const DtString& DtExerciseConn::fedType() const
1109 {
1110  return myFedType;
1111 }
1112 
1113 inline const DtString& DtExerciseConn::execName() const
1114 {
1115  return myExecName;
1116 }
1117 
1118 
1119 inline void DtExerciseConn::setSendFedTime(bool flag)
1120 {
1121  mySendFedTimeFlag = flag;
1122 }
1123 
1124 inline bool DtExerciseConn::sendFedTime() const
1125 {
1126  return mySendFedTimeFlag;
1127 }
1128 
1129 inline void DtExerciseConn::setUseGeographicDdm(bool flag)
1130 {
1131  myUseGeographicDdm = flag;
1132 }
1133 
1134 inline bool DtExerciseConn::useGeographicDdm() const
1135 {
1136  return myUseGeographicDdm;
1137 }
1138 
1139 inline void DtExerciseConn::setDeleteOnOutOfScope(bool yesNo)
1140 {
1141  myDeleteOnOutOfScope = yesNo;
1142 }
1143 
1144 inline bool DtExerciseConn::deleteOnOutOfScope() const
1145 {
1146  return myDeleteOnOutOfScope;
1147 }
1148 
1149 #endif
1150 #endif
1151 
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) 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: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 Wed Mar 27 02:04:30 EDT 2024 from SVN revision 264570
Copyright © 2005-2024 MAK Technologies. All Rights Reserved (www.mak.com)