iffDataEncoders.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2020 VT MAK
** All rights reserved.
*********************************************************************/

#pragma once

#if DtHLA

#include <vl/hlaStateDecoder.h>
#include <vl/hlaStateEncoder.h>

class DT_DLL_VL DtIFFDataStateRepository;
class DT_DLL_VL DtMode1StateRepository;
class DT_DLL_VL DtMode1InterrogatorStateRepository;
class DT_DLL_VL DtMode1TransponderStateRepository;
class DT_DLL_VL DtMode2StateRepository;
class DT_DLL_VL DtMode2InterrogatorStateRepository;
class DT_DLL_VL DtMode2TransponderStateRepository;
class DT_DLL_VL DtMode3AStateRepository;
class DT_DLL_VL DtMode3AInterrogatorStateRepository;
class DT_DLL_VL DtMode3ATransponderStateRepository;
class DT_DLL_VL DtMode4StateRepository;
class DT_DLL_VL DtMode4InterrogatorStateRepository;
class DT_DLL_VL DtMode4TransponderStateRepository;
class DT_DLL_VL DtMode5StateRepository;
class DT_DLL_VL DtMode5InterrogatorStateRepository;
class DT_DLL_VL DtMode5TransponderStateRepository;
class DT_DLL_VL DtModeCStateRepository;
class DT_DLL_VL DtModeCInterrogatorStateRepository;
class DT_DLL_VL DtModeCTransponderStateRepository;
class DT_DLL_VL DtModeSStateRepository;
class DT_DLL_VL DtModeSInterrogatorStateRepository;
class DT_DLL_VL DtModeSTransponderStateRepository;
class DT_DLL_VL DtSovietStateRepository;
class DT_DLL_VL DtSovietInterrogatorStateRepository;
class DT_DLL_VL DtSovietTransponderStateRepository;
class DT_DLL_VL DtTCASDataStateRepository;

class DT_DLL_VL DtIFFDataDecoder : public DtHlaStateDecoder
{
public:
   DtIFFDataDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtIFFDataDecoder();

   DtIFFDataDecoder(const DtIFFDataDecoder& orig);

