VR-Link API Documentation for DIS
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
iffDataReflected.h
Go to the documentation of this file.
1 /*********************************************************************
2 ** Copyright (c) 2020 MAK Technologies, Inc
3 ** All rights reserved.
4 *********************************************************************/
5 
6 #pragma once
7 
8 #if DtHLA
9 
10 #include <vl/reflectedObjectHLA.h>
11 #include <vl/reflectedObjectListHLA.h>
12 #include <vl/IFFDataStateRepository.h>
13 #include <vl/iffMode1StateRepository.h>
14 #include <vl/iffMode2StateRepository.h>
15 #include <vl/iffMode3AStateRepository.h>
16 #include <vl/iffMode3CStateRepository.h>
17 #include <vl/iffMode4StateRepository.h>
18 #include <vl/iffMode5StateRepository.h>
19 #include <vl/iffModeSStateRepository.h>
20 #include <vl/iffTCASDataStateRepository.h>
21 #include <vl/iffSovietStateRepository.h>
22 #include <vl/iffRRBStateRepository.h>
23 
24 
25 class DT_DLL_VL DtReflectedIFFData;
26 class DT_DLL_VL DtReflectedMode1;
27 class DT_DLL_VL DtReflectedMode2;
28 class DT_DLL_VL DtReflectedMode3A;
29 class DT_DLL_VL DtReflectedMode3C;
30 class DT_DLL_VL DtReflectedMode4;
31 class DT_DLL_VL DtReflectedMode5;
32 class DT_DLL_VL DtReflectedModeS;
33 class DT_DLL_VL DtReflectedTCASData;
34 class DT_DLL_VL DtReflectedSoviet;
35 class DT_DLL_VL DtReflectedRRB;
36 
37 /******************** DtReflectedIFFData *********************/
38 
42 typedef void(*DtIFFDataCallbackFunction)(
43  DtReflectedIFFData* obj, void* userData);
44 
49 class DT_DLL_VL DtReflectedIFFData : public DtReflectedObject
50 {
51 public:
54  typedef DtIFFDataStateRepository* (*DtStateRepCreator)();
55 
56 public:
58  DtReflectedIFFData(DtHlaObject* obj, DtExerciseConn* exConn);
59 
61  virtual ~DtReflectedIFFData();
62 
64  virtual DtIFFDataStateRepository* IFFDataStateRep() const;
65 
67  virtual DtIFFDataStateRepository* Isr() const;
68 
71  virtual DtReflectedIFFData* next() const;
72 
75  virtual DtReflectedIFFData* prev() const;
76 
79  virtual DtReflectedIFFData* wrapNext() const;
80 
83  virtual DtReflectedIFFData* wrapPrev() const;
84 
87  virtual void addPostUpdateCallback(
88  DtIFFDataCallbackFunction cb, void* userData);
89 
92  virtual void removePostUpdateCallback(
93  DtIFFDataCallbackFunction cb, void* userData);
94 
95 public:
97  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
98 
99 protected:
101  DtReflectedIFFData(const DtReflectedIFFData& orig);
102 
104  DtReflectedIFFData& operator=(const DtReflectedIFFData& orig);
105 
106 protected:
108  static DtStateRepCreator theStateRepCreator;
109 };
110 
111 inline DtIFFDataStateRepository* DtReflectedIFFData::IFFDataStateRep() const
112 {
113  return (DtIFFDataStateRepository*)myStateRep;
114 }
115 
116 inline DtIFFDataStateRepository* DtReflectedIFFData::Isr() const
117 {
118  return (DtIFFDataStateRepository*)myStateRep;
119 }
120 
121 /******************** DtReflectedIFFDataList *********************/
122 
126 class DT_DLL_VL DtReflectedIFFDataList : public DtReflectedObjectList
127 {
128 public:
130  DtReflectedIFFDataList(DtExerciseConn* exConn,
131  const DtDDMRegionSet* regionSetToUse = 0);
132 
135  DtReflectedIFFDataList(DtExerciseConn* exConn,
136  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
137 
139  virtual ~DtReflectedIFFDataList();
140 
141 private:
142 
144  DtReflectedIFFDataList(const DtReflectedIFFDataList& orig);
145 
147  DtReflectedIFFDataList& operator=(const DtReflectedIFFDataList&orig);
148 
149 public:
150 
152  virtual DtReflectedIFFData* lookup(
153 #if DtHLA_1516
154  RTI::ObjectInstanceHandle id);
155 #else
156  RTI::ObjectHandle id);
157 #endif
158 
160  virtual DtReflectedIFFData* lookup(
161  const DtGlobalObjectDesignator& objName);
162 
164  virtual DtReflectedIFFData* first() const;
165 
167  virtual DtReflectedIFFData* last() const;
168 
170  virtual void addIFFDataAdditionCallback(
171  DtIFFDataCallbackFunction cb, void* userData);
172 
174  virtual void removeIFFDataAdditionCallback(
175  DtIFFDataCallbackFunction cb, void* userData);
176 
178  virtual void addIFFDataRemovalCallback(
179  DtIFFDataCallbackFunction cb, void* userData);
180 
182  virtual void removeIFFDataRemovalCallback(
183  DtIFFDataCallbackFunction cb, void* userData);
184 
185 protected:
186 
188  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
189 
194  virtual void objectAdded(DtReflectedObject* obj);
195 
198  virtual const DtList* dfltHandleList();
199 
200 };
201 
202 /******************** DtReflectedMode1 *********************/
203 
207 typedef void(*DtMode1CallbackFunction)(
208  DtReflectedMode1* obj, void* userData);
209 
214 class DT_DLL_VL DtReflectedMode1 : public DtReflectedObject
215 {
216 public:
219  typedef DtMode1StateRepository* (*DtStateRepCreator)();
220 
221 public:
223  DtReflectedMode1(DtHlaObject* obj, DtExerciseConn* exConn);
224 
226  virtual ~DtReflectedMode1();
227 
229  virtual DtMode1StateRepository* mode1StateRep() const;
230 
232  virtual DtMode1StateRepository* msr() const;
233 
236  virtual DtReflectedMode1* next() const;
237 
240  virtual DtReflectedMode1* prev() const;
241 
244  virtual DtReflectedMode1* wrapNext() const;
245 
248  virtual DtReflectedMode1* wrapPrev() const;
249 
252  virtual void addPostUpdateCallback(
253  DtMode1CallbackFunction cb, void* userData);
254 
257  virtual void removePostUpdateCallback(
258  DtMode1CallbackFunction cb, void* userData);
259 
260 public:
262  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
263 
264 protected:
266  DtReflectedMode1(const DtReflectedMode1& orig);
267 
269  DtReflectedMode1& operator=(const DtReflectedMode1& orig);
270 
271 protected:
273  static DtStateRepCreator theStateRepCreator;
274 };
275 
276 inline DtMode1StateRepository* DtReflectedMode1::mode1StateRep() const
277 {
278  return (DtMode1StateRepository*)myStateRep;
279 }
280 
281 inline DtMode1StateRepository* DtReflectedMode1::msr() const
282 {
283  return (DtMode1StateRepository*)myStateRep;
284 }
285 
286 /******************** DtReflectedMode1List *********************/
287 
291 class DT_DLL_VL DtReflectedMode1List : public DtReflectedObjectList
292 {
293 public:
295  DtReflectedMode1List(DtExerciseConn* exConn,
296  const DtDDMRegionSet* regionSetToUse = 0);
297 
300  DtReflectedMode1List(DtExerciseConn* exConn,
301  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
302 
304  virtual ~DtReflectedMode1List();
305 
306 private:
307 
309  DtReflectedMode1List(const DtReflectedMode1List& orig);
310 
312  DtReflectedMode1List& operator=(const DtReflectedMode1List&orig);
313 
314 public:
315 
317  virtual DtReflectedMode1* lookup(
318 #if DtHLA_1516
319  RTI::ObjectInstanceHandle id);
320 #else
321  RTI::ObjectHandle id);
322 #endif
323 
325  virtual DtReflectedMode1* lookup(
326  const DtGlobalObjectDesignator& objName);
327 
329  virtual DtReflectedMode1* first() const;
330 
332  virtual DtReflectedMode1* last() const;
333 
335  virtual void addMode1AdditionCallback(
336  DtMode1CallbackFunction cb, void* userData);
337 
339  virtual void removeMode1AdditionCallback(
340  DtMode1CallbackFunction cb, void* userData);
341 
343  virtual void addMode1RemovalCallback(
344  DtMode1CallbackFunction cb, void* userData);
345 
347  virtual void removeMode1RemovalCallback(
348  DtMode1CallbackFunction cb, void* userData);
349 
350 protected:
351 
353  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
354 
359  virtual void objectAdded(DtReflectedObject* obj);
360 
363  virtual const DtList* dfltHandleList();
364 
365 };
366 
367 /******************** DtReflectedMode2 *********************/
368 
372 typedef void(*DtMode2CallbackFunction)(
373  DtReflectedMode2* obj, void* userData);
374 
379 class DT_DLL_VL DtReflectedMode2 : public DtReflectedObject
380 {
381 public:
384  typedef DtMode2StateRepository* (*DtStateRepCreator)();
385 
386 public:
388  DtReflectedMode2(DtHlaObject* obj, DtExerciseConn* exConn);
389 
391  virtual ~DtReflectedMode2();
392 
394  virtual DtMode2StateRepository* mode2StateRep() const;
395 
397  virtual DtMode2StateRepository* msr() const;
398 
401  virtual DtReflectedMode2* next() const;
402 
405  virtual DtReflectedMode2* prev() const;
406 
409  virtual DtReflectedMode2* wrapNext() const;
410 
413  virtual DtReflectedMode2* wrapPrev() const;
414 
417  virtual void addPostUpdateCallback(
418  DtMode2CallbackFunction cb, void* userData);
419 
422  virtual void removePostUpdateCallback(
423  DtMode2CallbackFunction cb, void* userData);
424 
425 public:
427  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
428 
429 protected:
431  DtReflectedMode2(const DtReflectedMode2& orig);
432 
434  DtReflectedMode2& operator=(const DtReflectedMode2& orig);
435 
436 protected:
438  static DtStateRepCreator theStateRepCreator;
439 };
440 
441 inline DtMode2StateRepository* DtReflectedMode2::mode2StateRep() const
442 {
443  return (DtMode2StateRepository*)myStateRep;
444 }
445 
446 inline DtMode2StateRepository* DtReflectedMode2::msr() const
447 {
448  return (DtMode2StateRepository*)myStateRep;
449 }
450 
451 /******************** DtReflectedMode2List *********************/
452 
456 class DT_DLL_VL DtReflectedMode2List : public DtReflectedObjectList
457 {
458 public:
460  DtReflectedMode2List(DtExerciseConn* exConn,
461  const DtDDMRegionSet* regionSetToUse = 0);
462 
465  DtReflectedMode2List(DtExerciseConn* exConn,
466  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
467 
469  virtual ~DtReflectedMode2List();
470 
471 private:
472 
474  DtReflectedMode2List(const DtReflectedMode2List& orig);
475 
477  DtReflectedMode2List& operator=(const DtReflectedMode2List&orig);
478 
479 public:
480 
482  virtual DtReflectedMode2* lookup(
483 #if DtHLA_1516
484  RTI::ObjectInstanceHandle id);
485 #else
486  RTI::ObjectHandle id);
487 #endif
488 
490  virtual DtReflectedMode2* lookup(
491  const DtGlobalObjectDesignator& objName);
492 
494  virtual DtReflectedMode2* first() const;
495 
497  virtual DtReflectedMode2* last() const;
498 
500  virtual void addMode2AdditionCallback(
501  DtMode2CallbackFunction cb, void* userData);
502 
504  virtual void removeMode2AdditionCallback(
505  DtMode2CallbackFunction cb, void* userData);
506 
508  virtual void addMode2RemovalCallback(
509  DtMode2CallbackFunction cb, void* userData);
510 
512  virtual void removeMode2RemovalCallback(
513  DtMode2CallbackFunction cb, void* userData);
514 
515 protected:
516 
518  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
519 
524  virtual void objectAdded(DtReflectedObject* obj);
525 
528  virtual const DtList* dfltHandleList();
529 
530 };
531 
532 /******************** DtReflectedMode3A *********************/
533 
537 typedef void(*DtMode3ACallbackFunction)(
538  DtReflectedMode3A* obj, void* userData);
539 
544 class DT_DLL_VL DtReflectedMode3A : public DtReflectedObject
545 {
546 public:
549  typedef DtMode3AStateRepository* (*DtStateRepCreator)();
550 
551 public:
553  DtReflectedMode3A(DtHlaObject* obj, DtExerciseConn* exConn);
554 
556  virtual ~DtReflectedMode3A();
557 
559  virtual DtMode3AStateRepository* mode3AStateRep() const;
560 
562  virtual DtMode3AStateRepository* msr() const;
563 
566  virtual DtReflectedMode3A* next() const;
567 
570  virtual DtReflectedMode3A* prev() const;
571 
574  virtual DtReflectedMode3A* wrapNext() const;
575 
578  virtual DtReflectedMode3A* wrapPrev() const;
579 
582  virtual void addPostUpdateCallback(
583  DtMode3ACallbackFunction cb, void* userData);
584 
587  virtual void removePostUpdateCallback(
588  DtMode3ACallbackFunction cb, void* userData);
589 
590 public:
592  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
593 
594 protected:
596  DtReflectedMode3A(const DtReflectedMode3A& orig);
597 
599  DtReflectedMode3A& operator=(const DtReflectedMode3A& orig);
600 
601 protected:
603  static DtStateRepCreator theStateRepCreator;
604 };
605 
606 inline DtMode3AStateRepository* DtReflectedMode3A::mode3AStateRep() const
607 {
608  return (DtMode3AStateRepository*)myStateRep;
609 }
610 
611 inline DtMode3AStateRepository* DtReflectedMode3A::msr() const
612 {
613  return (DtMode3AStateRepository*)myStateRep;
614 }
615 
616 /******************** DtReflectedMode3AList *********************/
617 
621 class DT_DLL_VL DtReflectedMode3AList : public DtReflectedObjectList
622 {
623 public:
625  DtReflectedMode3AList(DtExerciseConn* exConn,
626  const DtDDMRegionSet* regionSetToUse = 0);
627 
630  DtReflectedMode3AList(DtExerciseConn* exConn,
631  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
632 
634  virtual ~DtReflectedMode3AList();
635 
636 private:
637 
639  DtReflectedMode3AList(const DtReflectedMode3AList& orig);
640 
642  DtReflectedMode3AList& operator=(const DtReflectedMode3AList&orig);
643 
644 public:
645 
647  virtual DtReflectedMode3A* lookup(
648 #if DtHLA_1516
649  RTI::ObjectInstanceHandle id);
650 #else
651  RTI::ObjectHandle id);
652 #endif
653 
655  virtual DtReflectedMode3A* lookup(
656  const DtGlobalObjectDesignator& objName);
657 
659  virtual DtReflectedMode3A* first() const;
660 
662  virtual DtReflectedMode3A* last() const;
663 
665  virtual void addMode3AAdditionCallback(
666  DtMode3ACallbackFunction cb, void* userData);
667 
669  virtual void removeMode3AAdditionCallback(
670  DtMode3ACallbackFunction cb, void* userData);
671 
673  virtual void addMode3ARemovalCallback(
674  DtMode3ACallbackFunction cb, void* userData);
675 
677  virtual void removeMode3ARemovalCallback(
678  DtMode3ACallbackFunction cb, void* userData);
679 
680 protected:
681 
683  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
684 
689  virtual void objectAdded(DtReflectedObject* obj);
690 
693  virtual const DtList* dfltHandleList();
694 
695 };
696 
697 /******************** DtReflectedMode3C *********************/
698 
702 typedef void(*DtMode3CCallbackFunction)(
703  DtReflectedMode3C* obj, void* userData);
704 
709 class DT_DLL_VL DtReflectedMode3C : public DtReflectedObject
710 {
711 public:
714  typedef DtMode3CStateRepository* (*DtStateRepCreator)();
715 
716 public:
718  DtReflectedMode3C(DtHlaObject* obj, DtExerciseConn* exConn);
719 
721  virtual ~DtReflectedMode3C();
722 
724  virtual DtMode3CStateRepository* Mode3CStateRep() const;
725 
727  virtual DtMode3CStateRepository* msr() const;
728 
731  virtual DtReflectedMode3C* next() const;
732 
735  virtual DtReflectedMode3C* prev() const;
736 
739  virtual DtReflectedMode3C* wrapNext() const;
740 
743  virtual DtReflectedMode3C* wrapPrev() const;
744 
747  virtual void addPostUpdateCallback(
748  DtMode3CCallbackFunction cb, void* userData);
749 
752  virtual void removePostUpdateCallback(
753  DtMode3CCallbackFunction cb, void* userData);
754 
755 public:
757  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
758 
759 protected:
761  DtReflectedMode3C(const DtReflectedMode3C& orig);
762 
764  DtReflectedMode3C& operator=(const DtReflectedMode3C& orig);
765 
766 protected:
768  static DtStateRepCreator theStateRepCreator;
769 };
770 
771 inline DtMode3CStateRepository* DtReflectedMode3C::Mode3CStateRep() const
772 {
773  return (DtMode3CStateRepository*)myStateRep;
774 }
775 
776 inline DtMode3CStateRepository* DtReflectedMode3C::msr() const
777 {
778  return (DtMode3CStateRepository*)myStateRep;
779 }
780 
781 /******************** DtReflectedMode3CList *********************/
782 
786 class DT_DLL_VL DtReflectedMode3CList : public DtReflectedObjectList
787 {
788 public:
790  DtReflectedMode3CList(DtExerciseConn* exConn,
791  const DtDDMRegionSet* regionSetToUse = 0);
792 
795  DtReflectedMode3CList(DtExerciseConn* exConn,
796  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
797 
799  virtual ~DtReflectedMode3CList();
800 
801 private:
802 
804  DtReflectedMode3CList(const DtReflectedMode3CList& orig);
805 
807  DtReflectedMode3CList& operator=(const DtReflectedMode3CList&orig);
808 
809 public:
810 
812  virtual DtReflectedMode3C* lookup(
813 #if DtHLA_1516
814  RTI::ObjectInstanceHandle id);
815 #else
816  RTI::ObjectHandle id);
817 #endif
818 
820  virtual DtReflectedMode3C* lookup(
821  const DtGlobalObjectDesignator& objName);
822 
824  virtual DtReflectedMode3C* first() const;
825 
827  virtual DtReflectedMode3C* last() const;
828 
830  virtual void addMode3CAdditionCallback(
831  DtMode3CCallbackFunction cb, void* userData);
832 
834  virtual void removeMode3CAdditionCallback(
835  DtMode3CCallbackFunction cb, void* userData);
836 
838  virtual void addMode3CRemovalCallback(
839  DtMode3CCallbackFunction cb, void* userData);
840 
842  virtual void removeMode3CRemovalCallback(
843  DtMode3CCallbackFunction cb, void* userData);
844 
845 protected:
846 
848  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
849 
854  virtual void objectAdded(DtReflectedObject* obj);
855 
858  virtual const DtList* dfltHandleList();
859 
860 };
861 
862 /******************** DtReflectedMode4 *********************/
863 
867 typedef void(*DtMode4CallbackFunction)(
868  DtReflectedMode4* obj, void* userData);
869 
874 class DT_DLL_VL DtReflectedMode4 : public DtReflectedObject
875 {
876 public:
879  typedef DtMode4StateRepository* (*DtStateRepCreator)();
880 
881 public:
883  DtReflectedMode4(DtHlaObject* obj, DtExerciseConn* exConn);
884 
886  virtual ~DtReflectedMode4();
887 
889  virtual DtMode4StateRepository* mode4StateRep() const;
890 
892  virtual DtMode4StateRepository* msr() const;
893 
896  virtual DtReflectedMode4* next() const;
897 
900  virtual DtReflectedMode4* prev() const;
901 
904  virtual DtReflectedMode4* wrapNext() const;
905 
908  virtual DtReflectedMode4* wrapPrev() const;
909 
912  virtual void addPostUpdateCallback(
913  DtMode4CallbackFunction cb, void* userData);
914 
917  virtual void removePostUpdateCallback(
918  DtMode4CallbackFunction cb, void* userData);
919 
920 public:
922  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
923 
924 protected:
926  DtReflectedMode4(const DtReflectedMode4& orig);
927 
929  DtReflectedMode4& operator=(const DtReflectedMode4& orig);
930 
931 protected:
933  static DtStateRepCreator theStateRepCreator;
934 };
935 
936 inline DtMode4StateRepository* DtReflectedMode4::mode4StateRep() const
937 {
938  return (DtMode4StateRepository*)myStateRep;
939 }
940 
941 inline DtMode4StateRepository* DtReflectedMode4::msr() const
942 {
943  return (DtMode4StateRepository*)myStateRep;
944 }
945 
946 /******************** DtReflectedMode4List *********************/
947 
951 class DT_DLL_VL DtReflectedMode4List : public DtReflectedObjectList
952 {
953 public:
955  DtReflectedMode4List(DtExerciseConn* exConn,
956  const DtDDMRegionSet* regionSetToUse = 0);
957 
960  DtReflectedMode4List(DtExerciseConn* exConn,
961  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
962 
964  virtual ~DtReflectedMode4List();
965 
966 private:
967 
969  DtReflectedMode4List(const DtReflectedMode4List& orig);
970 
972  DtReflectedMode4List& operator=(const DtReflectedMode4List&orig);
973 
974 public:
975 
977  virtual DtReflectedMode4* lookup(
978 #if DtHLA_1516
979  RTI::ObjectInstanceHandle id);
980 #else
981  RTI::ObjectHandle id);
982 #endif
983 
985  virtual DtReflectedMode4* lookup(
986  const DtGlobalObjectDesignator& objName);
987 
989  virtual DtReflectedMode4* first() const;
990 
992  virtual DtReflectedMode4* last() const;
993 
995  virtual void addMode4AdditionCallback(
996  DtMode4CallbackFunction cb, void* userData);
997 
999  virtual void removeMode4AdditionCallback(
1000  DtMode4CallbackFunction cb, void* userData);
1001 
1003  virtual void addMode4RemovalCallback(
1004  DtMode4CallbackFunction cb, void* userData);
1005 
1007  virtual void removeMode4RemovalCallback(
1008  DtMode4CallbackFunction cb, void* userData);
1009 
1010 protected:
1011 
1013  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
1014 
1019  virtual void objectAdded(DtReflectedObject* obj);
1020 
1023  virtual const DtList* dfltHandleList();
1024 
1025 };
1026 
1027 /******************** DtReflectedMode5 *********************/
1028 
1032 typedef void(*DtMode5CallbackFunction)(
1033  DtReflectedMode5* obj, void* userData);
1034 
1039 class DT_DLL_VL DtReflectedMode5 : public DtReflectedObject
1040 {
1041 public:
1044  typedef DtMode5StateRepository* (*DtStateRepCreator)();
1045 
1046 public:
1048  DtReflectedMode5(DtHlaObject* obj, DtExerciseConn* exConn);
1049 
1051  virtual ~DtReflectedMode5();
1052 
1054  virtual DtMode5StateRepository* mode5StateRep() const;
1055 
1057  virtual DtMode5StateRepository* msr() const;
1058 
1061  virtual DtReflectedMode5* next() const;
1062 
1065  virtual DtReflectedMode5* prev() const;
1066 
1069  virtual DtReflectedMode5* wrapNext() const;
1070 
1073  virtual DtReflectedMode5* wrapPrev() const;
1074 
1077  virtual void addPostUpdateCallback(
1078  DtMode5CallbackFunction cb, void* userData);
1079 
1082  virtual void removePostUpdateCallback(
1083  DtMode5CallbackFunction cb, void* userData);
1084 
1085 public:
1087  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
1088 
1089 protected:
1091  DtReflectedMode5(const DtReflectedMode5& orig);
1092 
1094  DtReflectedMode5& operator=(const DtReflectedMode5& orig);
1095 
1096 protected:
1098  static DtStateRepCreator theStateRepCreator;
1099 };
1100 
1101 inline DtMode5StateRepository* DtReflectedMode5::mode5StateRep() const
1102 {
1103  return (DtMode5StateRepository*)myStateRep;
1104 }
1105 
1106 inline DtMode5StateRepository* DtReflectedMode5::msr() const
1107 {
1108  return (DtMode5StateRepository*)myStateRep;
1109 }
1110 
1111 /******************** DtReflectedMode5List *********************/
1112 
1116 class DT_DLL_VL DtReflectedMode5List : public DtReflectedObjectList
1117 {
1118 public:
1120  DtReflectedMode5List(DtExerciseConn* exConn,
1121  const DtDDMRegionSet* regionSetToUse = 0);
1122 
1125  DtReflectedMode5List(DtExerciseConn* exConn,
1126  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
1127 
1129  virtual ~DtReflectedMode5List();
1130 
1131 private:
1132 
1134  DtReflectedMode5List(const DtReflectedMode5List& orig);
1135 
1137  DtReflectedMode5List& operator=(const DtReflectedMode5List&orig);
1138 
1139 public:
1140 
1142  virtual DtReflectedMode5* lookup(
1143 #if DtHLA_1516
1144  RTI::ObjectInstanceHandle id);
1145 #else
1146  RTI::ObjectHandle id);
1147 #endif
1148 
1150  virtual DtReflectedMode5* lookup(
1151  const DtGlobalObjectDesignator& objName);
1152 
1154  virtual DtReflectedMode5* first() const;
1155 
1157  virtual DtReflectedMode5* last() const;
1158 
1160  virtual void addMode5AdditionCallback(
1161  DtMode5CallbackFunction cb, void* userData);
1162 
1164  virtual void removeMode5AdditionCallback(
1165  DtMode5CallbackFunction cb, void* userData);
1166 
1168  virtual void addMode5RemovalCallback(
1169  DtMode5CallbackFunction cb, void* userData);
1170 
1172  virtual void removeMode5RemovalCallback(
1173  DtMode5CallbackFunction cb, void* userData);
1174 
1175 protected:
1176 
1178  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
1179 
1184  virtual void objectAdded(DtReflectedObject* obj);
1185 
1188  virtual const DtList* dfltHandleList();
1189 
1190 };
1191 
1192 /******************** DtReflectedModeS *********************/
1193 
1197 typedef void(*DtModeSCallbackFunction)(
1198  DtReflectedModeS* obj, void* userData);
1199 
1204 class DT_DLL_VL DtReflectedModeS : public DtReflectedObject
1205 {
1206 public:
1209  typedef DtModeSStateRepository* (*DtStateRepCreator)();
1210 
1211 public:
1213  DtReflectedModeS(DtHlaObject* obj, DtExerciseConn* exConn);
1214 
1216  virtual ~DtReflectedModeS();
1217 
1219  virtual DtModeSStateRepository* modeSStateRep() const;
1220 
1222  virtual DtModeSStateRepository* msr() const;
1223 
1226  virtual DtReflectedModeS* next() const;
1227 
1230  virtual DtReflectedModeS* prev() const;
1231 
1234  virtual DtReflectedModeS* wrapNext() const;
1235 
1238  virtual DtReflectedModeS* wrapPrev() const;
1239 
1242  virtual void addPostUpdateCallback(
1243  DtModeSCallbackFunction cb, void* userData);
1244 
1247  virtual void removePostUpdateCallback(
1248  DtModeSCallbackFunction cb, void* userData);
1249 
1250 public:
1252  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
1253 
1254 protected:
1256  DtReflectedModeS(const DtReflectedModeS& orig);
1257 
1259  DtReflectedModeS& operator=(const DtReflectedModeS& orig);
1260 
1261 protected:
1263  static DtStateRepCreator theStateRepCreator;
1264 };
1265 
1266 inline DtModeSStateRepository* DtReflectedModeS::modeSStateRep() const
1267 {
1268  return (DtModeSStateRepository*)myStateRep;
1269 }
1270 
1271 inline DtModeSStateRepository* DtReflectedModeS::msr() const
1272 {
1273  return (DtModeSStateRepository*)myStateRep;
1274 }
1275 
1276 /******************** DtReflectedModeSList *********************/
1277 
1281 class DT_DLL_VL DtReflectedModeSList : public DtReflectedObjectList
1282 {
1283 public:
1285  DtReflectedModeSList(DtExerciseConn* exConn,
1286  const DtDDMRegionSet* regionSetToUse = 0);
1287 
1290  DtReflectedModeSList(DtExerciseConn* exConn,
1291  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
1292 
1294  virtual ~DtReflectedModeSList();
1295 
1296 private:
1297 
1299  DtReflectedModeSList(const DtReflectedModeSList& orig);
1300 
1302  DtReflectedModeSList& operator=(const DtReflectedModeSList&orig);
1303 
1304 public:
1305 
1307  virtual DtReflectedModeS* lookup(
1308 #if DtHLA_1516
1309  RTI::ObjectInstanceHandle id);
1310 #else
1311  RTI::ObjectHandle id);
1312 #endif
1313 
1315  virtual DtReflectedModeS* lookup(
1316  const DtGlobalObjectDesignator& objName);
1317 
1319  virtual DtReflectedModeS* first() const;
1320 
1322  virtual DtReflectedModeS* last() const;
1323 
1325  virtual void addModeSAdditionCallback(
1326  DtModeSCallbackFunction cb, void* userData);
1327 
1329  virtual void removeModeSAdditionCallback(
1330  DtModeSCallbackFunction cb, void* userData);
1331 
1333  virtual void addModeSRemovalCallback(
1334  DtModeSCallbackFunction cb, void* userData);
1335 
1337  virtual void removeModeSRemovalCallback(
1338  DtModeSCallbackFunction cb, void* userData);
1339 
1340 protected:
1341 
1343  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
1344 
1349  virtual void objectAdded(DtReflectedObject* obj);
1350 
1353  virtual const DtList* dfltHandleList();
1354 
1355 };
1356 
1357 /******************** DtReflectedSoviet *********************/
1358 /*
1362 typedef void(*DtSovietInterrogatorCallbackFunction)(
1363  DtReflectedSovietInterrogator* obj, void* userData);
1364 
1369 class DT_DLL_VL DtReflectedSovietInterrogator : public DtReflectedObject
1370 {
1371 public:
1374  typedef DtSovietInterrogatorStateRepository* (*DtStateRepCreator)();
1375 
1376 public:
1378  DtReflectedSovietInterrogator(DtHlaObject* obj, DtExerciseConn* exConn);
1379 
1381  virtual ~DtReflectedSovietInterrogator();
1382 
1384  virtual DtSovietInterrogatorStateRepository* sovietInterrogatorStateRep() const;
1385 
1387  virtual DtSovietInterrogatorStateRepository* ssr() const;
1388 
1391  virtual DtReflectedSovietInterrogator* next() const;
1392 
1395  virtual DtReflectedSovietInterrogator* prev() const;
1396 
1399  virtual DtReflectedSovietInterrogator* wrapNext() const;
1400 
1403  virtual DtReflectedSovietInterrogator* wrapPrev() const;
1404 
1407  virtual void addPostUpdateCallback(
1408  DtSovietInterrogatorCallbackFunction cb, void* userData);
1409 
1412  virtual void removePostUpdateCallback(
1413  DtSovietInterrogatorCallbackFunction cb, void* userData);
1414 
1415 public:
1417  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
1418 
1419 protected:
1421  DtReflectedSovietInterrogator(const DtReflectedSovietInterrogator& orig);
1422 
1424  DtReflectedSovietInterrogator& operator=(const DtReflectedSovietInterrogator& orig);
1425 
1426 protected:
1428  static DtStateRepCreator theStateRepCreator;
1429 };
1430 
1431 inline DtSovietInterrogatorStateRepository* DtReflectedSovietInterrogator::sovietInterrogatorStateRep() const
1432 {
1433  return (DtSovietInterrogatorStateRepository*)myStateRep;
1434 }
1435 
1436 inline DtSovietInterrogatorStateRepository* DtReflectedSovietInterrogator::ssr() const
1437 {
1438  return (DtSovietInterrogatorStateRepository*)myStateRep;
1439 }
1440 
1444 class DT_DLL_VL DtReflectedSovietInterrogatorList : public DtReflectedObjectList
1445 {
1446 public:
1448  DtReflectedSovietInterrogatorList(DtExerciseConn* exConn,
1449  const DtDDMRegionSet* regionSetToUse = 0);
1450 
1453  DtReflectedSovietInterrogatorList(DtExerciseConn* exConn,
1454  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
1455 
1457  virtual ~DtReflectedSovietInterrogatorList();
1458 
1459 private:
1460 
1462  DtReflectedSovietInterrogatorList(const DtReflectedSovietInterrogatorList& orig);
1463 
1465  DtReflectedSovietInterrogatorList& operator=(const DtReflectedSovietInterrogatorList&orig);
1466 
1467 public:
1468 
1470  virtual DtReflectedSovietInterrogator* lookup(
1471 #if DtHLA_1516
1472  RTI::ObjectInstanceHandle id);
1473 #else
1474  RTI::ObjectHandle id);
1475 #endif
1476 
1478  virtual DtReflectedSovietInterrogator* lookup(
1479  const DtGlobalObjectDesignator& objName);
1480 
1482  virtual DtReflectedSovietInterrogator* first() const;
1483 
1485  virtual DtReflectedSovietInterrogator* last() const;
1486 
1488  virtual void addSovietInterrogatorAdditionCallback(
1489  DtSovietInterrogatorCallbackFunction cb, void* userData);
1490 
1492  virtual void removeSovietInterrogatorAdditionCallback(
1493  DtSovietInterrogatorCallbackFunction cb, void* userData);
1494 
1496  virtual void addSovietInterrogatorRemovalCallback(
1497  DtSovietInterrogatorCallbackFunction cb, void* userData);
1498 
1500  virtual void removeSovietInterrogatorRemovalCallback(
1501  DtSovietInterrogatorCallbackFunction cb, void* userData);
1502 
1503 protected:
1504 
1506  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
1507 
1512  virtual void objectAdded(DtReflectedObject* obj);
1513 
1514 };
1515 
1519 typedef void(*DtSovietTransponderCallbackFunction)(
1520  DtReflectedSovietTransponder* obj, void* userData);
1521 
1526 class DT_DLL_VL DtReflectedSovietTransponder : public DtReflectedObject
1527 {
1528 public:
1531  typedef DtSovietTransponderStateRepository* (*DtStateRepCreator)();
1532 
1533 public:
1535  DtReflectedSovietTransponder(DtHlaObject* obj, DtExerciseConn* exConn);
1536 
1538  virtual ~DtReflectedSovietTransponder();
1539 
1541  virtual DtSovietTransponderStateRepository* sovietTransponderStateRep() const;
1542 
1544  virtual DtSovietTransponderStateRepository* ssr() const;
1545 
1548  virtual DtReflectedSovietTransponder* next() const;
1549 
1552  virtual DtReflectedSovietTransponder* prev() const;
1553 
1556  virtual DtReflectedSovietTransponder* wrapNext() const;
1557 
1560  virtual DtReflectedSovietTransponder* wrapPrev() const;
1561 
1564  virtual void addPostUpdateCallback(
1565  DtSovietTransponderCallbackFunction cb, void* userData);
1566 
1569  virtual void removePostUpdateCallback(
1570  DtSovietTransponderCallbackFunction cb, void* userData);
1571 
1572 public:
1574  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
1575 
1576 protected:
1578  DtReflectedSovietTransponder(const DtReflectedSovietTransponder& orig);
1579 
1581  DtReflectedSovietTransponder& operator=(const DtReflectedSovietTransponder& orig);
1582 
1583 protected:
1585  static DtStateRepCreator theStateRepCreator;
1586 };
1587 
1588 inline DtSovietTransponderStateRepository* DtReflectedSovietTransponder::sovietTransponderStateRep() const
1589 {
1590  return (DtSovietTransponderStateRepository*)myStateRep;
1591 }
1592 
1593 inline DtSovietTransponderStateRepository* DtReflectedSovietTransponder::ssr() const
1594 {
1595  return (DtSovietTransponderStateRepository*)myStateRep;
1596 }
1597 
1601 class DT_DLL_VL DtReflectedSovietTransponderList : public DtReflectedObjectList
1602 {
1603 public:
1605  DtReflectedSovietTransponderList(DtExerciseConn* exConn,
1606  const DtDDMRegionSet* regionSetToUse = 0);
1607 
1610  DtReflectedSovietTransponderList(DtExerciseConn* exConn,
1611  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
1612 
1614  virtual ~DtReflectedSovietTransponderList();
1615 
1616 private:
1617 
1619  DtReflectedSovietTransponderList(const DtReflectedSovietTransponderList& orig);
1620 
1622  DtReflectedSovietTransponderList& operator=(const DtReflectedSovietTransponderList&orig);
1623 
1624 public:
1625 
1627  virtual DtReflectedSovietTransponder* lookup(
1628 #if DtHLA_1516
1629  RTI::ObjectInstanceHandle id);
1630 #else
1631  RTI::ObjectHandle id);
1632 #endif
1633 
1635  virtual DtReflectedSovietTransponder* lookup(
1636  const DtGlobalObjectDesignator& objName);
1637 
1639  virtual DtReflectedSovietTransponder* first() const;
1640 
1642  virtual DtReflectedSovietTransponder* last() const;
1643 
1645  virtual void addSovietTransponderAdditionCallback(
1646  DtSovietTransponderCallbackFunction cb, void* userData);
1647 
1649  virtual void removeSovietTransponderAdditionCallback(
1650  DtSovietTransponderCallbackFunction cb, void* userData);
1651 
1653  virtual void addSovietTransponderRemovalCallback(
1654  DtSovietTransponderCallbackFunction cb, void* userData);
1655 
1657  virtual void removeSovietTransponderRemovalCallback(
1658  DtSovietTransponderCallbackFunction cb, void* userData);
1659 
1660 protected:
1661 
1663  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
1664 
1669  virtual void objectAdded(DtReflectedObject* obj);
1670 
1673  virtual const DtList* dfltHandleList();
1674 
1675 };
1676 */
1677 /******************** DtReflectedTCASData *********************/
1678 
1682 typedef void(*DtTCASDataCallbackFunction)(
1683  DtReflectedTCASData* obj, void* userData);
1684 
1689 class DT_DLL_VL DtReflectedTCASData : public DtReflectedObject
1690 {
1691 public:
1694  typedef DtTCASDataStateRepository* (*DtStateRepCreator)();
1695 
1696 public:
1698  DtReflectedTCASData(DtHlaObject* obj, DtExerciseConn* exConn);
1699 
1701  virtual ~DtReflectedTCASData();
1702 
1704  virtual DtTCASDataStateRepository* TCASDataStateRep() const;
1705 
1707  virtual DtTCASDataStateRepository* Tsr() const;
1708 
1711  virtual DtReflectedTCASData* next() const;
1712 
1715  virtual DtReflectedTCASData* prev() const;
1716 
1719  virtual DtReflectedTCASData* wrapNext() const;
1720 
1723  virtual DtReflectedTCASData* wrapPrev() const;
1724 
1727  virtual void addPostUpdateCallback(
1728  DtTCASDataCallbackFunction cb, void* userData);
1729 
1732  virtual void removePostUpdateCallback(
1733  DtTCASDataCallbackFunction cb, void* userData);
1734 
1735 public:
1737  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
1738 
1739 protected:
1741  DtReflectedTCASData(const DtReflectedTCASData& orig);
1742 
1744  DtReflectedTCASData& operator=(const DtReflectedTCASData& orig);
1745 
1746 protected:
1748  static DtStateRepCreator theStateRepCreator;
1749 };
1750 
1751 inline DtTCASDataStateRepository* DtReflectedTCASData::TCASDataStateRep() const
1752 {
1753  return (DtTCASDataStateRepository*)myStateRep;
1754 }
1755 
1756 inline DtTCASDataStateRepository* DtReflectedTCASData::Tsr() const
1757 {
1758  return (DtTCASDataStateRepository*)myStateRep;
1759 }
1760 
1761 /******************** DtReflectedTCASDataList *********************/
1762 
1766 class DT_DLL_VL DtReflectedTCASDataList : public DtReflectedObjectList
1767 {
1768 public:
1770  DtReflectedTCASDataList(DtExerciseConn* exConn,
1771  const DtDDMRegionSet* regionSetToUse = 0);
1772 
1775  DtReflectedTCASDataList(DtExerciseConn* exConn,
1776  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
1777 
1779  virtual ~DtReflectedTCASDataList();
1780 
1781 private:
1782 
1784  DtReflectedTCASDataList(const DtReflectedTCASDataList& orig);
1785 
1787  DtReflectedTCASDataList& operator=(const DtReflectedTCASDataList&orig);
1788 
1789 public:
1790 
1792  virtual DtReflectedTCASData* lookup(
1793 #if DtHLA_1516
1794  RTI::ObjectInstanceHandle id);
1795 #else
1796  RTI::ObjectHandle id);
1797 #endif
1798 
1800  virtual DtReflectedTCASData* lookup(
1801  const DtGlobalObjectDesignator& objName);
1802 
1804  virtual DtReflectedTCASData* first() const;
1805 
1807  virtual DtReflectedTCASData* last() const;
1808 
1810  virtual void addTCASDataAdditionCallback(
1811  DtTCASDataCallbackFunction cb, void* userData);
1812 
1814  virtual void removeTCASDataAdditionCallback(
1815  DtTCASDataCallbackFunction cb, void* userData);
1816 
1818  virtual void addTCASDataRemovalCallback(
1819  DtTCASDataCallbackFunction cb, void* userData);
1820 
1822  virtual void removeTCASDataRemovalCallback(
1823  DtTCASDataCallbackFunction cb, void* userData);
1824 
1825 protected:
1826 
1828  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
1829 
1834  virtual void objectAdded(DtReflectedObject* obj);
1835 
1838  virtual const DtList* dfltHandleList();
1839 
1840 };
1841 /******************** DtReflectedSoviet *********************/
1842 
1846 typedef void(*DtSovietCallbackFunction)(
1847  DtReflectedSoviet* obj, void* userData);
1848 
1853 class DT_DLL_VL DtReflectedSoviet : public DtReflectedObject
1854 {
1855 public:
1858  typedef DtSovietStateRepository* (*DtStateRepCreator)();
1859 
1860 public:
1862  DtReflectedSoviet(DtHlaObject* obj, DtExerciseConn* exConn);
1863 
1865  virtual ~DtReflectedSoviet();
1866 
1868  virtual DtSovietStateRepository* sovietStateRep() const;
1869 
1871  virtual DtSovietStateRepository* msr() const;
1872 
1875  virtual DtReflectedSoviet* next() const;
1876 
1879  virtual DtReflectedSoviet* prev() const;
1880 
1883  virtual DtReflectedSoviet* wrapNext() const;
1884 
1887  virtual DtReflectedSoviet* wrapPrev() const;
1888 
1891  virtual void addPostUpdateCallback(
1892  DtSovietCallbackFunction cb, void* userData);
1893 
1896  virtual void removePostUpdateCallback(
1897  DtSovietCallbackFunction cb, void* userData);
1898 
1899 public:
1901  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
1902 
1903 protected:
1905  DtReflectedSoviet(const DtReflectedSoviet& orig);
1906 
1908  DtReflectedSoviet& operator=(const DtReflectedSoviet& orig);
1909 
1910 protected:
1912  static DtStateRepCreator theStateRepCreator;
1913 };
1914 
1915 inline DtSovietStateRepository* DtReflectedSoviet::sovietStateRep() const
1916 {
1917  return (DtSovietStateRepository*)myStateRep;
1918 }
1919 
1920 inline DtSovietStateRepository* DtReflectedSoviet::msr() const
1921 {
1922  return (DtSovietStateRepository*)myStateRep;
1923 }
1924 
1925 /******************** DtReflectedSovietList *********************/
1926 
1930 class DT_DLL_VL DtReflectedSovietList : public DtReflectedObjectList
1931 {
1932 public:
1934  DtReflectedSovietList(DtExerciseConn* exConn,
1935  const DtDDMRegionSet* regionSetToUse = 0);
1936 
1939  DtReflectedSovietList(DtExerciseConn* exConn,
1940  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
1941 
1943  virtual ~DtReflectedSovietList();
1944 
1945 private:
1946 
1948  DtReflectedSovietList(const DtReflectedSovietList& orig);
1949 
1951  DtReflectedSovietList& operator=(const DtReflectedSovietList&orig);
1952 
1953 public:
1954 
1956  virtual DtReflectedSoviet* lookup(
1957 #if DtHLA_1516
1958  RTI::ObjectInstanceHandle id);
1959 #else
1960  RTI::ObjectHandle id);
1961 #endif
1962 
1964  virtual DtReflectedSoviet* lookup(
1965  const DtGlobalObjectDesignator& objName);
1966 
1968  virtual DtReflectedSoviet* first() const;
1969 
1971  virtual DtReflectedSoviet* last() const;
1972 
1974  virtual void addSovietAdditionCallback(
1975  DtSovietCallbackFunction cb, void* userData);
1976 
1978  virtual void removeSovietAdditionCallback(
1979  DtSovietCallbackFunction cb, void* userData);
1980 
1982  virtual void addSovietRemovalCallback(
1983  DtSovietCallbackFunction cb, void* userData);
1984 
1986  virtual void removeSovietRemovalCallback(
1987  DtSovietCallbackFunction cb, void* userData);
1988 
1989 protected:
1990 
1992  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
1993 
1998  virtual void objectAdded(DtReflectedObject* obj);
1999 
2002  virtual const DtList* dfltHandleList();
2003 
2004 };
2005 
2006 /******************** DtReflectedRRB *********************/
2007 
2011 typedef void(*DtRRBCallbackFunction)(
2012  DtReflectedRRB* obj, void* userData);
2013 
2018 class DT_DLL_VL DtReflectedRRB : public DtReflectedObject
2019 {
2020 public:
2023  typedef DtRRBStateRepository* (*DtStateRepCreator)();
2024 
2025 public:
2027  DtReflectedRRB(DtHlaObject* obj, DtExerciseConn* exConn);
2028 
2030  virtual ~DtReflectedRRB();
2031 
2033  virtual DtRRBStateRepository* rrbStateRep() const;
2034 
2036  virtual DtRRBStateRepository* msr() const;
2037 
2040  virtual DtReflectedRRB* next() const;
2041 
2044  virtual DtReflectedRRB* prev() const;
2045 
2048  virtual DtReflectedRRB* wrapNext() const;
2049 
2052  virtual DtReflectedRRB* wrapPrev() const;
2053 
2056  virtual void addPostUpdateCallback(
2057  DtRRBCallbackFunction cb, void* userData);
2058 
2061  virtual void removePostUpdateCallback(
2062  DtRRBCallbackFunction cb, void* userData);
2063 
2064 public:
2066  static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);
2067 
2068 protected:
2070  DtReflectedRRB(const DtReflectedRRB& orig);
2071 
2073  DtReflectedRRB& operator=(const DtReflectedRRB& orig);
2074 
2075 protected:
2077  static DtStateRepCreator theStateRepCreator;
2078 };
2079 
2080 inline DtRRBStateRepository* DtReflectedRRB::rrbStateRep() const
2081 {
2082  return (DtRRBStateRepository*)myStateRep;
2083 }
2084 
2085 inline DtRRBStateRepository* DtReflectedRRB::msr() const
2086 {
2087  return (DtRRBStateRepository*)myStateRep;
2088 }
2089 
2090 /******************** DtReflectedRRBList *********************/
2091 
2095 class DT_DLL_VL DtReflectedRRBList : public DtReflectedObjectList
2096 {
2097 public:
2099  DtReflectedRRBList(DtExerciseConn* exConn,
2100  const DtDDMRegionSet* regionSetToUse = 0);
2101 
2104  DtReflectedRRBList(DtExerciseConn* exConn,
2105  const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);
2106 
2108  virtual ~DtReflectedRRBList();
2109 
2110 private:
2111 
2113  DtReflectedRRBList(const DtReflectedRRBList& orig);
2114 
2116  DtReflectedRRBList& operator=(const DtReflectedRRBList&orig);
2117 
2118 public:
2119 
2121  virtual DtReflectedRRB* lookup(
2122 #if DtHLA_1516
2123  RTI::ObjectInstanceHandle id);
2124 #else
2125  RTI::ObjectHandle id);
2126 #endif
2127 
2129  virtual DtReflectedRRB* lookup(
2130  const DtGlobalObjectDesignator& objName);
2131 
2133  virtual DtReflectedRRB* first() const;
2134 
2136  virtual DtReflectedRRB* last() const;
2137 
2139  virtual void addRRBAdditionCallback(
2140  DtRRBCallbackFunction cb, void* userData);
2141 
2143  virtual void removeRRBAdditionCallback(
2144  DtRRBCallbackFunction cb, void* userData);
2145 
2147  virtual void addRRBRemovalCallback(
2148  DtRRBCallbackFunction cb, void* userData);
2149 
2151  virtual void removeRRBRemovalCallback(
2152  DtRRBCallbackFunction cb, void* userData);
2153 
2154 protected:
2155 
2157  virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
2158 
2163  virtual void objectAdded(DtReflectedObject* obj);
2164 
2167  virtual const DtList* dfltHandleList();
2168 
2169 };
2170 
2171 #endif
DtReflectedObjectList
Instances of DtReflectedObjectList are lists of instances of classes derived from DtReflectedObject...
Definition: reflectedObjectListDIS.h:38
DtSovietStateRepository
Instances of DtSovietStateRepository are used to store state data for IFFData.Soviet objects...
Definition: iffSovietStateRepository.h:29
DtListedObj::next
void * next() const
Return next (previous) elements on the list, or NULL if hit the end (beginning) of the list...
Definition: vlList.h:272
reflectedObjectListHLA.h
Contains the HLA DtReflectedObjectList class declaration.
DtTCASDataStateRepository
Instances of DtTCASDataStateRepository are used to store state data for IFFData.TCASData objects...
Definition: iffTCASDataStateRepository.h:29
iffSovietStateRepository.h
Contains the DtSovietStateRepository class DT_DLL_VL declaration.
DtExerciseConn
Instances of DtExerciseConn are used to provide an application&#39;s interface or connection to the netwo...
Definition: exerciseConnDIS.h:62
DT_DLL_VL
#define DT_DLL_VL
Definition: vlMachineTypes.h:108
DtMode2StateRepository
Instances of DtMode2StateRepository are used to store state data for IFFData.Mode2 objects...
Definition: iffMode2StateRepository.h:29
iffMode3CStateRepository.h
Contains the DtMode3CStateRepository class DT_DLL_VL declaration.
iffMode3AStateRepository.h
Contains the DtMode3AStateRepository class DT_DLL_VL declaration.
DtModeSStateRepository
Instances of DtModeSStateRepository are used to store state data for IFFData.ModeS objects...
Definition: iffModeSStateRepository.h:29
IFFDataStateRepository.h
Contains the DtIFFDataStateRepository class DT_DLL_VL declaration.
iffRRBStateRepository.h
Contains the DtRRBStateRepository class DT_DLL_VL declaration.
DtReflectedObject::operator=
DtReflectedObject & operator=(const DtReflectedObject &orig)
assignment operator – not implemented
DtIFFDataStateRepository
Instances of DtIFFDataStateRepository are used to store state data for IFFData objects.
Definition: IFFDataStateRepository.h:32
DtReflectedObjectList::operator=
DtReflectedObjectList & operator=(const DtReflectedObjectList &orig)
assignment operator – not implemented
DtList
DtList is deprecated, please use std::list&lt;T&gt;.
Definition: vlList.h:71
DtReflectedObject
Instances of DtReflectedObject are used to represent a simulation entity reflected across a network (...
Definition: reflectedObjectDIS.h:34
DtRRBStateRepository
Instances of DtRRBStateRepository are used to store state data for IFFData.RRB objects.
Definition: iffRRBStateRepository.h:29
DtListedObj::prev
void * prev() const
Definition: vlList.h:277
DtListedObj::wrapNext
void * wrapNext() const
Return next (previous) elements on the list, but wrap to the beginning (end) of the list when you hit...
Definition: vlList.h:282
DtMode1StateRepository
Instances of DtMode1StateRepository are used to store state data for IFFData.Mode1 objects...
Definition: iffMode1StateRepository.h:29
DtMode3CStateRepository
Instances of DtMode3CStateRepository are used to store state data for IFFData.ModeC objects...
Definition: iffMode3CStateRepository.h:28
DtEntityIdentifier
Instances of DtEntityIdentifier are used as a unique ID for entities in DIS.
Definition: entityIdentifier.h:31
iffTCASDataStateRepository.h
Contains the DtTCASDataStateRepository class DT_DLL_VL declaration.
DtMode4StateRepository
Instances of DtMode4StateRepository are used to store state data for IFFData.Mode4 objects...
Definition: iffMode4StateRepository.h:29
DtReflectedObjectList::objectAdded
virtual void objectAdded(DtReflectedObject *object)
Called after a remote object has been added to the list.
DtMode5StateRepository
Instances of DtMode5StateRepository are used to store state data for IFFData.Mode5 objects...
Definition: iffMode5StateRepository.h:30
DtListedObj::wrapPrev
void * wrapPrev() const
Definition: vlList.h:288
DtMode3AStateRepository
Instances of DtMode3AStateRepository are used to store state data for IFFData.Mode3A objects...
Definition: iffMode3AStateRepository.h:29
iffMode4StateRepository.h
Contains the DtMode4StateRepository class DT_DLL_VL declaration.
iffMode5StateRepository.h
Contains the DtMode5StateRepository class DT_DLL_VL declaration.
iffMode1StateRepository.h
Contains the DtMode1StateRepository class DT_DLL_VL declaration.
iffMode2StateRepository.h
Contains the DtMode2StateRepository class DT_DLL_VL declaration.
iffModeSStateRepository.h
Contains the DtModeSStateRepository class DT_DLL_VL declaration.
Document ID: Generated on Thu Sep 19 02:12:35 EDT 2024 from SVN revision 269601
Copyright © 2005-2024 MAK Technologies. All Rights Reserved (www.mak.com)