sovietIffEncoder.h

Go to the documentation of this file.

#if DtHLA

#ifndef DtSovietIffEncoder_H_
#define DtSovietIffEncoder_H_

#include "iffEncoder.h"


class DT_DLL_VL DtSovietStateRepository;


#define DtDECLARE_SOVIET_IFF_ATTR_CHECKER(attrName) \
   DtDECLARE_ATTR_CHECKER(DtIffStateRepository, attrName)

#define DtDECLARE_SOVIET_IFF_ATTR_ENCODER(attrName) \
   DtDECLARE_ATTR_ENCODER(DtIffStateRepository, attrName)

#define DtDEFINE_SIMPLE_SOVIET_IFF_ATTR_ENCODER( \
   attrName, netType, inspector) \
   DtDEFINE_SIMPLE_ATTR_ENCODER(DtSovietIffEncoder, \
      DtSovietStateRepository, attrName, netType, inspector)

#define DtDEFINE_SIMPLE_SOVIET_IFF_ATTR_CHECKER( \
   attrName, inspector) \
   DtDEFINE_SIMPLE_ATTR_CHECKER(DtSovietIffEncoder, \
      DtSovietStateRepository, attrName, inspector)

#define DtDEFINE_SIMPLE_SOVIET_ATTR_ENCODER_WITH_PARAM(\
   encClass, stateRepClass, attrName, netType, inspector, param) \
   void encClass::encode##attrName(const stateRepClass& rep, \
   RTI::AttributeHandleValuePairSet* attrs, \
   RTI::AttributeHandle attrHandle) \
{ \
   netType netVal; \
   netVal = rep.soviet()->inspector(param); \
   attrs->add(attrHandle, (char*) &netVal, sizeof(netType)); \
}

#define DtDEFINE_SIMPLE_SOVIET_IFF_ATTR_ENCODER_WITH_PARAM( \
   attrName, netType, inspector, param) \
   DtDEFINE_SIMPLE_SOVIET_ATTR_ENCODER_WITH_PARAM( \
   DtSovietIffEncoder, DtIffStateRepository, attrName, netType, inspector, param)

#define DtDEFINE_SIMPLE_SOVIET_ATTR_CHECKER_WITH_PARAM( \
   encClass, stateRepClass, attrName, inspector, param) \
bool encClass::need##attrName(const stateRepClass& stateRep, \
   const stateRepClass& asSeenByRemote) \
{ \
   return (bool) !(stateRep.soviet()->inspector(param) == \
       asSeenByRemote.soviet()->inspector(param)); \
}

#define DtDEFINE_SIMPLE_SOVIET_IFF_ATTR_CHECKER_WITH_PARAM( \
   attrName, inspector, param) \
   DtDEFINE_SIMPLE_SOVIET_ATTR_CHECKER_WITH_PARAM( \
     DtSovietIffEncoder, DtIffStateRepository, attrName, inspector, param)

class DT_DLL_VL DtSovietIffEncoder : public DtIffEncoder
{
public:
   DtSovietIffEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtSovietIffEncoder();

   DtSovietIffEncoder(const DtSovietIffEncoder& orig);

   DtSovietIffEncoder& operator=(const DtSovietIffEncoder& orig);

public:

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

protected:

   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter1Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter1IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter1IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter1IsOn);

   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter2Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter2IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter2IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter2IsOn);

   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter3Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter3IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter3IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter3IsOn);

   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter4Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter4IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter4IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter4IsOn);

   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter5Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter5IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter5IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter5IsOn);

   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter6Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter6IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter6IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_CHECKER(Parameter6IsOn);

   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter1Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter1IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter1IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter1IsOn);

   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter2Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter2IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter2IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter2IsOn);

   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter3Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter3IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter3IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter3IsOn);

   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter4Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter4IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter4IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter4IsOn);

   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter5Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter5IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter5IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter5IsOn);

   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter6Enabled);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter6IsMalfunctioning);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter6IsDamaged);
   DtDECLARE_SOVIET_IFF_ATTR_ENCODER(Parameter6IsOn);

};

#define DtDEFINE_SIMPLE_MAKRPR3_SOVIET_IFF_TRANSPONDER_ATTR_ENCODER( \
   attrName, netType, inspector) \
   DtDEFINE_SIMPLE_ATTR_ENCODER(DtMAKRPR3_SovietIffTransponderEncoder, \
      DtIffStateRepository, attrName, netType, inspector)

#define DtDEFINE_SIMPLE_MAKRPR3_SOVIET_IFF_TRANSPONDER_ATTR_CHECKER( \
   attrName, inspector) \
   DtDEFINE_SIMPLE_ATTR_CHECKER(DtMAKRPR3_SovietIffTransponderEncoder, \
      DtIffStateRepository, attrName, inspector)

class DT_DLL_VL DtMAKRPR3_SovietIffTransponderEncoder : public DtSovietIffEncoder
{
public:
   DtMAKRPR3_SovietIffTransponderEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMAKRPR3_SovietIffTransponderEncoder();

   DtMAKRPR3_SovietIffTransponderEncoder(const DtMAKRPR3_SovietIffTransponderEncoder& orig);

   DtMAKRPR3_SovietIffTransponderEncoder& operator=(const DtMAKRPR3_SovietIffTransponderEncoder& orig);

public:

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

protected:

   DtDECLARE_IFF_ATTR_CHECKER(SystemDesignator);
   DtDECLARE_IFF_ATTR_ENCODER(SystemDesignator);

};

#define DtDEFINE_SIMPLE_MAKRPR3_SOVIET_IFF_INTERROGATOR_ATTR_ENCODER( \
   attrName, netType, inspector) \
   DtDEFINE_SIMPLE_ATTR_ENCODER(DtMAKRPR3_SovietIffInterrogatorEncoder, \
      DtIffStateRepository, attrName, netType, inspector)

#define DtDEFINE_SIMPLE_MAKRPR3_SOVIET_IFF_INTERROGATOR_ATTR_CHECKER( \
   attrName, inspector) \
   DtDEFINE_SIMPLE_ATTR_CHECKER(DtMAKRPR3_SovietIffInterrogatorEncoder, \
      DtIffStateRepository, attrName, inspector)

class DT_DLL_VL DtMAKRPR3_SovietIffInterrogatorEncoder : public DtSovietIffEncoder
{
public:
   DtMAKRPR3_SovietIffInterrogatorEncoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtMAKRPR3_SovietIffInterrogatorEncoder();

   DtMAKRPR3_SovietIffInterrogatorEncoder(const DtMAKRPR3_SovietIffInterrogatorEncoder& orig);

   DtMAKRPR3_SovietIffInterrogatorEncoder& operator=(const DtMAKRPR3_SovietIffInterrogatorEncoder& orig);

public:

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

protected:

   DtDECLARE_IFF_ATTR_CHECKER(SystemDesignator);
   DtDECLARE_IFF_ATTR_ENCODER(SystemDesignator);

};

#endif
#endif