VR-Link API Documentation for DIS
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
iffDataEncoders.h
Go to the documentation of this file.
1 /*********************************************************************
2 ** Copyright (c) 1992-2025 MAK Technologies, Inc
3 ** All rights reserved.
4 *********************************************************************/
5 
6 #pragma once
7 
8 #if DtHLA
9 
10 #include <vl/hlaStateDecoder.h>
11 #include <vl/hlaStateEncoder.h>
12 
13 class DT_DLL_VL DtIFFDataStateRepository;
14 class DT_DLL_VL DtMode1StateRepository;
15 class DT_DLL_VL DtMode2StateRepository;
16 class DT_DLL_VL DtMode3AStateRepository;
17 class DT_DLL_VL DtMode3CStateRepository;
18 class DT_DLL_VL DtMode4StateRepository;
19 class DT_DLL_VL DtMode5StateRepository;
20 class DT_DLL_VL DtModeSStateRepository;
21 class DT_DLL_VL DtTCASDataStateRepository;
22 class DT_DLL_VL DtSovietStateRepository;
23 class DT_DLL_VL DtRRBStateRepository;
24 
28 class DT_DLL_VL DtIFFDataDecoder : public DtHlaStateDecoder
29 {
30 public:
32  DtIFFDataDecoder(
33  DtExerciseConn* exConn,
34  DtObjClassDesc* classDesc);
35 
37  virtual ~DtIFFDataDecoder();
38 
40  DtIFFDataDecoder(const DtIFFDataDecoder& orig);
41 
43  DtIFFDataDecoder& operator=(const DtIFFDataDecoder& orig);
44 
45 public:
47  static DtHlaStateDecoder* create(
48  DtExerciseConn* exConn,
49  DtObjClassDesc* classDesc);
50 
51 protected:
52 
54  static void decodeIFFSystemIdentifier(
55  DtIFFDataStateRepository* rep,
56  const RTI::AttributeHandleValuePairSet& attrs,
57  int pairSetIndex);
58 
60  static void decodeIffData(
61  DtIFFDataStateRepository* rep,
62  const RTI::AttributeHandleValuePairSet& attrs,
63  int pairSetIndex);
64 
66  static void decodeReportingSimulation(
67  DtIFFDataStateRepository* rep,
68  const RTI::AttributeHandleValuePairSet& attrs,
69  int pairSetIndex);
70 
71 };
72 
77 class DT_DLL_VL DtIFFDataEncoder : public DtHlaStateEncoder
78 {
79 public:
80 
82  DtIFFDataEncoder(
83  DtExerciseConn* exConn,
84  DtObjClassDesc* classDesc);
85 
87  virtual ~DtIFFDataEncoder();
88 
90  DtIFFDataEncoder(const DtIFFDataEncoder& orig);
91 
93  DtIFFDataEncoder& operator=(const DtIFFDataEncoder& orig);
94 
95 public:
97  static DtHlaStateEncoder* create(
98  DtExerciseConn* exConn,
99  DtObjClassDesc* classDesc);
100 
101 protected:
102 
105  static bool needIFFSystemIdentifier(
106  const DtIFFDataStateRepository& stateRep,
107  const DtIFFDataStateRepository& asSeenByRemote);
108 
110  static void encodeIFFSystemIdentifier(
111  const DtIFFDataStateRepository& rep,
112  RTI::AttributeHandleValuePairSet* attrs,
113  RTI::AttributeHandle attrHandle);
114 
117  static bool needIffData(
118  const DtIFFDataStateRepository& stateRep,
119  const DtIFFDataStateRepository& asSeenByRemote);
120 
122  static void encodeIffData(
123  const DtIFFDataStateRepository& rep,
124  RTI::AttributeHandleValuePairSet* attrs,
125  RTI::AttributeHandle attrHandle);
126 
129  static bool needReportingSimulation(
130  const DtIFFDataStateRepository& stateRep,
131  const DtIFFDataStateRepository& asSeenByRemote);
132 
134  static void encodeReportingSimulation(
135  const DtIFFDataStateRepository& rep,
136  RTI::AttributeHandleValuePairSet* attrs,
137  RTI::AttributeHandle attrHandle);
138 
139 };
140 
141 /****************** Mode 1 *******************/
142 
146 class DT_DLL_VL DtMode1Decoder : public DtIFFDataDecoder
147 {
148 public:
150  DtMode1Decoder(
151  DtExerciseConn* exConn,
152  DtObjClassDesc* classDesc);
153 
155  virtual ~DtMode1Decoder();
156 
158  DtMode1Decoder(const DtMode1Decoder& orig);
159 
161  DtMode1Decoder& operator=(const DtMode1Decoder& orig);
162 
163 public:
165  static DtHlaStateDecoder* create(
166  DtExerciseConn* exConn,
167  DtObjClassDesc* classDesc);
168 
169 protected:
171  static void decodeIsOn(
172  DtMode1StateRepository* rep,
173  const RTI::AttributeHandleValuePairSet& attrs,
174  int pairSetIndex);
175 
177  static void decodeIsDamaged(
178  DtMode1StateRepository* rep,
179  const RTI::AttributeHandleValuePairSet& attrs,
180  int pairSetIndex);
181 
183  static void decodeIsMalfunctioning(
184  DtMode1StateRepository* rep,
185  const RTI::AttributeHandleValuePairSet& attrs,
186  int pairSetIndex);
187 
191  static void decodeCode(
192  DtMode1StateRepository* rep,
193  const RTI::AttributeHandleValuePairSet& attrs,
194  int pairSetIndex);
195 
197  static void decodeExtendedCodeIsSet(
198  DtMode1StateRepository* rep,
199  const RTI::AttributeHandleValuePairSet& attrs,
200  int pairSetIndex);
203 
204 };
205 
210 class DT_DLL_VL DtMode1Encoder : public DtIFFDataEncoder
211 {
212 public:
213 
215  DtMode1Encoder(
216  DtExerciseConn* exConn,
217  DtObjClassDesc* classDesc);
218 
220  virtual ~DtMode1Encoder();
221 
223  DtMode1Encoder(const DtMode1Encoder& orig);
224 
226  DtMode1Encoder& operator=(const DtMode1Encoder& orig);
227 
228 public:
230  static DtHlaStateEncoder* create(
231  DtExerciseConn* exConn,
232  DtObjClassDesc* classDesc);
233 
234 protected:
235 
238  static bool needIsOn(
239  const DtMode1StateRepository& stateRep,
240  const DtMode1StateRepository& asSeenByRemote);
241 
243  static void encodeIsOn(
244  const DtMode1StateRepository& rep,
245  RTI::AttributeHandleValuePairSet* attrs,
246  RTI::AttributeHandle attrHandle);
247 
250  static bool needIsDamaged(
251  const DtMode1StateRepository& stateRep,
252  const DtMode1StateRepository& asSeenByRemote);
253 
255  static void encodeIsDamaged(
256  const DtMode1StateRepository& rep,
257  RTI::AttributeHandleValuePairSet* attrs,
258  RTI::AttributeHandle attrHandle);
259 
262  static bool needIsMalfunctioning(
263  const DtMode1StateRepository& stateRep,
264  const DtMode1StateRepository& asSeenByRemote);
265 
267  static void encodeIsMalfunctioning(
268  const DtMode1StateRepository& rep,
269  RTI::AttributeHandleValuePairSet* attrs,
270  RTI::AttributeHandle attrHandle);
271 
276  static bool needCode(
277  const DtMode1StateRepository& stateRep,
278  const DtMode1StateRepository& asSeenByRemote);
279 
281  static void encodeCode(
282  const DtMode1StateRepository& rep,
283  RTI::AttributeHandleValuePairSet* attrs,
284  RTI::AttributeHandle attrHandle);
285 
288  static bool needExtendedCodeIsSet(
289  const DtMode1StateRepository& stateRep,
290  const DtMode1StateRepository& asSeenByRemote);
291 
293  static void encodeExtendedCodeIsSet(
294  const DtMode1StateRepository& rep,
295  RTI::AttributeHandleValuePairSet* attrs,
296  RTI::AttributeHandle attrHandle);
299 };
300 
301 /****************** Mode 1 *******************/
302 /****************** Mode 2 *******************/
303 
307 class DT_DLL_VL DtMode2Decoder : public DtIFFDataDecoder
308 {
309 public:
311  DtMode2Decoder(
312  DtExerciseConn* exConn,
313  DtObjClassDesc* classDesc);
314 
316  virtual ~DtMode2Decoder();
317 
319  DtMode2Decoder(const DtMode2Decoder& orig);
320 
322  DtMode2Decoder& operator=(const DtMode2Decoder& orig);
323 
324 public:
326  static DtHlaStateDecoder* create(
327  DtExerciseConn* exConn,
328  DtObjClassDesc* classDesc);
329 
330 protected:
332  static void decodeIsOn(
333  DtMode2StateRepository* rep,
334  const RTI::AttributeHandleValuePairSet& attrs,
335  int pairSetIndex);
336 
338  static void decodeIsDamaged(
339  DtMode2StateRepository* rep,
340  const RTI::AttributeHandleValuePairSet& attrs,
341  int pairSetIndex);
342 
344  static void decodeIsMalfunctioning(
345  DtMode2StateRepository* rep,
346  const RTI::AttributeHandleValuePairSet& attrs,
347  int pairSetIndex);
348 
352  static void decodeCode(
353  DtMode2StateRepository* rep,
354  const RTI::AttributeHandleValuePairSet& attrs,
355  int pairSetIndex);
358 
359 };
360 
365 class DT_DLL_VL DtMode2Encoder : public DtIFFDataEncoder
366 {
367 public:
368 
370  DtMode2Encoder(
371  DtExerciseConn* exConn,
372  DtObjClassDesc* classDesc);
373 
375  virtual ~DtMode2Encoder();
376 
378  DtMode2Encoder(const DtMode2Encoder& orig);
379 
381  DtMode2Encoder& operator=(const DtMode2Encoder& orig);
382 
383 public:
385  static DtHlaStateEncoder* create(
386  DtExerciseConn* exConn,
387  DtObjClassDesc* classDesc);
388 
389 protected:
390 
393  static bool needIsOn(
394  const DtMode2StateRepository& stateRep,
395  const DtMode2StateRepository& asSeenByRemote);
396 
398  static void encodeIsOn(
399  const DtMode2StateRepository& rep,
400  RTI::AttributeHandleValuePairSet* attrs,
401  RTI::AttributeHandle attrHandle);
402 
405  static bool needIsDamaged(
406  const DtMode2StateRepository& stateRep,
407  const DtMode2StateRepository& asSeenByRemote);
408 
410  static void encodeIsDamaged(
411  const DtMode2StateRepository& rep,
412  RTI::AttributeHandleValuePairSet* attrs,
413  RTI::AttributeHandle attrHandle);
414 
417  static bool needIsMalfunctioning(
418  const DtMode2StateRepository& stateRep,
419  const DtMode2StateRepository& asSeenByRemote);
420 
422  static void encodeIsMalfunctioning(
423  const DtMode2StateRepository& rep,
424  RTI::AttributeHandleValuePairSet* attrs,
425  RTI::AttributeHandle attrHandle);
426 
431  static bool needCode(
432  const DtMode2StateRepository& stateRep,
433  const DtMode2StateRepository& asSeenByRemote);
434 
436  static void encodeCode(
437  const DtMode2StateRepository& rep,
438  RTI::AttributeHandleValuePairSet* attrs,
439  RTI::AttributeHandle attrHandle);
442 
443 };
444 /****************** Mode 2 *******************/
445 /****************** Mode 3A *******************/
449 class DT_DLL_VL DtMode3ADecoder : public DtIFFDataDecoder
450 {
451 public:
453  DtMode3ADecoder(
454  DtExerciseConn* exConn,
455  DtObjClassDesc* classDesc);
456 
458  virtual ~DtMode3ADecoder();
459 
461  DtMode3ADecoder(const DtMode3ADecoder& orig);
462 
464  DtMode3ADecoder& operator=(const DtMode3ADecoder& orig);
465 
466 public:
468  static DtHlaStateDecoder* create(
469  DtExerciseConn* exConn,
470  DtObjClassDesc* classDesc);
471 
472 protected:
473 
475  static void decodeIsOn(
476  DtMode3AStateRepository* rep,
477  const RTI::AttributeHandleValuePairSet& attrs,
478  int pairSetIndex);
479 
481  static void decodeIsDamaged(
482  DtMode3AStateRepository* rep,
483  const RTI::AttributeHandleValuePairSet& attrs,
484  int pairSetIndex);
485 
487  static void decodeIsMalfunctioning(
488  DtMode3AStateRepository* rep,
489  const RTI::AttributeHandleValuePairSet& attrs,
490  int pairSetIndex);
491 
493  static void decodeCode(
494  DtMode3AStateRepository* rep,
495  const RTI::AttributeHandleValuePairSet& attrs,
496  int pairSetIndex);
497 
498 };
499 
504 class DT_DLL_VL DtMode3AEncoder : public DtIFFDataEncoder
505 {
506 public:
507 
509  DtMode3AEncoder(
510  DtExerciseConn* exConn,
511  DtObjClassDesc* classDesc);
512 
514  virtual ~DtMode3AEncoder();
515 
517  DtMode3AEncoder(const DtMode3AEncoder& orig);
518 
520  DtMode3AEncoder& operator=(const DtMode3AEncoder& orig);
521 
522 public:
524  static DtHlaStateEncoder* create(
525  DtExerciseConn* exConn,
526  DtObjClassDesc* classDesc);
527 
528 protected:
529 
532  static bool needIsOn(
533  const DtMode3AStateRepository& stateRep,
534  const DtMode3AStateRepository& asSeenByRemote);
535 
537  static void encodeIsOn(
538  const DtMode3AStateRepository& rep,
539  RTI::AttributeHandleValuePairSet* attrs,
540  RTI::AttributeHandle attrHandle);
541 
544  static bool needIsDamaged(
545  const DtMode3AStateRepository& stateRep,
546  const DtMode3AStateRepository& asSeenByRemote);
547 
549  static void encodeIsDamaged(
550  const DtMode3AStateRepository& rep,
551  RTI::AttributeHandleValuePairSet* attrs,
552  RTI::AttributeHandle attrHandle);
553 
556  static bool needIsMalfunctioning(
557  const DtMode3AStateRepository& stateRep,
558  const DtMode3AStateRepository& asSeenByRemote);
559 
561  static void encodeIsMalfunctioning(
562  const DtMode3AStateRepository& rep,
563  RTI::AttributeHandleValuePairSet* attrs,
564  RTI::AttributeHandle attrHandle);
565 
568  static bool needCode(
569  const DtMode3AStateRepository& stateRep,
570  const DtMode3AStateRepository& asSeenByRemote);
571 
573  static void encodeCode(
574  const DtMode3AStateRepository& rep,
575  RTI::AttributeHandleValuePairSet* attrs,
576  RTI::AttributeHandle attrHandle);
577 
578 };
579 
580 /****************** Mode 3A *******************/
581 /****************** Mode 3C *******************/
585 class DT_DLL_VL DtMode3CDecoder : public DtIFFDataDecoder
586 {
587 public:
589  DtMode3CDecoder(
590  DtExerciseConn* exConn,
591  DtObjClassDesc* classDesc);
592 
594  virtual ~DtMode3CDecoder();
595 
597  DtMode3CDecoder(const DtMode3CDecoder& orig);
598 
600  DtMode3CDecoder& operator=(const DtMode3CDecoder& orig);
601 
602 public:
604  static DtHlaStateDecoder* create(
605  DtExerciseConn* exConn,
606  DtObjClassDesc* classDesc);
607 
608 protected:
609 
611  static void decodeIsOn(
612  DtMode3CStateRepository* rep,
613  const RTI::AttributeHandleValuePairSet& attrs,
614  int pairSetIndex);
615 
617  static void decodeIsDamaged(
618  DtMode3CStateRepository* rep,
619  const RTI::AttributeHandleValuePairSet& attrs,
620  int pairSetIndex);
621 
623  static void decodeIsMalfunctioning(
624  DtMode3CStateRepository* rep,
625  const RTI::AttributeHandleValuePairSet& attrs,
626  int pairSetIndex);
627 
629  static void decodeAltitudeAvailable(
630  DtMode3CStateRepository* rep,
631  const RTI::AttributeHandleValuePairSet& attrs,
632  int pairSetIndex);
633 
635  static void decodeAltitude(
636  DtMode3CStateRepository* rep,
637  const RTI::AttributeHandleValuePairSet& attrs,
638  int pairSetIndex);
639 
640 };
641 
646 class DT_DLL_VL DtMode3CEncoder : public DtIFFDataEncoder
647 {
648 public:
649 
651  DtMode3CEncoder(
652  DtExerciseConn* exConn,
653  DtObjClassDesc* classDesc);
654 
656  virtual ~DtMode3CEncoder();
657 
659  DtMode3CEncoder(const DtMode3CEncoder& orig);
660 
662  DtMode3CEncoder& operator=(const DtMode3CEncoder& orig);
663 
664 public:
666  static DtHlaStateEncoder* create(
667  DtExerciseConn* exConn,
668  DtObjClassDesc* classDesc);
669 
670 protected:
671 
674  static bool needIsOn(
675  const DtMode3CStateRepository& stateRep,
676  const DtMode3CStateRepository& asSeenByRemote);
677 
679  static void encodeIsOn(
680  const DtMode3CStateRepository& rep,
681  RTI::AttributeHandleValuePairSet* attrs,
682  RTI::AttributeHandle attrHandle);
683 
686  static bool needIsDamaged(
687  const DtMode3CStateRepository& stateRep,
688  const DtMode3CStateRepository& asSeenByRemote);
689 
691  static void encodeIsDamaged(
692  const DtMode3CStateRepository& rep,
693  RTI::AttributeHandleValuePairSet* attrs,
694  RTI::AttributeHandle attrHandle);
695 
698  static bool needIsMalfunctioning(
699  const DtMode3CStateRepository& stateRep,
700  const DtMode3CStateRepository& asSeenByRemote);
701 
703  static void encodeIsMalfunctioning(
704  const DtMode3CStateRepository& rep,
705  RTI::AttributeHandleValuePairSet* attrs,
706  RTI::AttributeHandle attrHandle);
707 
710  static bool needAltitudeAvailable(
711  const DtMode3CStateRepository& stateRep,
712  const DtMode3CStateRepository& asSeenByRemote);
713 
715  static void encodeAltitudeAvailable(
716  const DtMode3CStateRepository& rep,
717  RTI::AttributeHandleValuePairSet* attrs,
718  RTI::AttributeHandle attrHandle);
719 
722  static bool needAltitude(
723  const DtMode3CStateRepository& stateRep,
724  const DtMode3CStateRepository& asSeenByRemote);
725 
727  static void encodeAltitude(
728  const DtMode3CStateRepository& rep,
729  RTI::AttributeHandleValuePairSet* attrs,
730  RTI::AttributeHandle attrHandle);
731 
732 };
733 
734 /****************** Mode 3C *******************/
735 /****************** Mode 4 *******************/
739 class DT_DLL_VL DtMode4Decoder : public DtIFFDataDecoder
740 {
741 public:
743  DtMode4Decoder(
744  DtExerciseConn* exConn,
745  DtObjClassDesc* classDesc);
746 
748  virtual ~DtMode4Decoder();
749 
751  DtMode4Decoder(const DtMode4Decoder& orig);
752 
754  DtMode4Decoder& operator=(const DtMode4Decoder& orig);
755 
756 public:
758  static DtHlaStateDecoder* create(
759  DtExerciseConn* exConn,
760  DtObjClassDesc* classDesc);
761 
762 protected:
763 
765  static void decodeIsOn(
766  DtMode4StateRepository* rep,
767  const RTI::AttributeHandleValuePairSet& attrs,
768  int pairSetIndex);
769 
771  static void decodeIsDamaged(
772  DtMode4StateRepository* rep,
773  const RTI::AttributeHandleValuePairSet& attrs,
774  int pairSetIndex);
775 
777  static void decodeIsMalfunctioning(
778  DtMode4StateRepository* rep,
779  const RTI::AttributeHandleValuePairSet& attrs,
780  int pairSetIndex);
781 
783  static void decodePseudoCryptoCodeAAvailable(
784  DtMode4StateRepository* rep,
785  const RTI::AttributeHandleValuePairSet& attrs,
786  int pairSetIndex);
787 
789  static void decodePseudoCryptoCodeA(
790  DtMode4StateRepository* rep,
791  const RTI::AttributeHandleValuePairSet& attrs,
792  int pairSetIndex);
793 
795  static void decodePseudoCryptoCodeBAvailable(
796  DtMode4StateRepository* rep,
797  const RTI::AttributeHandleValuePairSet& attrs,
798  int pairSetIndex);
799 
801  static void decodePseudoCryptoCodeB(
802  DtMode4StateRepository* rep,
803  const RTI::AttributeHandleValuePairSet& attrs,
804  int pairSetIndex);
805 
807  static void decodePseudoCryptoCodeActive(
808  DtMode4StateRepository* rep,
809  const RTI::AttributeHandleValuePairSet& attrs,
810  int pairSetIndex);
811 
813  static void decodeChallenge(
814  DtMode4StateRepository* rep,
815  const RTI::AttributeHandleValuePairSet& attrs,
816  int pairSetIndex);
817 
819  static void decodeReply(
820  DtMode4StateRepository* rep,
821  const RTI::AttributeHandleValuePairSet& attrs,
822  int pairSetIndex);
823 
824 };
825 
830 class DT_DLL_VL DtMode4Encoder : public DtIFFDataEncoder
831 {
832 public:
833 
835  DtMode4Encoder(
836  DtExerciseConn* exConn,
837  DtObjClassDesc* classDesc);
838 
840  virtual ~DtMode4Encoder();
841 
843  DtMode4Encoder(const DtMode4Encoder& orig);
844 
846  DtMode4Encoder& operator=(const DtMode4Encoder& orig);
847 
848 public:
850  static DtHlaStateEncoder* create(
851  DtExerciseConn* exConn,
852  DtObjClassDesc* classDesc);
853 
854 protected:
855 
858  static bool needIsOn(
859  const DtMode4StateRepository& stateRep,
860  const DtMode4StateRepository& asSeenByRemote);
861 
863  static void encodeIsOn(
864  const DtMode4StateRepository& rep,
865  RTI::AttributeHandleValuePairSet* attrs,
866  RTI::AttributeHandle attrHandle);
867 
870  static bool needIsDamaged(
871  const DtMode4StateRepository& stateRep,
872  const DtMode4StateRepository& asSeenByRemote);
873 
875  static void encodeIsDamaged(
876  const DtMode4StateRepository& rep,
877  RTI::AttributeHandleValuePairSet* attrs,
878  RTI::AttributeHandle attrHandle);
879 
882  static bool needIsMalfunctioning(
883  const DtMode4StateRepository& stateRep,
884  const DtMode4StateRepository& asSeenByRemote);
885 
887  static void encodeIsMalfunctioning(
888  const DtMode4StateRepository& rep,
889  RTI::AttributeHandleValuePairSet* attrs,
890  RTI::AttributeHandle attrHandle);
891 
894  static bool needPseudoCryptoCodeAAvailable(
895  const DtMode4StateRepository& stateRep,
896  const DtMode4StateRepository& asSeenByRemote);
897 
899  static void encodePseudoCryptoCodeAAvailable(
900  const DtMode4StateRepository& rep,
901  RTI::AttributeHandleValuePairSet* attrs,
902  RTI::AttributeHandle attrHandle);
903 
906  static bool needPseudoCryptoCodeA(
907  const DtMode4StateRepository& stateRep,
908  const DtMode4StateRepository& asSeenByRemote);
909 
911  static void encodePseudoCryptoCodeA(
912  const DtMode4StateRepository& rep,
913  RTI::AttributeHandleValuePairSet* attrs,
914  RTI::AttributeHandle attrHandle);
915 
918  static bool needPseudoCryptoCodeBAvailable(
919  const DtMode4StateRepository& stateRep,
920  const DtMode4StateRepository& asSeenByRemote);
921 
923  static void encodePseudoCryptoCodeBAvailable(
924  const DtMode4StateRepository& rep,
925  RTI::AttributeHandleValuePairSet* attrs,
926  RTI::AttributeHandle attrHandle);
927 
930  static bool needPseudoCryptoCodeB(
931  const DtMode4StateRepository& stateRep,
932  const DtMode4StateRepository& asSeenByRemote);
933 
935  static void encodePseudoCryptoCodeB(
936  const DtMode4StateRepository& rep,
937  RTI::AttributeHandleValuePairSet* attrs,
938  RTI::AttributeHandle attrHandle);
939 
942  static bool needPseudoCryptoCodeActive(
943  const DtMode4StateRepository& stateRep,
944  const DtMode4StateRepository& asSeenByRemote);
945 
947  static void encodePseudoCryptoCodeActive(
948  const DtMode4StateRepository& rep,
949  RTI::AttributeHandleValuePairSet* attrs,
950  RTI::AttributeHandle attrHandle);
951 
954  static bool needChallenge(
955  const DtMode4StateRepository& stateRep,
956  const DtMode4StateRepository& asSeenByRemote);
957 
959  static void encodeChallenge(
960  const DtMode4StateRepository& rep,
961  RTI::AttributeHandleValuePairSet* attrs,
962  RTI::AttributeHandle attrHandle);
963 
966  static bool needReply(
967  const DtMode4StateRepository& stateRep,
968  const DtMode4StateRepository& asSeenByRemote);
969 
971  static void encodeReply(
972  const DtMode4StateRepository& rep,
973  RTI::AttributeHandleValuePairSet* attrs,
974  RTI::AttributeHandle attrHandle);
975 
976 };
977 
978 /****************** Mode 4 *******************/
979 /****************** Mode 5 *******************/
983 class DT_DLL_VL DtMode5Decoder : public DtIFFDataDecoder
984 {
985 public:
987  DtMode5Decoder(
988  DtExerciseConn* exConn,
989  DtObjClassDesc* classDesc);
990 
992  virtual ~DtMode5Decoder();
993 
995  DtMode5Decoder(const DtMode5Decoder& orig);
996 
998  DtMode5Decoder& operator=(const DtMode5Decoder& orig);
999 
1000 public:
1002  static DtHlaStateDecoder* create(
1003  DtExerciseConn* exConn,
1004  DtObjClassDesc* classDesc);
1005 
1006 protected:
1007 
1009  static void decodeIsOn(
1010  DtMode5StateRepository* rep,
1011  const RTI::AttributeHandleValuePairSet& attrs,
1012  int pairSetIndex);
1013 
1015  static void decodeIsDamaged(
1016  DtMode5StateRepository* rep,
1017  const RTI::AttributeHandleValuePairSet& attrs,
1018  int pairSetIndex);
1019 
1021  static void decodeIsMalfunctioning(
1022  DtMode5StateRepository* rep,
1023  const RTI::AttributeHandleValuePairSet& attrs,
1024  int pairSetIndex);
1025 
1027  static void decodePseudoCryptoCodeAvailable(
1028  DtMode5StateRepository* rep,
1029  const RTI::AttributeHandleValuePairSet& attrs,
1030  int pairSetIndex);
1031 
1033  static void decodePseudoCryptoCode(
1034  DtMode5StateRepository* rep,
1035  const RTI::AttributeHandleValuePairSet& attrs,
1036  int pairSetIndex);
1037 
1039  static void decodeSpecificInformation(
1040  DtMode5StateRepository* rep,
1041  const RTI::AttributeHandleValuePairSet& attrs,
1042  int pairSetIndex);
1043 
1045  static void decodeMission(
1046  DtMode5StateRepository* rep,
1047  const RTI::AttributeHandleValuePairSet& attrs,
1048  int pairSetIndex);
1049 
1051  static void decodeMessageFormatsCapable(
1052  DtMode5StateRepository* rep,
1053  const RTI::AttributeHandleValuePairSet& attrs,
1054  int pairSetIndex);
1055 
1057  static void decodePlatformType(
1058  DtMode5StateRepository* rep,
1059  const RTI::AttributeHandleValuePairSet& attrs,
1060  int pairSetIndex);
1061 
1063  static void decodeNationalOrigin(
1064  DtMode5StateRepository* rep,
1065  const RTI::AttributeHandleValuePairSet& attrs,
1066  int pairSetIndex);
1067 
1069  static void decodePlatformIdentificationNumber(
1070  DtMode5StateRepository* rep,
1071  const RTI::AttributeHandleValuePairSet& attrs,
1072  int pairSetIndex);
1073 
1075  static void decodeAntennaSelection(
1076  DtMode5StateRepository* rep,
1077  const RTI::AttributeHandleValuePairSet& attrs,
1078  int pairSetIndex);
1079 
1081  static void decodeLevelSelection(
1082  DtMode5StateRepository* rep,
1083  const RTI::AttributeHandleValuePairSet& attrs,
1084  int pairSetIndex);
1085 
1087  static void decodeSquitterIsOn(
1088  DtMode5StateRepository* rep,
1089  const RTI::AttributeHandleValuePairSet& attrs,
1090  int pairSetIndex);
1091 
1093  static void decodeLevel2SquitterStatus(
1094  DtMode5StateRepository* rep,
1095  const RTI::AttributeHandleValuePairSet& attrs,
1096  int pairSetIndex);
1097 
1099  static void decodeLineTestIsEnabled(
1100  DtMode5StateRepository* rep,
1101  const RTI::AttributeHandleValuePairSet& attrs,
1102  int pairSetIndex);
1103 
1105  static void decodeReply(
1106  DtMode5StateRepository* rep,
1107  const RTI::AttributeHandleValuePairSet& attrs,
1108  int pairSetIndex);
1109 
1111  static void decodeFigureOfMerit(
1112  DtMode5StateRepository* rep,
1113  const RTI::AttributeHandleValuePairSet& attrs,
1114  int pairSetIndex);
1115 
1117  static void decodeNavigationSource(
1118  DtMode5StateRepository* rep,
1119  const RTI::AttributeHandleValuePairSet& attrs,
1120  int pairSetIndex);
1121 /*
1123  static void decodeCryptoControlDataIsPresent(
1124  DtMode5StateRepository* rep,
1125  const RTI::AttributeHandleValuePairSet& attrs,
1126  int pairSetIndex);
1127 */
1128 
1130  static void decodeLocationDataIsPresent(
1131  DtMode5StateRepository* rep,
1132  const RTI::AttributeHandleValuePairSet& attrs,
1133  int pairSetIndex);
1134 
1136  static void decodeLocationErrorDataIsPresent(
1137  DtMode5StateRepository* rep,
1138  const RTI::AttributeHandleValuePairSet& attrs,
1139  int pairSetIndex);
1140 
1141 };
1142 
1147 class DT_DLL_VL DtMode5Encoder : public DtIFFDataEncoder
1148 {
1149 public:
1150 
1152  DtMode5Encoder(
1153  DtExerciseConn* exConn,
1154  DtObjClassDesc* classDesc);
1155 
1157  virtual ~DtMode5Encoder();
1158 
1160  DtMode5Encoder(const DtMode5Encoder& orig);
1161 
1163  DtMode5Encoder& operator=(const DtMode5Encoder& orig);
1164 
1165 public:
1167  static DtHlaStateEncoder* create(
1168  DtExerciseConn* exConn,
1169  DtObjClassDesc* classDesc);
1170 
1171 protected:
1172 
1175  static bool needIsOn(
1176  const DtMode5StateRepository& stateRep,
1177  const DtMode5StateRepository& asSeenByRemote);
1178 
1180  static void encodeIsOn(
1181  const DtMode5StateRepository& rep,
1182  RTI::AttributeHandleValuePairSet* attrs,
1183  RTI::AttributeHandle attrHandle);
1184 
1187  static bool needIsDamaged(
1188  const DtMode5StateRepository& stateRep,
1189  const DtMode5StateRepository& asSeenByRemote);
1190 
1192  static void encodeIsDamaged(
1193  const DtMode5StateRepository& rep,
1194  RTI::AttributeHandleValuePairSet* attrs,
1195  RTI::AttributeHandle attrHandle);
1196 
1199  static bool needIsMalfunctioning(
1200  const DtMode5StateRepository& stateRep,
1201  const DtMode5StateRepository& asSeenByRemote);
1202 
1204  static void encodeIsMalfunctioning(
1205  const DtMode5StateRepository& rep,
1206  RTI::AttributeHandleValuePairSet* attrs,
1207  RTI::AttributeHandle attrHandle);
1208 
1211  static bool needPseudoCryptoCodeAvailable(
1212  const DtMode5StateRepository& stateRep,
1213  const DtMode5StateRepository& asSeenByRemote);
1214 
1216  static void encodePseudoCryptoCodeAvailable(
1217  const DtMode5StateRepository& rep,
1218  RTI::AttributeHandleValuePairSet* attrs,
1219  RTI::AttributeHandle attrHandle);
1220 
1223  static bool needPseudoCryptoCode(
1224  const DtMode5StateRepository& stateRep,
1225  const DtMode5StateRepository& asSeenByRemote);
1226 
1228  static void encodePseudoCryptoCode(
1229  const DtMode5StateRepository& rep,
1230  RTI::AttributeHandleValuePairSet* attrs,
1231  RTI::AttributeHandle attrHandle);
1232 
1235  static bool needSpecificInformation(
1236  const DtMode5StateRepository& stateRep,
1237  const DtMode5StateRepository& asSeenByRemote);
1238 
1240  static void encodeSpecificInformation(
1241  const DtMode5StateRepository& rep,
1242  RTI::AttributeHandleValuePairSet* attrs,
1243  RTI::AttributeHandle attrHandle);
1244 
1247  static bool needMission(
1248  const DtMode5StateRepository& stateRep,
1249  const DtMode5StateRepository& asSeenByRemote);
1250 
1252  static void encodeMission(
1253  const DtMode5StateRepository& rep,
1254  RTI::AttributeHandleValuePairSet* attrs,
1255  RTI::AttributeHandle attrHandle);
1256 
1259  static bool needMessageFormatsCapable(
1260  const DtMode5StateRepository& stateRep,
1261  const DtMode5StateRepository& asSeenByRemote);
1262 
1264  static void encodeMessageFormatsCapable(
1265  const DtMode5StateRepository& rep,
1266  RTI::AttributeHandleValuePairSet* attrs,
1267  RTI::AttributeHandle attrHandle);
1268 
1271  static bool needPlatformType(
1272  const DtMode5StateRepository& stateRep,
1273  const DtMode5StateRepository& asSeenByRemote);
1274 
1276  static void encodePlatformType(
1277  const DtMode5StateRepository& rep,
1278  RTI::AttributeHandleValuePairSet* attrs,
1279  RTI::AttributeHandle attrHandle);
1280 
1283  static bool needNationalOrigin(
1284  const DtMode5StateRepository& stateRep,
1285  const DtMode5StateRepository& asSeenByRemote);
1286 
1288  static void encodeNationalOrigin(
1289  const DtMode5StateRepository& rep,
1290  RTI::AttributeHandleValuePairSet* attrs,
1291  RTI::AttributeHandle attrHandle);
1292 
1295  static bool needPlatformIdentificationNumber(
1296  const DtMode5StateRepository& stateRep,
1297  const DtMode5StateRepository& asSeenByRemote);
1298 
1300  static void encodePlatformIdentificationNumber(
1301  const DtMode5StateRepository& rep,
1302  RTI::AttributeHandleValuePairSet* attrs,
1303  RTI::AttributeHandle attrHandle);
1304 
1307  static bool needAntennaSelection(
1308  const DtMode5StateRepository& stateRep,
1309  const DtMode5StateRepository& asSeenByRemote);
1310 
1312  static void encodeAntennaSelection(
1313  const DtMode5StateRepository& rep,
1314  RTI::AttributeHandleValuePairSet* attrs,
1315  RTI::AttributeHandle attrHandle);
1316 
1319  static bool needLevelSelection(
1320  const DtMode5StateRepository& stateRep,
1321  const DtMode5StateRepository& asSeenByRemote);
1322 
1324  static void encodeLevelSelection(
1325  const DtMode5StateRepository& rep,
1326  RTI::AttributeHandleValuePairSet* attrs,
1327  RTI::AttributeHandle attrHandle);
1328 
1331  static bool needSquitterIsOn(
1332  const DtMode5StateRepository& stateRep,
1333  const DtMode5StateRepository& asSeenByRemote);
1334 
1336  static void encodeSquitterIsOn(
1337  const DtMode5StateRepository& rep,
1338  RTI::AttributeHandleValuePairSet* attrs,
1339  RTI::AttributeHandle attrHandle);
1340 
1343  static bool needLevel2SquitterStatus(
1344  const DtMode5StateRepository& stateRep,
1345  const DtMode5StateRepository& asSeenByRemote);
1346 
1348  static void encodeLevel2SquitterStatus(
1349  const DtMode5StateRepository& rep,
1350  RTI::AttributeHandleValuePairSet* attrs,
1351  RTI::AttributeHandle attrHandle);
1352 
1355  static bool needLineTestIsEnabled(
1356  const DtMode5StateRepository& stateRep,
1357  const DtMode5StateRepository& asSeenByRemote);
1358 
1360  static void encodeLineTestIsEnabled(
1361  const DtMode5StateRepository& rep,
1362  RTI::AttributeHandleValuePairSet* attrs,
1363  RTI::AttributeHandle attrHandle);
1364 
1367  static bool needReply(
1368  const DtMode5StateRepository& stateRep,
1369  const DtMode5StateRepository& asSeenByRemote);
1370 
1372  static void encodeReply(
1373  const DtMode5StateRepository& rep,
1374  RTI::AttributeHandleValuePairSet* attrs,
1375  RTI::AttributeHandle attrHandle);
1376 
1379  static bool needFigureOfMerit(
1380  const DtMode5StateRepository& stateRep,
1381  const DtMode5StateRepository& asSeenByRemote);
1382 
1384  static void encodeFigureOfMerit(
1385  const DtMode5StateRepository& rep,
1386  RTI::AttributeHandleValuePairSet* attrs,
1387  RTI::AttributeHandle attrHandle);
1388 
1391  static bool needNavigationSource(
1392  const DtMode5StateRepository& stateRep,
1393  const DtMode5StateRepository& asSeenByRemote);
1394 
1396  static void encodeNavigationSource(
1397  const DtMode5StateRepository& rep,
1398  RTI::AttributeHandleValuePairSet* attrs,
1399  RTI::AttributeHandle attrHandle);
1400 /*
1403  static bool needCryptoControlDataIsPresent(
1404  const DtMode5StateRepository& stateRep,
1405  const DtMode5StateRepository& asSeenByRemote);
1406 
1408  static void encodeCryptoControlDataIsPresent(
1409  const DtMode5StateRepository& rep,
1410  RTI::AttributeHandleValuePairSet* attrs,
1411  RTI::AttributeHandle attrHandle);
1412 */
1415  static bool needLocationDataIsPresent(
1416  const DtMode5StateRepository& stateRep,
1417  const DtMode5StateRepository& asSeenByRemote);
1418 
1420  static void encodeLocationDataIsPresent(
1421  const DtMode5StateRepository& rep,
1422  RTI::AttributeHandleValuePairSet* attrs,
1423  RTI::AttributeHandle attrHandle);
1424 
1427  static bool needLocationErrorDataIsPresent(
1428  const DtMode5StateRepository& stateRep,
1429  const DtMode5StateRepository& asSeenByRemote);
1430 
1432  static void encodeLocationErrorDataIsPresent(
1433  const DtMode5StateRepository& rep,
1434  RTI::AttributeHandleValuePairSet* attrs,
1435  RTI::AttributeHandle attrHandle);
1436 };
1437 /****************** Mode 5 *******************/
1438 /****************** Mode S *******************/
1442 class DT_DLL_VL DtModeSDecoder : public DtIFFDataDecoder
1443 {
1444 public:
1446  DtModeSDecoder(
1447  DtExerciseConn* exConn,
1448  DtObjClassDesc* classDesc);
1449 
1451  virtual ~DtModeSDecoder();
1452 
1454  DtModeSDecoder(const DtModeSDecoder& orig);
1455 
1457  DtModeSDecoder& operator=(const DtModeSDecoder& orig);
1458 
1459 public:
1461  static DtHlaStateDecoder* create(
1462  DtExerciseConn* exConn,
1463  DtObjClassDesc* classDesc);
1464 
1465 protected:
1466 
1468  static void decodeIsOn(
1469  DtModeSStateRepository* rep,
1470  const RTI::AttributeHandleValuePairSet& attrs,
1471  int pairSetIndex);
1472 
1474  static void decodeIsDamaged(
1475  DtModeSStateRepository* rep,
1476  const RTI::AttributeHandleValuePairSet& attrs,
1477  int pairSetIndex);
1478 
1480  static void decodeIsMalfunctioning(
1481  DtModeSStateRepository* rep,
1482  const RTI::AttributeHandleValuePairSet& attrs,
1483  int pairSetIndex);
1484 
1486  static void decodeSpecificInformation(
1487  DtModeSStateRepository* rep,
1488  const RTI::AttributeHandleValuePairSet& attrs,
1489  int pairSetIndex);
1490 
1492  static void decodeLevelsPresent(
1493  DtModeSStateRepository* rep,
1494  const RTI::AttributeHandleValuePairSet& attrs,
1495  int pairSetIndex);
1496 
1498  static void decodeIFFData(
1499  DtModeSStateRepository* rep,
1500  const RTI::AttributeHandleValuePairSet& attrs,
1501  int pairSetIndex);
1502 
1503 
1505  static void decodeInterrogatorIdentifier(
1506  DtModeSStateRepository* rep,
1507  const RTI::AttributeHandleValuePairSet& attrs,
1508  int pairSetIndex);
1509 
1511  static void decodeTransmitState(
1512  DtModeSStateRepository* rep,
1513  const RTI::AttributeHandleValuePairSet& attrs,
1514  int pairSetIndex);
1515 
1516 
1518  static void decodeAircraftAddress(
1519  DtModeSStateRepository* rep,
1520  const RTI::AttributeHandleValuePairSet& attrs,
1521  int pairSetIndex);
1522 
1524  static void decodeAircraftIdentificationType(
1525  DtModeSStateRepository* rep,
1526  const RTI::AttributeHandleValuePairSet& attrs,
1527  int pairSetIndex);
1528 
1530  static void decodeAircraftIdentification(
1531  DtModeSStateRepository* rep,
1532  const RTI::AttributeHandleValuePairSet& attrs,
1533  int pairSetIndex);
1534 
1536  static void decodeSquitterIsOn(
1537  DtModeSStateRepository* rep,
1538  const RTI::AttributeHandleValuePairSet& attrs,
1539  int pairSetIndex);
1540 
1542  static void decodeSquitterType(
1543  DtModeSStateRepository* rep,
1544  const RTI::AttributeHandleValuePairSet& attrs,
1545  int pairSetIndex);
1546 
1548  static void decodeCapabilityReport(
1549  DtModeSStateRepository* rep,
1550  const RTI::AttributeHandleValuePairSet& attrs,
1551  int pairSetIndex);
1552 
1554  static void decodeAircraftPresentDomain(
1555  DtModeSStateRepository* rep,
1556  const RTI::AttributeHandleValuePairSet& attrs,
1557  int pairSetIndex);
1558 
1560  static void decodeAltitudeAvailable(
1561  DtModeSStateRepository* rep,
1562  const RTI::AttributeHandleValuePairSet& attrs,
1563  int pairSetIndex);
1564 
1566  static void decodeAltitude(
1567  DtModeSStateRepository* rep,
1568  const RTI::AttributeHandleValuePairSet& attrs,
1569  int pairSetIndex);
1570 
1572  static void decodeSquitterRecordSource(
1573  DtModeSStateRepository* rep,
1574  const RTI::AttributeHandleValuePairSet& attrs,
1575  int pairSetIndex);
1576 
1578  static void decodeAirbornePositionReportDataIsPresent(
1579  DtModeSStateRepository* rep,
1580  const RTI::AttributeHandleValuePairSet& attrs,
1581  int pairSetIndex);
1582 
1584  static void decodeAirborneVelocityReportDataIsPresent(
1585  DtModeSStateRepository* rep,
1586  const RTI::AttributeHandleValuePairSet& attrs,
1587  int pairSetIndex);
1588 
1590  static void decodeSurfacePositionReportDataIsPresent(
1591  DtModeSStateRepository* rep,
1592  const RTI::AttributeHandleValuePairSet& attrs,
1593  int pairSetIndex);
1594 
1596  static void decodeIdentificationReportDataIsPresent(
1597  DtModeSStateRepository* rep,
1598  const RTI::AttributeHandleValuePairSet& attrs,
1599  int pairSetIndex);
1600 
1602  static void decodeEventDrivenReportDataIsPresent(
1603  DtModeSStateRepository* rep,
1604  const RTI::AttributeHandleValuePairSet& attrs,
1605  int pairSetIndex);
1606 
1608  static void decodeDAPSource(
1609  DtModeSStateRepository* rep,
1610  const RTI::AttributeHandleValuePairSet& attrs,
1611  int pairSetIndex);
1612 
1614  static void decodeLocationErrorDataIsPresent(
1615  DtModeSStateRepository* rep,
1616  const RTI::AttributeHandleValuePairSet& attrs,
1617  int pairSetIndex);
1618 };
1619 
1624 class DT_DLL_VL DtModeSEncoder : public DtIFFDataEncoder
1625 {
1626 public:
1627 
1629  DtModeSEncoder(
1630  DtExerciseConn* exConn,
1631  DtObjClassDesc* classDesc);
1632 
1634  virtual ~DtModeSEncoder();
1635 
1637  DtModeSEncoder(const DtModeSEncoder& orig);
1638 
1640  DtModeSEncoder& operator=(const DtModeSEncoder& orig);
1641 
1642 public:
1644  static DtHlaStateEncoder* create(
1645  DtExerciseConn* exConn,
1646  DtObjClassDesc* classDesc);
1647 
1648 protected:
1649 
1652  static bool needIsOn(
1653  const DtModeSStateRepository& stateRep,
1654  const DtModeSStateRepository& asSeenByRemote);
1655 
1657  static void encodeIsOn(
1658  const DtModeSStateRepository& rep,
1659  RTI::AttributeHandleValuePairSet* attrs,
1660  RTI::AttributeHandle attrHandle);
1661 
1664  static bool needIsDamaged(
1665  const DtModeSStateRepository& stateRep,
1666  const DtModeSStateRepository& asSeenByRemote);
1667 
1669  static void encodeIsDamaged(
1670  const DtModeSStateRepository& rep,
1671  RTI::AttributeHandleValuePairSet* attrs,
1672  RTI::AttributeHandle attrHandle);
1673 
1676  static bool needIsMalfunctioning(
1677  const DtModeSStateRepository& stateRep,
1678  const DtModeSStateRepository& asSeenByRemote);
1679 
1681  static void encodeIsMalfunctioning(
1682  const DtModeSStateRepository& rep,
1683  RTI::AttributeHandleValuePairSet* attrs,
1684  RTI::AttributeHandle attrHandle);
1685 
1688  static bool needSpecificInformation(
1689  const DtModeSStateRepository& stateRep,
1690  const DtModeSStateRepository& asSeenByRemote);
1691 
1693  static void encodeSpecificInformation(
1694  const DtModeSStateRepository& rep,
1695  RTI::AttributeHandleValuePairSet* attrs,
1696  RTI::AttributeHandle attrHandle);
1697 
1700  static bool needLevelsPresent(
1701  const DtModeSStateRepository& stateRep,
1702  const DtModeSStateRepository& asSeenByRemote);
1703 
1705  static void encodeLevelsPresent(
1706  const DtModeSStateRepository& rep,
1707  RTI::AttributeHandleValuePairSet* attrs,
1708  RTI::AttributeHandle attrHandle);
1709 
1712  static bool needIFFData(
1713  const DtModeSStateRepository& stateRep,
1714  const DtModeSStateRepository& asSeenByRemote);
1715 
1717  static void encodeIFFData(
1718  const DtModeSStateRepository& rep,
1719  RTI::AttributeHandleValuePairSet* attrs,
1720  RTI::AttributeHandle attrHandle);
1721 
1724  static bool needInterrogatorIdentifier(
1725  const DtModeSStateRepository& stateRep,
1726  const DtModeSStateRepository& asSeenByRemote);
1727 
1729  static void encodeInterrogatorIdentifier(
1730  const DtModeSStateRepository& rep,
1731  RTI::AttributeHandleValuePairSet* attrs,
1732  RTI::AttributeHandle attrHandle);
1733 
1736  static bool needTransmitState(
1737  const DtModeSStateRepository& stateRep,
1738  const DtModeSStateRepository& asSeenByRemote);
1739 
1741  static void encodeTransmitState(
1742  const DtModeSStateRepository& rep,
1743  RTI::AttributeHandleValuePairSet* attrs,
1744  RTI::AttributeHandle attrHandle);
1745 
1748  static bool needAircraftAddress(
1749  const DtModeSStateRepository& stateRep,
1750  const DtModeSStateRepository& asSeenByRemote);
1751 
1753  static void encodeAircraftAddress(
1754  const DtModeSStateRepository& rep,
1755  RTI::AttributeHandleValuePairSet* attrs,
1756  RTI::AttributeHandle attrHandle);
1757 
1760  static bool needAircraftIdentificationType(
1761  const DtModeSStateRepository& stateRep,
1762  const DtModeSStateRepository& asSeenByRemote);
1763 
1765  static void encodeAircraftIdentificationType(
1766  const DtModeSStateRepository& rep,
1767  RTI::AttributeHandleValuePairSet* attrs,
1768  RTI::AttributeHandle attrHandle);
1769 
1772  static bool needAircraftIdentification(
1773  const DtModeSStateRepository& stateRep,
1774  const DtModeSStateRepository& asSeenByRemote);
1775 
1777  static void encodeAircraftIdentification(
1778  const DtModeSStateRepository& rep,
1779  RTI::AttributeHandleValuePairSet* attrs,
1780  RTI::AttributeHandle attrHandle);
1781 
1784  static bool needSquitterIsOn(
1785  const DtModeSStateRepository& stateRep,
1786  const DtModeSStateRepository& asSeenByRemote);
1787 
1789  static void encodeSquitterIsOn(
1790  const DtModeSStateRepository& rep,
1791  RTI::AttributeHandleValuePairSet* attrs,
1792  RTI::AttributeHandle attrHandle);
1793 
1796  static bool needSquitterType(
1797  const DtModeSStateRepository& stateRep,
1798  const DtModeSStateRepository& asSeenByRemote);
1799 
1801  static void encodeSquitterType(
1802  const DtModeSStateRepository& rep,
1803  RTI::AttributeHandleValuePairSet* attrs,
1804  RTI::AttributeHandle attrHandle);
1805 
1808  static bool needCapabilityReport(
1809  const DtModeSStateRepository& stateRep,
1810  const DtModeSStateRepository& asSeenByRemote);
1811 
1813  static void encodeCapabilityReport(
1814  const DtModeSStateRepository& rep,
1815  RTI::AttributeHandleValuePairSet* attrs,
1816  RTI::AttributeHandle attrHandle);
1817 
1820  static bool needAircraftPresentDomain(
1821  const DtModeSStateRepository& stateRep,
1822  const DtModeSStateRepository& asSeenByRemote);
1823 
1825  static void encodeAircraftPresentDomain(
1826  const DtModeSStateRepository& rep,
1827  RTI::AttributeHandleValuePairSet* attrs,
1828  RTI::AttributeHandle attrHandle);
1829 
1832  static bool needAltitudeAvailable(
1833  const DtModeSStateRepository& stateRep,
1834  const DtModeSStateRepository& asSeenByRemote);
1835 
1837  static void encodeAltitudeAvailable(
1838  const DtModeSStateRepository& rep,
1839  RTI::AttributeHandleValuePairSet* attrs,
1840  RTI::AttributeHandle attrHandle);
1841 
1844  static bool needAltitude(
1845  const DtModeSStateRepository& stateRep,
1846  const DtModeSStateRepository& asSeenByRemote);
1847 
1849  static void encodeAltitude(
1850  const DtModeSStateRepository& rep,
1851  RTI::AttributeHandleValuePairSet* attrs,
1852  RTI::AttributeHandle attrHandle);
1853 
1856  static bool needSquitterRecordSource(
1857  const DtModeSStateRepository& stateRep,
1858  const DtModeSStateRepository& asSeenByRemote);
1859 
1861  static void encodeSquitterRecordSource(
1862  const DtModeSStateRepository& rep,
1863  RTI::AttributeHandleValuePairSet* attrs,
1864  RTI::AttributeHandle attrHandle);
1865 
1868  static bool needAirbornePositionReportDataIsPresent(
1869  const DtModeSStateRepository& stateRep,
1870  const DtModeSStateRepository& asSeenByRemote);
1871 
1873  static void encodeAirbornePositionReportDataIsPresent(
1874  const DtModeSStateRepository& rep,
1875  RTI::AttributeHandleValuePairSet* attrs,
1876  RTI::AttributeHandle attrHandle);
1877 
1880  static bool needAirborneVelocityReportDataIsPresent(
1881  const DtModeSStateRepository& stateRep,
1882  const DtModeSStateRepository& asSeenByRemote);
1883 
1885  static void encodeAirborneVelocityReportDataIsPresent(
1886  const DtModeSStateRepository& rep,
1887  RTI::AttributeHandleValuePairSet* attrs,
1888  RTI::AttributeHandle attrHandle);
1889 
1892  static bool needSurfacePositionReportDataIsPresent(
1893  const DtModeSStateRepository& stateRep,
1894  const DtModeSStateRepository& asSeenByRemote);
1895 
1897  static void encodeSurfacePositionReportDataIsPresent(
1898  const DtModeSStateRepository& rep,
1899  RTI::AttributeHandleValuePairSet* attrs,
1900  RTI::AttributeHandle attrHandle);
1901 
1904  static bool needIdentificationReportDataIsPresent(
1905  const DtModeSStateRepository& stateRep,
1906  const DtModeSStateRepository& asSeenByRemote);
1907 
1909  static void encodeIdentificationReportDataIsPresent(
1910  const DtModeSStateRepository& rep,
1911  RTI::AttributeHandleValuePairSet* attrs,
1912  RTI::AttributeHandle attrHandle);
1913 
1916  static bool needEventDrivenReportDataIsPresent(
1917  const DtModeSStateRepository& stateRep,
1918  const DtModeSStateRepository& asSeenByRemote);
1919 
1921  static void encodeEventDrivenReportDataIsPresent(
1922  const DtModeSStateRepository& rep,
1923  RTI::AttributeHandleValuePairSet* attrs,
1924  RTI::AttributeHandle attrHandle);
1925 
1928  static bool needDapSource(
1929  const DtModeSStateRepository& stateRep,
1930  const DtModeSStateRepository& asSeenByRemote);
1931 
1933  static void encodeDapSource(
1934  const DtModeSStateRepository& rep,
1935  RTI::AttributeHandleValuePairSet* attrs,
1936  RTI::AttributeHandle attrHandle);
1937 
1940  static bool needLocationErrorDataIsPresent(
1941  const DtModeSStateRepository& stateRep,
1942  const DtModeSStateRepository& asSeenByRemote);
1943 
1945  static void encodeLocationErrorDataIsPresent(
1946  const DtModeSStateRepository& rep,
1947  RTI::AttributeHandleValuePairSet* attrs,
1948  RTI::AttributeHandle attrHandle);
1949 };
1950 /****************** Mode S *******************/
1951 /****************** TCAS *******************/
1955 class DT_DLL_VL DtTCASDataDecoder : public DtIFFDataDecoder
1956 {
1957 public:
1959  DtTCASDataDecoder(
1960  DtExerciseConn* exConn,
1961  DtObjClassDesc* classDesc);
1962 
1964  virtual ~DtTCASDataDecoder();
1965 
1967  DtTCASDataDecoder(const DtTCASDataDecoder& orig);
1968 
1970  DtTCASDataDecoder& operator=(const DtTCASDataDecoder& orig);
1971 
1972 public:
1974  static DtHlaStateDecoder* create(
1975  DtExerciseConn* exConn,
1976  DtObjClassDesc* classDesc);
1977 
1978 protected:
1979 
1981  static void decodeIsOn(
1982  DtTCASDataStateRepository* rep,
1983  const RTI::AttributeHandleValuePairSet& attrs,
1984  int pairSetIndex);
1985 
1987  static void decodeIsDamaged(
1988  DtTCASDataStateRepository* rep,
1989  const RTI::AttributeHandleValuePairSet& attrs,
1990  int pairSetIndex);
1991 
1993  static void decodeIsMalfunctioning(
1994  DtTCASDataStateRepository* rep,
1995  const RTI::AttributeHandleValuePairSet& attrs,
1996  int pairSetIndex);
1997 
1999  static void decodeTCAS_I_II_Type(
2000  DtTCASDataStateRepository* rep,
2001  const RTI::AttributeHandleValuePairSet& attrs,
2002  int pairSetIndex);
2003 
2005  static void decodeBasicAdvancedIndicator(
2006  DtTCASDataStateRepository* rep,
2007  const RTI::AttributeHandleValuePairSet& attrs,
2008  int pairSetIndex);
2009 
2011  static void decodeTCAS_ACASType(
2012  DtTCASDataStateRepository* rep,
2013  const RTI::AttributeHandleValuePairSet& attrs,
2014  int pairSetIndex);
2015 
2017  static void decodeTCAS_ACASIndicator(
2018  DtTCASDataStateRepository* rep,
2019  const RTI::AttributeHandleValuePairSet& attrs,
2020  int pairSetIndex);
2021 
2023  static void decodeSoftwareVersion(
2024  DtTCASDataStateRepository* rep,
2025  const RTI::AttributeHandleValuePairSet& attrs,
2026  int pairSetIndex);
2027 
2028 };
2029 
2034 class DT_DLL_VL DtTCASDataEncoder : public DtIFFDataEncoder
2035 {
2036 public:
2037 
2039  DtTCASDataEncoder(
2040  DtExerciseConn* exConn,
2041  DtObjClassDesc* classDesc);
2042 
2044  virtual ~DtTCASDataEncoder();
2045 
2047  DtTCASDataEncoder(const DtTCASDataEncoder& orig);
2048 
2050  DtTCASDataEncoder& operator=(const DtTCASDataEncoder& orig);
2051 
2052 public:
2054  static DtHlaStateEncoder* create(
2055  DtExerciseConn* exConn,
2056  DtObjClassDesc* classDesc);
2057 
2058 protected:
2059 
2062  static bool needIsOn(
2063  const DtTCASDataStateRepository& stateRep,
2064  const DtTCASDataStateRepository& asSeenByRemote);
2065 
2067  static void encodeIsOn(
2068  const DtTCASDataStateRepository& rep,
2069  RTI::AttributeHandleValuePairSet* attrs,
2070  RTI::AttributeHandle attrHandle);
2071 
2074  static bool needIsDamaged(
2075  const DtTCASDataStateRepository& stateRep,
2076  const DtTCASDataStateRepository& asSeenByRemote);
2077 
2079  static void encodeIsDamaged(
2080  const DtTCASDataStateRepository& rep,
2081  RTI::AttributeHandleValuePairSet* attrs,
2082  RTI::AttributeHandle attrHandle);
2083 
2086  static bool needIsMalfunctioning(
2087  const DtTCASDataStateRepository& stateRep,
2088  const DtTCASDataStateRepository& asSeenByRemote);
2089 
2091  static void encodeIsMalfunctioning(
2092  const DtTCASDataStateRepository& rep,
2093  RTI::AttributeHandleValuePairSet* attrs,
2094  RTI::AttributeHandle attrHandle);
2095 
2098  static bool needTCAS_I_II_Type(
2099  const DtTCASDataStateRepository& stateRep,
2100  const DtTCASDataStateRepository& asSeenByRemote);
2101 
2103  static void encodeTCAS_I_II_Type(
2104  const DtTCASDataStateRepository& rep,
2105  RTI::AttributeHandleValuePairSet* attrs,
2106  RTI::AttributeHandle attrHandle);
2107 
2110  static bool needBasicAdvancedIndicator(
2111  const DtTCASDataStateRepository& stateRep,
2112  const DtTCASDataStateRepository& asSeenByRemote);
2113 
2115  static void encodeBasicAdvancedIndicator(
2116  const DtTCASDataStateRepository& rep,
2117  RTI::AttributeHandleValuePairSet* attrs,
2118  RTI::AttributeHandle attrHandle);
2119 
2122  static bool needTCAS_ACASType(
2123  const DtTCASDataStateRepository& stateRep,
2124  const DtTCASDataStateRepository& asSeenByRemote);
2125 
2127  static void encodeTCAS_ACASType(
2128  const DtTCASDataStateRepository& rep,
2129  RTI::AttributeHandleValuePairSet* attrs,
2130  RTI::AttributeHandle attrHandle);
2131 
2134  static bool needTCAS_ACASIndicator(
2135  const DtTCASDataStateRepository& stateRep,
2136  const DtTCASDataStateRepository& asSeenByRemote);
2137 
2139  static void encodeTCAS_ACASIndicator(
2140  const DtTCASDataStateRepository& rep,
2141  RTI::AttributeHandleValuePairSet* attrs,
2142  RTI::AttributeHandle attrHandle);
2143 
2146  static bool needSoftwareVersion(
2147  const DtTCASDataStateRepository& stateRep,
2148  const DtTCASDataStateRepository& asSeenByRemote);
2149 
2151  static void encodeSoftwareVersion(
2152  const DtTCASDataStateRepository& rep,
2153  RTI::AttributeHandleValuePairSet* attrs,
2154  RTI::AttributeHandle attrHandle);
2155 
2156 };
2157 /****************** TCAS *******************/
2158 /****************** Soviet *******************/
2159 
2163 class DT_DLL_VL DtSovietDecoder : public DtIFFDataDecoder
2164 {
2165 public:
2167  DtSovietDecoder(
2168  DtExerciseConn* exConn,
2169  DtObjClassDesc* classDesc);
2170 
2172  virtual ~DtSovietDecoder();
2173 
2175  DtSovietDecoder(const DtSovietDecoder& orig);
2176 
2178  DtSovietDecoder& operator=(const DtSovietDecoder& orig);
2179 
2180 public:
2182  static DtHlaStateDecoder* create(
2183  DtExerciseConn* exConn,
2184  DtObjClassDesc* classDesc);
2185 
2186 protected:
2187 
2189  static void decodeIsOn(
2190  DtSovietStateRepository* rep,
2191  const RTI::AttributeHandleValuePairSet& attrs,
2192  int pairSetIndex);
2193 
2195  static void decodeIsDamaged(
2196  DtSovietStateRepository* rep,
2197  const RTI::AttributeHandleValuePairSet& attrs,
2198  int pairSetIndex);
2199 
2201  static void decodeIsMalfunctioning(
2202  DtSovietStateRepository* rep,
2203  const RTI::AttributeHandleValuePairSet& attrs,
2204  int pairSetIndex);
2205 
2206 };
2207 
2212 class DT_DLL_VL DtSovietEncoder : public DtIFFDataEncoder
2213 {
2214 public:
2215 
2217  DtSovietEncoder(
2218  DtExerciseConn* exConn,
2219  DtObjClassDesc* classDesc);
2220 
2222  virtual ~DtSovietEncoder();
2223 
2225  DtSovietEncoder(const DtSovietEncoder& orig);
2226 
2228  DtSovietEncoder& operator=(const DtSovietEncoder& orig);
2229 
2230 public:
2232  static DtHlaStateEncoder* create(
2233  DtExerciseConn* exConn,
2234  DtObjClassDesc* classDesc);
2235 
2236 protected:
2237 
2240  static bool needIsOn(
2241  const DtSovietStateRepository& stateRep,
2242  const DtSovietStateRepository& asSeenByRemote);
2243 
2245  static void encodeIsOn(
2246  const DtSovietStateRepository& rep,
2247  RTI::AttributeHandleValuePairSet* attrs,
2248  RTI::AttributeHandle attrHandle);
2249 
2252  static bool needIsDamaged(
2253  const DtSovietStateRepository& stateRep,
2254  const DtSovietStateRepository& asSeenByRemote);
2255 
2257  static void encodeIsDamaged(
2258  const DtSovietStateRepository& rep,
2259  RTI::AttributeHandleValuePairSet* attrs,
2260  RTI::AttributeHandle attrHandle);
2261 
2264  static bool needIsMalfunctioning(
2265  const DtSovietStateRepository& stateRep,
2266  const DtSovietStateRepository& asSeenByRemote);
2267 
2269  static void encodeIsMalfunctioning(
2270  const DtSovietStateRepository& rep,
2271  RTI::AttributeHandleValuePairSet* attrs,
2272  RTI::AttributeHandle attrHandle);
2273 
2274 };
2275 /****************** Soviet *******************/
2276 /******************* RRB *********************/
2280 class DT_DLL_VL DtRRBDecoder : public DtIFFDataDecoder
2281 {
2282 public:
2284  DtRRBDecoder(
2285  DtExerciseConn* exConn,
2286  DtObjClassDesc* classDesc);
2287 
2289  virtual ~DtRRBDecoder();
2290 
2292  DtRRBDecoder(const DtRRBDecoder& orig);
2293 
2295  DtRRBDecoder& operator=(const DtRRBDecoder& orig);
2296 
2297 public:
2299  static DtHlaStateDecoder* create(
2300  DtExerciseConn* exConn,
2301  DtObjClassDesc* classDesc);
2302 
2303 protected:
2305  static void decodeIsOn(
2306  DtRRBStateRepository* rep,
2307  const RTI::AttributeHandleValuePairSet& attrs,
2308  int pairSetIndex);
2309 
2311  static void decodeIsDamaged(
2312  DtRRBStateRepository* rep,
2313  const RTI::AttributeHandleValuePairSet& attrs,
2314  int pairSetIndex);
2315 
2317  static void decodeIsMalfunctioning(
2318  DtRRBStateRepository* rep,
2319  const RTI::AttributeHandleValuePairSet& attrs,
2320  int pairSetIndex);
2321 
2325  static void decodeCode(
2326  DtRRBStateRepository* rep,
2327  const RTI::AttributeHandleValuePairSet& attrs,
2328  int pairSetIndex);
2329 
2331  static void decodePowerReductionIsOn(
2332  DtRRBStateRepository* rep,
2333  const RTI::AttributeHandleValuePairSet& attrs,
2334  int pairSetIndex);
2335 
2337  static void decodeRadarEnhancementIsOn(
2338  DtRRBStateRepository* rep,
2339  const RTI::AttributeHandleValuePairSet& attrs,
2340  int pairSetIndex);
2343 
2344 };
2345 
2350 class DT_DLL_VL DtRRBEncoder : public DtIFFDataEncoder
2351 {
2352 public:
2353 
2355  DtRRBEncoder(
2356  DtExerciseConn* exConn,
2357  DtObjClassDesc* classDesc);
2358 
2360  virtual ~DtRRBEncoder();
2361 
2363  DtRRBEncoder(const DtRRBEncoder& orig);
2364 
2366  DtRRBEncoder& operator=(const DtRRBEncoder& orig);
2367 
2368 public:
2370  static DtHlaStateEncoder* create(
2371  DtExerciseConn* exConn,
2372  DtObjClassDesc* classDesc);
2373 
2374 protected:
2375 
2378  static bool needIsOn(
2379  const DtRRBStateRepository& stateRep,
2380  const DtRRBStateRepository& asSeenByRemote);
2381 
2383  static void encodeIsOn(
2384  const DtRRBStateRepository& rep,
2385  RTI::AttributeHandleValuePairSet* attrs,
2386  RTI::AttributeHandle attrHandle);
2387 
2390  static bool needIsDamaged(
2391  const DtRRBStateRepository& stateRep,
2392  const DtRRBStateRepository& asSeenByRemote);
2393 
2395  static void encodeIsDamaged(
2396  const DtRRBStateRepository& rep,
2397  RTI::AttributeHandleValuePairSet* attrs,
2398  RTI::AttributeHandle attrHandle);
2399 
2402  static bool needIsMalfunctioning(
2403  const DtRRBStateRepository& stateRep,
2404  const DtRRBStateRepository& asSeenByRemote);
2405 
2407  static void encodeIsMalfunctioning(
2408  const DtRRBStateRepository& rep,
2409  RTI::AttributeHandleValuePairSet* attrs,
2410  RTI::AttributeHandle attrHandle);
2411 
2416  static bool needCode(
2417  const DtRRBStateRepository& stateRep,
2418  const DtRRBStateRepository& asSeenByRemote);
2419 
2421  static void encodeCode(
2422  const DtRRBStateRepository& rep,
2423  RTI::AttributeHandleValuePairSet* attrs,
2424  RTI::AttributeHandle attrHandle);
2425 
2428  static bool needPowerReductionIsOn(
2429  const DtRRBStateRepository& stateRep,
2430  const DtRRBStateRepository& asSeenByRemote);
2431 
2433  static void encodePowerReductionIsOn(
2434  const DtRRBStateRepository& rep,
2435  RTI::AttributeHandleValuePairSet* attrs,
2436  RTI::AttributeHandle attrHandle);
2437 
2440  static bool needRadarEnhancementIsOn(
2441  const DtRRBStateRepository& stateRep,
2442  const DtRRBStateRepository& asSeenByRemote);
2443 
2445  static void encodeRadarEnhancementIsOn(
2446  const DtRRBStateRepository& rep,
2447  RTI::AttributeHandleValuePairSet* attrs,
2448  RTI::AttributeHandle attrHandle);
2451 };
2452 /******************* RRB *********************/
2453 #endif
DtSovietStateRepository
Instances of DtSovietStateRepository are used to store state data for IFFData.Soviet objects...
Definition: iffSovietStateRepository.h:29
DtTCASDataStateRepository
Instances of DtTCASDataStateRepository are used to store state data for IFFData.TCASData objects...
Definition: iffTCASDataStateRepository.h:29
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
DtModeSStateRepository
Instances of DtModeSStateRepository are used to store state data for IFFData.ModeS objects...
Definition: iffModeSStateRepository.h:29
hlaStateEncoder.h
This file contains the declaration of DtHlaStateEncoder.
DtIFFDataStateRepository
Instances of DtIFFDataStateRepository are used to store state data for IFFData objects.
Definition: IFFDataStateRepository.h:32
DtRRBStateRepository
Instances of DtRRBStateRepository are used to store state data for IFFData.RRB objects.
Definition: iffRRBStateRepository.h:29
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
DtMode4StateRepository
Instances of DtMode4StateRepository are used to store state data for IFFData.Mode4 objects...
Definition: iffMode4StateRepository.h:29
DtMode5StateRepository
Instances of DtMode5StateRepository are used to store state data for IFFData.Mode5 objects...
Definition: iffMode5StateRepository.h:30
DtMode3AStateRepository
Instances of DtMode3AStateRepository are used to store state data for IFFData.Mode3A objects...
Definition: iffMode3AStateRepository.h:29
hlaStateDecoder.h
This file contains the declaration of DtHlaStateDecoder.
Document ID: Generated on Thu Oct 16 00:12:25 EDT 2025 from SVN revision 280738
Copyright © 1992-2025 MAK Technologies. All Rights Reserved (www.mak.com)