   DtIFFDataDecoder& operator=(const DtIFFDataDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeIFFSystemIdentifier(
      DtIFFDataStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtIFFDataEncoder : public DtHlaStateEncoder
{
public:

   DtIFFDataEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtIFFDataEncoder();

   DtIFFDataEncoder(const DtIFFDataEncoder& orig);

   DtIFFDataEncoder& operator=(const DtIFFDataEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needIFFSystemIdentifier(
      const DtIFFDataStateRepository& stateRep,
      const DtIFFDataStateRepository& asSeenByRemote);

   static void encodeIFFSystemIdentifier(
      const DtIFFDataStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtMode1Decoder : public DtIFFDataDecoder
{
public:
   DtMode1Decoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode1Decoder();

   DtMode1Decoder(const DtMode1Decoder& orig);

   DtMode1Decoder& operator=(const DtMode1Decoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeIsOn(
      DtMode1StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsDamaged(
      DtMode1StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsMalfunctioning(
      DtMode1StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtMode1Encoder : public DtIFFDataEncoder
{
public:

   DtMode1Encoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode1Encoder();

   DtMode1Encoder(const DtMode1Encoder& orig);

   DtMode1Encoder& operator=(const DtMode1Encoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needIsOn(
      const DtMode1StateRepository& stateRep,
      const DtMode1StateRepository& asSeenByRemote);

   static void encodeIsOn(
      const DtMode1StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsDamaged(
      const DtMode1StateRepository& stateRep,
      const DtMode1StateRepository& asSeenByRemote);

   static void encodeIsDamaged(
      const DtMode1StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsMalfunctioning(
      const DtMode1StateRepository& stateRep,
      const DtMode1StateRepository& asSeenByRemote);

   static void encodeIsMalfunctioning(
      const DtMode1StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtMode1InterrogatorDecoder : public DtMode1Decoder
{
public:
   DtMode1InterrogatorDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode1InterrogatorDecoder();

   DtMode1InterrogatorDecoder(const DtMode1InterrogatorDecoder& orig);

   DtMode1InterrogatorDecoder& operator=(const DtMode1InterrogatorDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtMode1InterrogatorEncoder : public DtMode1Encoder
{
public:

   DtMode1InterrogatorEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode1InterrogatorEncoder();

   DtMode1InterrogatorEncoder(const DtMode1InterrogatorEncoder& orig);

   DtMode1InterrogatorEncoder& operator=(const DtMode1InterrogatorEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtMode1TransponderDecoder : public DtMode1Decoder
{
public:
   DtMode1TransponderDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode1TransponderDecoder();

   DtMode1TransponderDecoder(const DtMode1TransponderDecoder& orig);

   DtMode1TransponderDecoder& operator=(const DtMode1TransponderDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeCode(
      DtMode1TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeExtendedCodeIsSet(
      DtMode1TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtMode1TransponderEncoder : public DtMode1Encoder
{
public:

   DtMode1TransponderEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode1TransponderEncoder();

   DtMode1TransponderEncoder(const DtMode1TransponderEncoder& orig);

   DtMode1TransponderEncoder& operator=(const DtMode1TransponderEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needCode(
      const DtMode1TransponderStateRepository& stateRep,
      const DtMode1TransponderStateRepository& asSeenByRemote);

   static void encodeCode(
      const DtMode1TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needExtendedCodeIsSet(
      const DtMode1TransponderStateRepository& stateRep,
      const DtMode1TransponderStateRepository& asSeenByRemote);

   static void encodeExtendedCodeIsSet(
      const DtMode1TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtMode2Decoder : public DtIFFDataDecoder
{
public:
   DtMode2Decoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode2Decoder();

   DtMode2Decoder(const DtMode2Decoder& orig);

   DtMode2Decoder& operator=(const DtMode2Decoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeIsOn(
      DtMode2StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsDamaged(
      DtMode2StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsMalfunctioning(
      DtMode2StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtMode2Encoder : public DtIFFDataEncoder
{
public:

   DtMode2Encoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode2Encoder();

   DtMode2Encoder(const DtMode2Encoder& orig);

   DtMode2Encoder& operator=(const DtMode2Encoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needIsOn(
      const DtMode2StateRepository& stateRep,
      const DtMode2StateRepository& asSeenByRemote);

   static void encodeIsOn(
      const DtMode2StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsDamaged(
      const DtMode2StateRepository& stateRep,
      const DtMode2StateRepository& asSeenByRemote);

   static void encodeIsDamaged(
      const DtMode2StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsMalfunctioning(
      const DtMode2StateRepository& stateRep,
      const DtMode2StateRepository& asSeenByRemote);

   static void encodeIsMalfunctioning(
      const DtMode2StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtMode2InterrogatorDecoder : public DtMode2Decoder
{
public:
   DtMode2InterrogatorDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode2InterrogatorDecoder();

   DtMode2InterrogatorDecoder(const DtMode2InterrogatorDecoder& orig);

   DtMode2InterrogatorDecoder& operator=(const DtMode2InterrogatorDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtMode2InterrogatorEncoder : public DtMode2Encoder
{
public:

   DtMode2InterrogatorEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode2InterrogatorEncoder();

   DtMode2InterrogatorEncoder(const DtMode2InterrogatorEncoder& orig);

   DtMode2InterrogatorEncoder& operator=(const DtMode2InterrogatorEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtMode2TransponderDecoder : public DtMode2Decoder
{
public:
   DtMode2TransponderDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode2TransponderDecoder();

   DtMode2TransponderDecoder(const DtMode2TransponderDecoder& orig);

   DtMode2TransponderDecoder& operator=(const DtMode2TransponderDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeCode(
      DtMode2TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtMode2TransponderEncoder : public DtMode2Encoder
{
public:

   DtMode2TransponderEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode2TransponderEncoder();

   DtMode2TransponderEncoder(const DtMode2TransponderEncoder& orig);

   DtMode2TransponderEncoder& operator=(const DtMode2TransponderEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needCode(
      const DtMode2TransponderStateRepository& stateRep,
      const DtMode2TransponderStateRepository& asSeenByRemote);

   static void encodeCode(
      const DtMode2TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtMode3ADecoder : public DtIFFDataDecoder
{
public:
   DtMode3ADecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode3ADecoder();

   DtMode3ADecoder(const DtMode3ADecoder& orig);

   DtMode3ADecoder& operator=(const DtMode3ADecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeIsOn(
      DtMode3AStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsDamaged(
      DtMode3AStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsMalfunctioning(
      DtMode3AStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtMode3AEncoder : public DtIFFDataEncoder
{
public:

   DtMode3AEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode3AEncoder();

   DtMode3AEncoder(const DtMode3AEncoder& orig);

   DtMode3AEncoder& operator=(const DtMode3AEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needIsOn(
      const DtMode3AStateRepository& stateRep,
      const DtMode3AStateRepository& asSeenByRemote);

   static void encodeIsOn(
      const DtMode3AStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsDamaged(
      const DtMode3AStateRepository& stateRep,
      const DtMode3AStateRepository& asSeenByRemote);

   static void encodeIsDamaged(
      const DtMode3AStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsMalfunctioning(
      const DtMode3AStateRepository& stateRep,
      const DtMode3AStateRepository& asSeenByRemote);

   static void encodeIsMalfunctioning(
      const DtMode3AStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtMode3AInterrogatorDecoder : public DtMode3ADecoder
{
public:
   DtMode3AInterrogatorDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode3AInterrogatorDecoder();

   DtMode3AInterrogatorDecoder(const DtMode3AInterrogatorDecoder& orig);

   DtMode3AInterrogatorDecoder& operator=(const DtMode3AInterrogatorDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtMode3AInterrogatorEncoder : public DtMode3AEncoder
{
public:

   DtMode3AInterrogatorEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode3AInterrogatorEncoder();

   DtMode3AInterrogatorEncoder(const DtMode3AInterrogatorEncoder& orig);

   DtMode3AInterrogatorEncoder& operator=(const DtMode3AInterrogatorEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtMode3ATransponderDecoder : public DtMode3ADecoder
{
public:
   DtMode3ATransponderDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode3ATransponderDecoder();

   DtMode3ATransponderDecoder(const DtMode3ATransponderDecoder& orig);

   DtMode3ATransponderDecoder& operator=(const DtMode3ATransponderDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeCode(
      DtMode3ATransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtMode3ATransponderEncoder : public DtMode3AEncoder
{
public:

   DtMode3ATransponderEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode3ATransponderEncoder();

   DtMode3ATransponderEncoder(const DtMode3ATransponderEncoder& orig);

   DtMode3ATransponderEncoder& operator=(const DtMode3ATransponderEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needCode(
      const DtMode3ATransponderStateRepository& stateRep,
      const DtMode3ATransponderStateRepository& asSeenByRemote);

   static void encodeCode(
      const DtMode3ATransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtMode4Decoder : public DtIFFDataDecoder
{
public:
   DtMode4Decoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode4Decoder();

   DtMode4Decoder(const DtMode4Decoder& orig);

   DtMode4Decoder& operator=(const DtMode4Decoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeIsOn(
      DtMode4StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsDamaged(
      DtMode4StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsMalfunctioning(
      DtMode4StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodePseudoCryptoCodeAAvailable(
      DtMode4StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodePseudoCryptoCodeA(
      DtMode4StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodePseudoCryptoCodeBAvailable(
      DtMode4StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodePseudoCryptoCodeB(
      DtMode4StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodePseudoCryptoCodeActive(
      DtMode4StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtMode4Encoder : public DtIFFDataEncoder
{
public:

   DtMode4Encoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode4Encoder();

   DtMode4Encoder(const DtMode4Encoder& orig);

   DtMode4Encoder& operator=(const DtMode4Encoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needIsOn(
      const DtMode4StateRepository& stateRep,
      const DtMode4StateRepository& asSeenByRemote);

   static void encodeIsOn(
      const DtMode4StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsDamaged(
      const DtMode4StateRepository& stateRep,
      const DtMode4StateRepository& asSeenByRemote);

   static void encodeIsDamaged(
      const DtMode4StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsMalfunctioning(
      const DtMode4StateRepository& stateRep,
      const DtMode4StateRepository& asSeenByRemote);

   static void encodeIsMalfunctioning(
      const DtMode4StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needPseudoCryptoCodeAAvailable(
      const DtMode4StateRepository& stateRep,
      const DtMode4StateRepository& asSeenByRemote);

   static void encodePseudoCryptoCodeAAvailable(
      const DtMode4StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needPseudoCryptoCodeA(
      const DtMode4StateRepository& stateRep,
      const DtMode4StateRepository& asSeenByRemote);

   static void encodePseudoCryptoCodeA(
      const DtMode4StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needPseudoCryptoCodeBAvailable(
      const DtMode4StateRepository& stateRep,
      const DtMode4StateRepository& asSeenByRemote);

   static void encodePseudoCryptoCodeBAvailable(
      const DtMode4StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needPseudoCryptoCodeB(
      const DtMode4StateRepository& stateRep,
      const DtMode4StateRepository& asSeenByRemote);

   static void encodePseudoCryptoCodeB(
      const DtMode4StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needPseudoCryptoCodeActive(
      const DtMode4StateRepository& stateRep,
      const DtMode4StateRepository& asSeenByRemote);

   static void encodePseudoCryptoCodeActive(
      const DtMode4StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtMode4InterrogatorDecoder : public DtMode4Decoder
{
public:
   DtMode4InterrogatorDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode4InterrogatorDecoder();

   DtMode4InterrogatorDecoder(const DtMode4InterrogatorDecoder& orig);

   DtMode4InterrogatorDecoder& operator=(const DtMode4InterrogatorDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeChallenge(
      DtMode4InterrogatorStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtMode4InterrogatorEncoder : public DtMode4Encoder
{
public:

   DtMode4InterrogatorEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode4InterrogatorEncoder();

   DtMode4InterrogatorEncoder(const DtMode4InterrogatorEncoder& orig);

   DtMode4InterrogatorEncoder& operator=(const DtMode4InterrogatorEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needChallenge(
      const DtMode4InterrogatorStateRepository& stateRep,
      const DtMode4InterrogatorStateRepository& asSeenByRemote);

   static void encodeChallenge(
      const DtMode4InterrogatorStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtMode4TransponderDecoder : public DtMode4Decoder
{
public:
   DtMode4TransponderDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode4TransponderDecoder();

   DtMode4TransponderDecoder(const DtMode4TransponderDecoder& orig);

   DtMode4TransponderDecoder& operator=(const DtMode4TransponderDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeReply(
      DtMode4TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtMode4TransponderEncoder : public DtMode4Encoder
{
public:

   DtMode4TransponderEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode4TransponderEncoder();

   DtMode4TransponderEncoder(const DtMode4TransponderEncoder& orig);

   DtMode4TransponderEncoder& operator=(const DtMode4TransponderEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needReply(
      const DtMode4TransponderStateRepository& stateRep,
      const DtMode4TransponderStateRepository& asSeenByRemote);

   static void encodeReply(
      const DtMode4TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtMode5Decoder : public DtIFFDataDecoder
{
public:
   DtMode5Decoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode5Decoder();

   DtMode5Decoder(const DtMode5Decoder& orig);

   DtMode5Decoder& operator=(const DtMode5Decoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeIsOn(
      DtMode5StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsDamaged(
      DtMode5StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsMalfunctioning(
      DtMode5StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodePseudoCryptoCodeAvailable(
      DtMode5StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodePseudoCryptoCode(
      DtMode5StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeSpecificInformation(
      DtMode5StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeMission(
      DtMode5StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeMessageFormatsCapable(
      DtMode5StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIFFData(
      DtMode5StateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtMode5Encoder : public DtIFFDataEncoder
{
public:

   DtMode5Encoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode5Encoder();

   DtMode5Encoder(const DtMode5Encoder& orig);

   DtMode5Encoder& operator=(const DtMode5Encoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needIsOn(
      const DtMode5StateRepository& stateRep,
      const DtMode5StateRepository& asSeenByRemote);

   static void encodeIsOn(
      const DtMode5StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsDamaged(
      const DtMode5StateRepository& stateRep,
      const DtMode5StateRepository& asSeenByRemote);

   static void encodeIsDamaged(
      const DtMode5StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsMalfunctioning(
      const DtMode5StateRepository& stateRep,
      const DtMode5StateRepository& asSeenByRemote);

   static void encodeIsMalfunctioning(
      const DtMode5StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needPseudoCryptoCodeAvailable(
      const DtMode5StateRepository& stateRep,
      const DtMode5StateRepository& asSeenByRemote);

   static void encodePseudoCryptoCodeAvailable(
      const DtMode5StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needPseudoCryptoCode(
      const DtMode5StateRepository& stateRep,
      const DtMode5StateRepository& asSeenByRemote);

   static void encodePseudoCryptoCode(
      const DtMode5StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needSpecificInformation(
      const DtMode5StateRepository& stateRep,
      const DtMode5StateRepository& asSeenByRemote);

   static void encodeSpecificInformation(
      const DtMode5StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needMission(
      const DtMode5StateRepository& stateRep,
      const DtMode5StateRepository& asSeenByRemote);

   static void encodeMission(
      const DtMode5StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needMessageFormatsCapable(
      const DtMode5StateRepository& stateRep,
      const DtMode5StateRepository& asSeenByRemote);

   static void encodeMessageFormatsCapable(
      const DtMode5StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIFFData(
      const DtMode5StateRepository& stateRep,
      const DtMode5StateRepository& asSeenByRemote);

   static void encodeIFFData(
      const DtMode5StateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtMode5InterrogatorDecoder : public DtMode5Decoder
{
public:
   DtMode5InterrogatorDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode5InterrogatorDecoder();

   DtMode5InterrogatorDecoder(const DtMode5InterrogatorDecoder& orig);

   DtMode5InterrogatorDecoder& operator=(const DtMode5InterrogatorDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtMode5InterrogatorEncoder : public DtMode5Encoder
{
public:

   DtMode5InterrogatorEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode5InterrogatorEncoder();

   DtMode5InterrogatorEncoder(const DtMode5InterrogatorEncoder& orig);

   DtMode5InterrogatorEncoder& operator=(const DtMode5InterrogatorEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtMode5TransponderDecoder : public DtMode5Decoder
{
public:
   DtMode5TransponderDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode5TransponderDecoder();

   DtMode5TransponderDecoder(const DtMode5TransponderDecoder& orig);

   DtMode5TransponderDecoder& operator=(const DtMode5TransponderDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodePlatformType(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeNationalOrigin(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodePersonalIdentificationNumber(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeAntennaSelection(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeLevelSelection(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeSquitterIsOn(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeLevel2SquitterStatus(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeLineTestIsEnabled(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeReply(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeFigureOfMerit(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeNavigationSource(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeCryptoControlDataIsPresent(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeLocationDataIsPresent(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeLocationErrorDataIsPresent(
      DtMode5TransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtMode5TransponderEncoder : public DtMode5Encoder
{
public:

   DtMode5TransponderEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMode5TransponderEncoder();

   DtMode5TransponderEncoder(const DtMode5TransponderEncoder& orig);

   DtMode5TransponderEncoder& operator=(const DtMode5TransponderEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needPlatformType(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodePlatformType(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needNationalOrigin(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeNationalOrigin(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needPersonalIdentificationNumber(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodePersonalIdentificationNumber(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needAntennaSelection(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeAntennaSelection(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needLevelSelection(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeLevelSelection(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needSquitterIsOn(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeSquitterIsOn(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needLevel2SquitterStatus(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeLevel2SquitterStatus(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needLineTestIsEnabled(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeLineTestIsEnabled(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needReply(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeReply(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needFigureOfMerit(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeFigureOfMerit(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needNavigationSource(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeNavigationSource(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needCryptoControlDataIsPresent(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeCryptoControlDataIsPresent(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needLocationDataIsPresent(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeLocationDataIsPresent(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needLocationErrorDataIsPresent(
      const DtMode5TransponderStateRepository& stateRep,
      const DtMode5TransponderStateRepository& asSeenByRemote);

   static void encodeLocationErrorDataIsPresent(
      const DtMode5TransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtModeCDecoder : public DtIFFDataDecoder
{
public:
   DtModeCDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeCDecoder();

   DtModeCDecoder(const DtModeCDecoder& orig);

   DtModeCDecoder& operator=(const DtModeCDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeIsOn(
      DtModeCStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsDamaged(
      DtModeCStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsMalfunctioning(
      DtModeCStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtModeCEncoder : public DtIFFDataEncoder
{
public:

   DtModeCEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeCEncoder();

   DtModeCEncoder(const DtModeCEncoder& orig);

   DtModeCEncoder& operator=(const DtModeCEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needIsOn(
      const DtModeCStateRepository& stateRep,
      const DtModeCStateRepository& asSeenByRemote);

   static void encodeIsOn(
      const DtModeCStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsDamaged(
      const DtModeCStateRepository& stateRep,
      const DtModeCStateRepository& asSeenByRemote);

   static void encodeIsDamaged(
      const DtModeCStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsMalfunctioning(
      const DtModeCStateRepository& stateRep,
      const DtModeCStateRepository& asSeenByRemote);

   static void encodeIsMalfunctioning(
      const DtModeCStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtModeCInterrogatorDecoder : public DtModeCDecoder
{
public:
   DtModeCInterrogatorDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeCInterrogatorDecoder();

   DtModeCInterrogatorDecoder(const DtModeCInterrogatorDecoder& orig);

   DtModeCInterrogatorDecoder& operator=(const DtModeCInterrogatorDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtModeCInterrogatorEncoder : public DtModeCEncoder
{
public:

   DtModeCInterrogatorEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeCInterrogatorEncoder();

   DtModeCInterrogatorEncoder(const DtModeCInterrogatorEncoder& orig);

   DtModeCInterrogatorEncoder& operator=(const DtModeCInterrogatorEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtModeCTransponderDecoder : public DtModeCDecoder
{
public:
   DtModeCTransponderDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeCTransponderDecoder();

   DtModeCTransponderDecoder(const DtModeCTransponderDecoder& orig);

   DtModeCTransponderDecoder& operator=(const DtModeCTransponderDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeAltitudeAvailable(
      DtModeCTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeAltitude(
      DtModeCTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtModeCTransponderEncoder : public DtModeCEncoder
{
public:

   DtModeCTransponderEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeCTransponderEncoder();

   DtModeCTransponderEncoder(const DtModeCTransponderEncoder& orig);

   DtModeCTransponderEncoder& operator=(const DtModeCTransponderEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needAltitudeAvailable(
      const DtModeCTransponderStateRepository& stateRep,
      const DtModeCTransponderStateRepository& asSeenByRemote);

   static void encodeAltitudeAvailable(
      const DtModeCTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needAltitude(
      const DtModeCTransponderStateRepository& stateRep,
      const DtModeCTransponderStateRepository& asSeenByRemote);

   static void encodeAltitude(
      const DtModeCTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtModeSDecoder : public DtIFFDataDecoder
{
public:
   DtModeSDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeSDecoder();

   DtModeSDecoder(const DtModeSDecoder& orig);

   DtModeSDecoder& operator=(const DtModeSDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeIsOn(
      DtModeSStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsDamaged(
      DtModeSStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsMalfunctioning(
      DtModeSStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeSpecificInformation(
      DtModeSStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeLevelsPresent(
      DtModeSStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIFFData(
      DtModeSStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtModeSEncoder : public DtIFFDataEncoder
{
public:

   DtModeSEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeSEncoder();

   DtModeSEncoder(const DtModeSEncoder& orig);

   DtModeSEncoder& operator=(const DtModeSEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needIsOn(
      const DtModeSStateRepository& stateRep,
      const DtModeSStateRepository& asSeenByRemote);

   static void encodeIsOn(
      const DtModeSStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsDamaged(
      const DtModeSStateRepository& stateRep,
      const DtModeSStateRepository& asSeenByRemote);

   static void encodeIsDamaged(
      const DtModeSStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsMalfunctioning(
      const DtModeSStateRepository& stateRep,
      const DtModeSStateRepository& asSeenByRemote);

   static void encodeIsMalfunctioning(
      const DtModeSStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needSpecificInformation(
      const DtModeSStateRepository& stateRep,
      const DtModeSStateRepository& asSeenByRemote);

   static void encodeSpecificInformation(
      const DtModeSStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needLevelsPresent(
      const DtModeSStateRepository& stateRep,
      const DtModeSStateRepository& asSeenByRemote);

   static void encodeLevelsPresent(
      const DtModeSStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIFFData(
      const DtModeSStateRepository& stateRep,
      const DtModeSStateRepository& asSeenByRemote);

   static void encodeIFFData(
      const DtModeSStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtModeSInterrogatorDecoder : public DtModeSDecoder
{
public:
   DtModeSInterrogatorDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeSInterrogatorDecoder();

   DtModeSInterrogatorDecoder(const DtModeSInterrogatorDecoder& orig);

   DtModeSInterrogatorDecoder& operator=(const DtModeSInterrogatorDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeInterrogatorIdentifier(
      DtModeSInterrogatorStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeTransmitState(
      DtModeSInterrogatorStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtModeSInterrogatorEncoder : public DtModeSEncoder
{
public:

   DtModeSInterrogatorEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeSInterrogatorEncoder();

   DtModeSInterrogatorEncoder(const DtModeSInterrogatorEncoder& orig);

   DtModeSInterrogatorEncoder& operator=(const DtModeSInterrogatorEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needInterrogatorIdentifier(
      const DtModeSInterrogatorStateRepository& stateRep,
      const DtModeSInterrogatorStateRepository& asSeenByRemote);

   static void encodeInterrogatorIdentifier(
      const DtModeSInterrogatorStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needTransmitState(
      const DtModeSInterrogatorStateRepository& stateRep,
      const DtModeSInterrogatorStateRepository& asSeenByRemote);

   static void encodeTransmitState(
      const DtModeSInterrogatorStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtModeSTransponderDecoder : public DtModeSDecoder
{
public:
   DtModeSTransponderDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeSTransponderDecoder();

   DtModeSTransponderDecoder(const DtModeSTransponderDecoder& orig);

   DtModeSTransponderDecoder& operator=(const DtModeSTransponderDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeAircraftAddress(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeAircraftIdentificationType(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeAircraftIdentification(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeSquitterIsOn(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeSquitterType(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeCapabilityReport(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeAircraftPresentDomain(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeAltitudeAvailable(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeAltitude(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeSquitterRecordSource(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeAirbornePositionReportDataIsPresent(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeAirborneVelocityReportDataIsPresent(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeSurfacePositionReportDataIsPresent(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIdentificationReportDataIsPresent(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeEventDrivenReportDataIsPresent(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeDAPSource(
      DtModeSTransponderStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtModeSTransponderEncoder : public DtModeSEncoder
{
public:

   DtModeSTransponderEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtModeSTransponderEncoder();

   DtModeSTransponderEncoder(const DtModeSTransponderEncoder& orig);

   DtModeSTransponderEncoder& operator=(const DtModeSTransponderEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needAircraftAddress(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeAircraftAddress(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needAircraftIdentificationType(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeAircraftIdentificationType(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needAircraftIdentification(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeAircraftIdentification(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needSquitterIsOn(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeSquitterIsOn(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needSquitterType(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeSquitterType(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needCapabilityReport(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeCapabilityReport(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needAircraftPresentDomain(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeAircraftPresentDomain(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needAltitudeAvailable(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeAltitudeAvailable(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needAltitude(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeAltitude(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needSquitterRecordSource(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeSquitterRecordSource(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needAirbornePositionReportDataIsPresent(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeAirbornePositionReportDataIsPresent(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needAirborneVelocityReportDataIsPresent(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeAirborneVelocityReportDataIsPresent(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needSurfacePositionReportDataIsPresent(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeSurfacePositionReportDataIsPresent(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIdentificationReportDataIsPresent(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeIdentificationReportDataIsPresent(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needEventDrivenReportDataIsPresent(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeEventDrivenReportDataIsPresent(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needDAPSource(
      const DtModeSTransponderStateRepository& stateRep,
      const DtModeSTransponderStateRepository& asSeenByRemote);

   static void encodeDAPSource(
      const DtModeSTransponderStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtSovietDecoder : public DtIFFDataDecoder
{
public:
   DtSovietDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtSovietDecoder();

   DtSovietDecoder(const DtSovietDecoder& orig);

   DtSovietDecoder& operator=(const DtSovietDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeIsOn(
      DtSovietStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsDamaged(
      DtSovietStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsMalfunctioning(
      DtSovietStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtSovietEncoder : public DtIFFDataEncoder
{
public:

   DtSovietEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtSovietEncoder();

   DtSovietEncoder(const DtSovietEncoder& orig);

   DtSovietEncoder& operator=(const DtSovietEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needIsOn(
      const DtSovietStateRepository& stateRep,
      const DtSovietStateRepository& asSeenByRemote);

   static void encodeIsOn(
      const DtSovietStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsDamaged(
      const DtSovietStateRepository& stateRep,
      const DtSovietStateRepository& asSeenByRemote);

   static void encodeIsDamaged(
      const DtSovietStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsMalfunctioning(
      const DtSovietStateRepository& stateRep,
      const DtSovietStateRepository& asSeenByRemote);

   static void encodeIsMalfunctioning(
      const DtSovietStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

class DT_DLL_VL DtSovietInterrogatorDecoder : public DtSovietDecoder
{
public:
   DtSovietInterrogatorDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtSovietInterrogatorDecoder();

   DtSovietInterrogatorDecoder(const DtSovietInterrogatorDecoder& orig);

   DtSovietInterrogatorDecoder& operator=(const DtSovietInterrogatorDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtSovietInterrogatorEncoder : public DtSovietEncoder
{
public:

   DtSovietInterrogatorEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtSovietInterrogatorEncoder();

   DtSovietInterrogatorEncoder(const DtSovietInterrogatorEncoder& orig);

   DtSovietInterrogatorEncoder& operator=(const DtSovietInterrogatorEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtSovietTransponderDecoder : public DtSovietDecoder
{
public:
   DtSovietTransponderDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtSovietTransponderDecoder();

   DtSovietTransponderDecoder(const DtSovietTransponderDecoder& orig);

   DtSovietTransponderDecoder& operator=(const DtSovietTransponderDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtSovietTransponderEncoder : public DtSovietEncoder
{
public:

   DtSovietTransponderEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtSovietTransponderEncoder();

   DtSovietTransponderEncoder(const DtSovietTransponderEncoder& orig);

   DtSovietTransponderEncoder& operator=(const DtSovietTransponderEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

};

class DT_DLL_VL DtTCASDataDecoder : public DtIFFDataDecoder
{
public:
   DtTCASDataDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtTCASDataDecoder();

   DtTCASDataDecoder(const DtTCASDataDecoder& orig);

   DtTCASDataDecoder& operator=(const DtTCASDataDecoder& orig);

public:
   static DtHlaStateDecoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static void decodeIsOn(
      DtTCASDataStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsDamaged(
      DtTCASDataStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeIsMalfunctioning(
      DtTCASDataStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeTCAS_I_II_Type(
      DtTCASDataStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeBasicAdvancedIndicator(
      DtTCASDataStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeTCAS_ACASType(
      DtTCASDataStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeTCAS_ACASIndicator(
      DtTCASDataStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

   static void decodeSoftwareVersion(
      DtTCASDataStateRepository* rep,
      const RTI::AttributeHandleValuePairSet& attrs,
      int pairSetIndex);

};

class DT_DLL_VL DtTCASDataEncoder : public DtIFFDataEncoder
{
public:

   DtTCASDataEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtTCASDataEncoder();

   DtTCASDataEncoder(const DtTCASDataEncoder& orig);

   DtTCASDataEncoder& operator=(const DtTCASDataEncoder& orig);

public:
   static DtHlaStateEncoder* create(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

protected:

   static bool needIsOn(
      const DtTCASDataStateRepository& stateRep,
      const DtTCASDataStateRepository& asSeenByRemote);

   static void encodeIsOn(
      const DtTCASDataStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsDamaged(
      const DtTCASDataStateRepository& stateRep,
      const DtTCASDataStateRepository& asSeenByRemote);

   static void encodeIsDamaged(
      const DtTCASDataStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needIsMalfunctioning(
      const DtTCASDataStateRepository& stateRep,
      const DtTCASDataStateRepository& asSeenByRemote);

   static void encodeIsMalfunctioning(
      const DtTCASDataStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needTCAS_I_II_Type(
      const DtTCASDataStateRepository& stateRep,
      const DtTCASDataStateRepository& asSeenByRemote);

   static void encodeTCAS_I_II_Type(
      const DtTCASDataStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needBasicAdvancedIndicator(
      const DtTCASDataStateRepository& stateRep,
      const DtTCASDataStateRepository& asSeenByRemote);

   static void encodeBasicAdvancedIndicator(
      const DtTCASDataStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needTCAS_ACASType(
      const DtTCASDataStateRepository& stateRep,
      const DtTCASDataStateRepository& asSeenByRemote);

   static void encodeTCAS_ACASType(
      const DtTCASDataStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needTCAS_ACASIndicator(
      const DtTCASDataStateRepository& stateRep,
      const DtTCASDataStateRepository& asSeenByRemote);

   static void encodeTCAS_ACASIndicator(
      const DtTCASDataStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

   static bool needSoftwareVersion(
      const DtTCASDataStateRepository& stateRep,
      const DtTCASDataStateRepository& asSeenByRemote);

   static void encodeSoftwareVersion(
      const DtTCASDataStateRepository& rep,
      RTI::AttributeHandleValuePairSet* attrs,
      RTI::AttributeHandle attrHandle);

};

#endif