iffDataPublishers.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2020 MAK Technologies, Inc
** All rights reserved.
*********************************************************************/


#pragma once

#if DtHLA

#include <vl/objectPublisherHLA.h>
#include "vlpi/disEnums.h"


class DT_DLL_VL DtIFFDataStateRepository;
class DT_DLL_VL DtMode1StateRepository;
class DT_DLL_VL DtMode2StateRepository;
class DT_DLL_VL DtMode3AStateRepository;
class DT_DLL_VL DtMode3CStateRepository;
class DT_DLL_VL DtMode4StateRepository;
class DT_DLL_VL DtMode5StateRepository;
class DT_DLL_VL DtModeSStateRepository;
class DT_DLL_VL DtTCASDataStateRepository;
class DT_DLL_VL DtSovietStateRepository;
class DT_DLL_VL DtRRBStateRepository;


class DT_DLL_VL DtIFFDataPublisher : public DtObjectPublisher
{
public:
   typedef DtIFFDataStateRepository* (*DtStateRepCreator)();

public:
   DtIFFDataPublisher(
      DtIFFDataStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtIFFDataPublisher(
      RTI::ObjectClassHandle h,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtIFFDataPublisher(
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtIFFDataPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   virtual const char * objectClassName();

   virtual ~DtIFFDataPublisher();

private:
   DtIFFDataPublisher(const DtIFFDataPublisher& orig);

   DtIFFDataPublisher& operator=(
      const DtIFFDataPublisher& orig);

public:

   virtual DtIFFDataStateRepository* IFFDataStateRep();

   virtual DtIFFDataStateRepository* Isr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtIFFDataStateRepository* DtIFFDataPublisher::IFFDataStateRep()
{
   return (DtIFFDataStateRepository*)myStateRep;
}

inline DtIFFDataStateRepository* DtIFFDataPublisher::Isr()
{
   return (DtIFFDataStateRepository*)myStateRep;
}

/*************** Mode 1 *****************/

class DT_DLL_VL DtMode1Publisher : public DtObjectPublisher
{
public:
   typedef DtMode1StateRepository* (*DtStateRepCreator)();

public:
   DtMode1Publisher(
      DtMode1StateRepository* stateRepToUse,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode1Publisher(
      DtMode1StateRepository* stateRepToUse,
      DtExerciseConn* conn,
      DtIffAtcNavaidsSysType type = DtIffAtcNavaidsSysType::DtIffAtcNavaidsTransponder,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode1Publisher(
      RTI::ObjectClassHandle h,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode1Publisher(
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode1Publisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   const char * objectClassName();

   virtual ~DtMode1Publisher();

private:
   DtMode1Publisher(const DtMode1Publisher& orig);

   DtMode1Publisher& operator=(
      const DtMode1Publisher& orig);

   void setObjectClassName(const char* name);

public:

   virtual DtMode1StateRepository* mode1StateRep();

   virtual DtMode1StateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
   const char* myObjectClassName;
};

inline DtMode1StateRepository* DtMode1Publisher::mode1StateRep()
{
   return (DtMode1StateRepository*)myStateRep;
}

inline DtMode1StateRepository* DtMode1Publisher::msr()
{
   return (DtMode1StateRepository*)myStateRep;
}

/*************** Mode 1 *****************/
/*************** Mode 2 *****************/

class DT_DLL_VL DtMode2Publisher : public DtObjectPublisher
{
public:
   typedef DtMode2StateRepository* (*DtStateRepCreator)();

public:
   DtMode2Publisher(
      DtMode2StateRepository* stateRepToUse,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode2Publisher(
      DtMode2StateRepository* stateRepToUse,
      DtExerciseConn* conn,
      DtIffAtcNavaidsSysType type = DtIffAtcNavaidsSysType::DtIffAtcNavaidsTransponder,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode2Publisher(
      RTI::ObjectClassHandle h,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode2Publisher(
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode2Publisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   const char * objectClassName();

   virtual ~DtMode2Publisher();

private:
   DtMode2Publisher(const DtMode2Publisher& orig);

   DtMode2Publisher& operator=(
      const DtMode2Publisher& orig);

   void setObjectClassName(const char* name);

public:

   virtual DtMode2StateRepository* mode2StateRep();

   virtual DtMode2StateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
   const char* myObjectClassName;
};

inline DtMode2StateRepository* DtMode2Publisher::mode2StateRep()
{
   return (DtMode2StateRepository*)myStateRep;
}

inline DtMode2StateRepository* DtMode2Publisher::msr()
{
   return (DtMode2StateRepository*)myStateRep;
}
/*************** Mode 2 *****************/
/*************** Mode 3A *****************/
class DT_DLL_VL DtMode3APublisher : public DtObjectPublisher
{
public:
   typedef DtMode3AStateRepository* (*DtStateRepCreator)();

public:
   DtMode3APublisher(
      DtMode3AStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode3APublisher(
      DtMode3AStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      DtIffAtcNavaidsSysType type = DtIffAtcNavaidsSysType::DtIffAtcNavaidsTransponder,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode3APublisher(
      RTI::ObjectClassHandle h,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode3APublisher(
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode3APublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   const char * objectClassName();

   virtual ~DtMode3APublisher();

private:
   DtMode3APublisher(const DtMode3APublisher& orig);

   DtMode3APublisher& operator=(
      const DtMode3APublisher& orig);
   
   void setObjectClassName(const char* name);

public:

   virtual DtMode3AStateRepository* mode3AStateRep();

   virtual DtMode3AStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
   const char* myObjectClassName;
};

inline DtMode3AStateRepository* DtMode3APublisher::mode3AStateRep()
{
   return (DtMode3AStateRepository*)myStateRep;
}

inline DtMode3AStateRepository* DtMode3APublisher::msr()
{
   return (DtMode3AStateRepository*)myStateRep;
}
/*************** Mode 3A *****************/
/*************** Mode 3C *****************/
class DT_DLL_VL DtMode3CPublisher : public DtObjectPublisher
{
public:
   typedef DtMode3CStateRepository* (*DtStateRepCreator)();

public:
   DtMode3CPublisher(
      DtMode3CStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode3CPublisher(
      DtMode3CStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      DtIffAtcNavaidsSysType type = DtIffAtcNavaidsSysType::DtIffAtcNavaidsTransponder,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode3CPublisher(
      RTI::ObjectClassHandle h,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode3CPublisher(
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode3CPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   const char * objectClassName();

   virtual ~DtMode3CPublisher();

private:
   DtMode3CPublisher(const DtMode3CPublisher& orig);

   DtMode3CPublisher& operator=(
      const DtMode3CPublisher& orig);

   void setObjectClassName(const char* name);

public:

   virtual DtMode3CStateRepository* Mode3CStateRep();

   virtual DtMode3CStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
   const char* myObjectClassName;
};

inline DtMode3CStateRepository* DtMode3CPublisher::Mode3CStateRep()
{
   return (DtMode3CStateRepository*)myStateRep;
}

inline DtMode3CStateRepository* DtMode3CPublisher::msr()
{
   return (DtMode3CStateRepository*)myStateRep;
}
/*************** Mode 3C *****************/
/*************** Mode 4 *****************/
class DT_DLL_VL DtMode4Publisher : public DtObjectPublisher
{
public:
   typedef DtMode4StateRepository* (*DtStateRepCreator)();

public:
   DtMode4Publisher(
      DtMode4StateRepository* stateRepToUse,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode4Publisher(
      DtMode4StateRepository* stateRepToUse,
      DtExerciseConn* conn,
      DtIffAtcNavaidsSysType type = DtIffAtcNavaidsSysType::DtIffAtcNavaidsTransponder,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode4Publisher(
      RTI::ObjectClassHandle h,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode4Publisher(
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode4Publisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   const char * objectClassName();

   virtual ~DtMode4Publisher();

private:
   DtMode4Publisher(const DtMode4Publisher& orig);

   DtMode4Publisher& operator=(
      const DtMode4Publisher& orig);

   void setObjectClassName(const char* name);

public:

   virtual DtMode4StateRepository* mode4StateRep();

   virtual DtMode4StateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
   const char* myObjectClassName;
};

inline DtMode4StateRepository* DtMode4Publisher::mode4StateRep()
{
   return (DtMode4StateRepository*)myStateRep;
}

inline DtMode4StateRepository* DtMode4Publisher::msr()
{
   return (DtMode4StateRepository*)myStateRep;
}
/*************** Mode 4 *****************/
/*************** Mode 5 *****************/
class DT_DLL_VL DtMode5Publisher : public DtObjectPublisher
{
public:
   typedef DtMode5StateRepository* (*DtStateRepCreator)();

public:
   DtMode5Publisher(
      DtMode5StateRepository* stateRepToUse,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode5Publisher(
      DtMode5StateRepository* stateRepToUse,
      DtExerciseConn* conn,
      DtIffAtcNavaidsSysType type = DtIffAtcNavaidsSysType::DtIffAtcNavaidsTransponder,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode5Publisher(
      RTI::ObjectClassHandle h,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode5Publisher(
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtMode5Publisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   const char * objectClassName();

   virtual ~DtMode5Publisher();

private:
   DtMode5Publisher(const DtMode5Publisher& orig);

   DtMode5Publisher& operator=(
      const DtMode5Publisher& orig);

   void setObjectClassName(const char* name);

public:

   virtual DtMode5StateRepository* mode5StateRep();

   virtual DtMode5StateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
   const char* myObjectClassName;
};

inline DtMode5StateRepository* DtMode5Publisher::mode5StateRep()
{
   return (DtMode5StateRepository*)myStateRep;
}

inline DtMode5StateRepository* DtMode5Publisher::msr()
{
   return (DtMode5StateRepository*)myStateRep;
}

/*************** Mode 5 *****************/
/*************** Mode S *****************/
class DT_DLL_VL DtModeSPublisher : public DtObjectPublisher
{
public:
   typedef DtModeSStateRepository* (*DtStateRepCreator)();

public:
   DtModeSPublisher(
      DtModeSStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtModeSPublisher(
      DtModeSStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      DtIffAtcNavaidsSysType type = DtIffAtcNavaidsSysType::DtIffAtcNavaidsTransponder,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtModeSPublisher(
      RTI::ObjectClassHandle h,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtModeSPublisher(
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtModeSPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   const char * objectClassName();

   virtual ~DtModeSPublisher();

private:
   DtModeSPublisher(const DtModeSPublisher& orig);

   DtModeSPublisher& operator=(
      const DtModeSPublisher& orig);

   void setObjectClassName(const char* name);

public:

   virtual DtModeSStateRepository* modeSStateRep();

   virtual DtModeSStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
   const char* myObjectClassName;
};

inline DtModeSStateRepository* DtModeSPublisher::modeSStateRep()
{
   return (DtModeSStateRepository*)myStateRep;
}

inline DtModeSStateRepository* DtModeSPublisher::msr()
{
   return (DtModeSStateRepository*)myStateRep;
}

/*************** Mode S *****************/
/***************  TCAS  *****************/
class DT_DLL_VL DtTCASDataPublisher : public DtObjectPublisher
{
public:
   typedef DtTCASDataStateRepository* (*DtStateRepCreator)();

public:
   DtTCASDataPublisher(
      DtTCASDataStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtTCASDataPublisher(
      DtTCASDataStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      DtIffAtcNavaidsSysType type = DtIffAtcNavaidsSysType::DtIffAtcNavaidsTransponder,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtTCASDataPublisher(
      RTI::ObjectClassHandle h,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtTCASDataPublisher(
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtTCASDataPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   const char * objectClassName();

   virtual ~DtTCASDataPublisher();

private:
   DtTCASDataPublisher(const DtTCASDataPublisher& orig);

   DtTCASDataPublisher& operator=(
      const DtTCASDataPublisher& orig);

   void setObjectClassName(const char* name);

public:

   virtual DtTCASDataStateRepository* TCASDataStateRep();

   virtual DtTCASDataStateRepository* Tsr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
   const char* myObjectClassName;
};

inline DtTCASDataStateRepository* DtTCASDataPublisher::TCASDataStateRep()
{
   return (DtTCASDataStateRepository*)myStateRep;
}

inline DtTCASDataStateRepository* DtTCASDataPublisher::Tsr()
{
   return (DtTCASDataStateRepository*)myStateRep;
}
/***************  TCAS  *****************/
/***************  Soviet  *****************/
class DT_DLL_VL DtSovietPublisher : public DtObjectPublisher
{
public:
   typedef DtSovietStateRepository* (*DtStateRepCreator)();

public:
   DtSovietPublisher(
      DtSovietStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtSovietPublisher(
      DtSovietStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      DtIffAtcNavaidsSysType type = DtIffAtcNavaidsSysType::DtIffAtcNavaidsTransponder,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtSovietPublisher(
      RTI::ObjectClassHandle h,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtSovietPublisher(
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtSovietPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   const char * objectClassName();

   virtual ~DtSovietPublisher();

private:
   DtSovietPublisher(const DtSovietPublisher& orig);

   DtSovietPublisher& operator=(
      const DtSovietPublisher& orig);

public:

   virtual DtSovietStateRepository* sovietStateRep();

   virtual DtSovietStateRepository* ssr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

   void setObjectClassName(const char* name);

protected:
   static DtStateRepCreator theStateRepCreator;
   const char* myObjectClassName;
};

inline DtSovietStateRepository* DtSovietPublisher::sovietStateRep()
{
   return (DtSovietStateRepository*)myStateRep;
}

inline DtSovietStateRepository* DtSovietPublisher::ssr()
{
   return (DtSovietStateRepository*)myStateRep;
}
/***************  Soviet  *****************/
/*************** RRB *****************/

class DT_DLL_VL DtRRBPublisher : public DtObjectPublisher
{
public:
   typedef DtRRBStateRepository* (*DtStateRepCreator)();

public:
   DtRRBPublisher(
      DtRRBStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtRRBPublisher(
      DtRRBStateRepository* stateRepToUse,
      DtExerciseConn* conn,
      DtIffAtcNavaidsSysType type = DtIffAtcNavaidsSysType::DtIffAtcNavaidsTransponder,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtRRBPublisher(
      RTI::ObjectClassHandle h,
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtRRBPublisher(
      DtExerciseConn* conn,
      const char* name = 0,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtRRBPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   const char * objectClassName();

   virtual ~DtRRBPublisher();

private:
   DtRRBPublisher(const DtRRBPublisher& orig);

   DtRRBPublisher& operator=(
      const DtRRBPublisher& orig);

   void setObjectClassName(const char* name);

public:

   virtual DtRRBStateRepository* rrbStateRep();

   virtual DtRRBStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
   const char* myObjectClassName;
};

inline DtRRBStateRepository* DtRRBPublisher::rrbStateRep()
{
   return (DtRRBStateRepository*)myStateRep;
}

inline DtRRBStateRepository* DtRRBPublisher::msr()
{
   return (DtRRBStateRepository*)myStateRep;
}

/*************** RRB *****************/
#endif