iffDataPublishers.h

Go to the documentation of this file.

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


#pragma once

#if DtHLA

#include <vl/objectPublisherHLA.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 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);

   static 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;
}

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(
      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);

   static const char * objectClassName();

   virtual ~DtMode1Publisher();

private:
   DtMode1Publisher(const DtMode1Publisher& orig);

   DtMode1Publisher& operator=(
      const DtMode1Publisher& orig);

public:

   virtual DtMode1StateRepository* mode1StateRep();

   virtual DtMode1StateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtMode1InterrogatorPublisher : public DtObjectPublisher
{
public:
   typedef DtMode1InterrogatorStateRepository* (*DtStateRepCreator)();

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

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

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

   DtMode1InterrogatorPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtMode1InterrogatorPublisher();

private:
   DtMode1InterrogatorPublisher(const DtMode1InterrogatorPublisher& orig);

   DtMode1InterrogatorPublisher& operator=(
      const DtMode1InterrogatorPublisher& orig);

public:

   virtual DtMode1InterrogatorStateRepository* mode1InterrogatorStateRep();

   virtual DtMode1InterrogatorStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtMode1InterrogatorStateRepository* DtMode1InterrogatorPublisher::mode1InterrogatorStateRep()
{
   return (DtMode1InterrogatorStateRepository*)myStateRep;
}

inline DtMode1InterrogatorStateRepository* DtMode1InterrogatorPublisher::msr()
{
   return (DtMode1InterrogatorStateRepository*)myStateRep;
}

class DT_DLL_VL DtMode1TransponderPublisher : public DtObjectPublisher
{
public:
   typedef DtMode1TransponderStateRepository* (*DtStateRepCreator)();

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

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

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

   DtMode1TransponderPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtMode1TransponderPublisher();

private:
   DtMode1TransponderPublisher(const DtMode1TransponderPublisher& orig);

   DtMode1TransponderPublisher& operator=(
      const DtMode1TransponderPublisher& orig);

public:

   virtual DtMode1TransponderStateRepository* mode1TransponderStateRep();

   virtual DtMode1TransponderStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtMode1TransponderStateRepository* DtMode1TransponderPublisher::mode1TransponderStateRep()
{
   return (DtMode1TransponderStateRepository*)myStateRep;
}

inline DtMode1TransponderStateRepository* DtMode1TransponderPublisher::msr()
{
   return (DtMode1TransponderStateRepository*)myStateRep;
}

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(
      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);

   static const char * objectClassName();

   virtual ~DtMode2Publisher();

private:
   DtMode2Publisher(const DtMode2Publisher& orig);

   DtMode2Publisher& operator=(
      const DtMode2Publisher& orig);

public:

   virtual DtMode2StateRepository* mode2StateRep();

   virtual DtMode2StateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtMode2InterrogatorPublisher : public DtObjectPublisher
{
public:
   typedef DtMode2InterrogatorStateRepository* (*DtStateRepCreator)();

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

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

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

   DtMode2InterrogatorPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtMode2InterrogatorPublisher();

private:
   DtMode2InterrogatorPublisher(const DtMode2InterrogatorPublisher& orig);

   DtMode2InterrogatorPublisher& operator=(
      const DtMode2InterrogatorPublisher& orig);

public:

   virtual DtMode2InterrogatorStateRepository* mode2InterrogatorStateRep();

   virtual DtMode2InterrogatorStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtMode2InterrogatorStateRepository* DtMode2InterrogatorPublisher::mode2InterrogatorStateRep()
{
   return (DtMode2InterrogatorStateRepository*)myStateRep;
}

inline DtMode2InterrogatorStateRepository* DtMode2InterrogatorPublisher::msr()
{
   return (DtMode2InterrogatorStateRepository*)myStateRep;
}

class DT_DLL_VL DtMode2TransponderPublisher : public DtObjectPublisher
{
public:
   typedef DtMode2TransponderStateRepository* (*DtStateRepCreator)();

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

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

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

   DtMode2TransponderPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtMode2TransponderPublisher();

private:
   DtMode2TransponderPublisher(const DtMode2TransponderPublisher& orig);

   DtMode2TransponderPublisher& operator=(
      const DtMode2TransponderPublisher& orig);

public:

   virtual DtMode2TransponderStateRepository* mode2TransponderStateRep();

   virtual DtMode2TransponderStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtMode2TransponderStateRepository* DtMode2TransponderPublisher::mode2TransponderStateRep()
{
   return (DtMode2TransponderStateRepository*)myStateRep;
}

inline DtMode2TransponderStateRepository* DtMode2TransponderPublisher::msr()
{
   return (DtMode2TransponderStateRepository*)myStateRep;
}

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(
      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);

   static const char * objectClassName();

   virtual ~DtMode3APublisher();

private:
   DtMode3APublisher(const DtMode3APublisher& orig);

   DtMode3APublisher& operator=(
      const DtMode3APublisher& orig);

public:

   virtual DtMode3AStateRepository* mode3AStateRep();

   virtual DtMode3AStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtMode3AInterrogatorPublisher : public DtObjectPublisher
{
public:
   typedef DtMode3AInterrogatorStateRepository* (*DtStateRepCreator)();

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

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

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

   DtMode3AInterrogatorPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtMode3AInterrogatorPublisher();

private:
   DtMode3AInterrogatorPublisher(const DtMode3AInterrogatorPublisher& orig);

   DtMode3AInterrogatorPublisher& operator=(
      const DtMode3AInterrogatorPublisher& orig);

public:

   virtual DtMode3AInterrogatorStateRepository* mode3AInterrogatorStateRep();

   virtual DtMode3AInterrogatorStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtMode3AInterrogatorStateRepository* DtMode3AInterrogatorPublisher::mode3AInterrogatorStateRep()
{
   return (DtMode3AInterrogatorStateRepository*)myStateRep;
}

inline DtMode3AInterrogatorStateRepository* DtMode3AInterrogatorPublisher::msr()
{
   return (DtMode3AInterrogatorStateRepository*)myStateRep;
}

class DT_DLL_VL DtMode3ATransponderPublisher : public DtObjectPublisher
{
public:
   typedef DtMode3ATransponderStateRepository* (*DtStateRepCreator)();

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

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

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

   DtMode3ATransponderPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtMode3ATransponderPublisher();

private:
   DtMode3ATransponderPublisher(const DtMode3ATransponderPublisher& orig);

   DtMode3ATransponderPublisher& operator=(
      const DtMode3ATransponderPublisher& orig);

public:

   virtual DtMode3ATransponderStateRepository* mode3ATransponderStateRep();

   virtual DtMode3ATransponderStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtMode3ATransponderStateRepository* DtMode3ATransponderPublisher::mode3ATransponderStateRep()
{
   return (DtMode3ATransponderStateRepository*)myStateRep;
}

inline DtMode3ATransponderStateRepository* DtMode3ATransponderPublisher::msr()
{
   return (DtMode3ATransponderStateRepository*)myStateRep;
}

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(
      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);

   static const char * objectClassName();

   virtual ~DtMode4Publisher();

private:
   DtMode4Publisher(const DtMode4Publisher& orig);

   DtMode4Publisher& operator=(
      const DtMode4Publisher& orig);

public:

   virtual DtMode4StateRepository* mode4StateRep();

   virtual DtMode4StateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtMode4InterrogatorPublisher : public DtObjectPublisher
{
public:
   typedef DtMode4InterrogatorStateRepository* (*DtStateRepCreator)();

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

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

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

   DtMode4InterrogatorPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtMode4InterrogatorPublisher();

private:
   DtMode4InterrogatorPublisher(const DtMode4InterrogatorPublisher& orig);

   DtMode4InterrogatorPublisher& operator=(
      const DtMode4InterrogatorPublisher& orig);

public:

   virtual DtMode4InterrogatorStateRepository* mode4InterrogatorStateRep();

   virtual DtMode4InterrogatorStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtMode4InterrogatorStateRepository* DtMode4InterrogatorPublisher::mode4InterrogatorStateRep()
{
   return (DtMode4InterrogatorStateRepository*)myStateRep;
}

inline DtMode4InterrogatorStateRepository* DtMode4InterrogatorPublisher::msr()
{
   return (DtMode4InterrogatorStateRepository*)myStateRep;
}

class DT_DLL_VL DtMode4TransponderPublisher : public DtObjectPublisher
{
public:
   typedef DtMode4TransponderStateRepository* (*DtStateRepCreator)();

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

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

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

   DtMode4TransponderPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtMode4TransponderPublisher();

private:
   DtMode4TransponderPublisher(const DtMode4TransponderPublisher& orig);

   DtMode4TransponderPublisher& operator=(
      const DtMode4TransponderPublisher& orig);

public:

   virtual DtMode4TransponderStateRepository* mode4TransponderStateRep();

   virtual DtMode4TransponderStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtMode4TransponderStateRepository* DtMode4TransponderPublisher::mode4TransponderStateRep()
{
   return (DtMode4TransponderStateRepository*)myStateRep;
}

inline DtMode4TransponderStateRepository* DtMode4TransponderPublisher::msr()
{
   return (DtMode4TransponderStateRepository*)myStateRep;
}

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(
      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);

   static const char * objectClassName();

   virtual ~DtMode5Publisher();

private:
   DtMode5Publisher(const DtMode5Publisher& orig);

   DtMode5Publisher& operator=(
      const DtMode5Publisher& orig);

public:

   virtual DtMode5StateRepository* mode5StateRep();

   virtual DtMode5StateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtMode5InterrogatorPublisher : public DtObjectPublisher
{
public:
   typedef DtMode5InterrogatorStateRepository* (*DtStateRepCreator)();

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

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

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

   DtMode5InterrogatorPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtMode5InterrogatorPublisher();

private:
   DtMode5InterrogatorPublisher(const DtMode5InterrogatorPublisher& orig);

   DtMode5InterrogatorPublisher& operator=(
      const DtMode5InterrogatorPublisher& orig);

public:

   virtual DtMode5InterrogatorStateRepository* mode5InterrogatorStateRep();

   virtual DtMode5InterrogatorStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtMode5InterrogatorStateRepository* DtMode5InterrogatorPublisher::mode5InterrogatorStateRep()
{
   return (DtMode5InterrogatorStateRepository*)myStateRep;
}

inline DtMode5InterrogatorStateRepository* DtMode5InterrogatorPublisher::msr()
{
   return (DtMode5InterrogatorStateRepository*)myStateRep;
}

class DT_DLL_VL DtMode5TransponderPublisher : public DtObjectPublisher
{
public:
   typedef DtMode5TransponderStateRepository* (*DtStateRepCreator)();

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

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

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

   DtMode5TransponderPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtMode5TransponderPublisher();

private:
   DtMode5TransponderPublisher(const DtMode5TransponderPublisher& orig);

   DtMode5TransponderPublisher& operator=(
      const DtMode5TransponderPublisher& orig);

public:

   virtual DtMode5TransponderStateRepository* mode5TransponderStateRep();

   virtual DtMode5TransponderStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtMode5TransponderStateRepository* DtMode5TransponderPublisher::mode5TransponderStateRep()
{
   return (DtMode5TransponderStateRepository*)myStateRep;
}

inline DtMode5TransponderStateRepository* DtMode5TransponderPublisher::msr()
{
   return (DtMode5TransponderStateRepository*)myStateRep;
}

class DT_DLL_VL DtModeCPublisher : public DtObjectPublisher
{
public:
   typedef DtModeCStateRepository* (*DtStateRepCreator)();

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

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

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

   DtModeCPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtModeCPublisher();

private:
   DtModeCPublisher(const DtModeCPublisher& orig);

   DtModeCPublisher& operator=(
      const DtModeCPublisher& orig);

public:

   virtual DtModeCStateRepository* modeCStateRep();

   virtual DtModeCStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtModeCStateRepository* DtModeCPublisher::modeCStateRep()
{
   return (DtModeCStateRepository*)myStateRep;
}

inline DtModeCStateRepository* DtModeCPublisher::msr()
{
   return (DtModeCStateRepository*)myStateRep;
}

class DT_DLL_VL DtModeCInterrogatorPublisher : public DtObjectPublisher
{
public:
   typedef DtModeCInterrogatorStateRepository* (*DtStateRepCreator)();

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

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

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

   DtModeCInterrogatorPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtModeCInterrogatorPublisher();

private:
   DtModeCInterrogatorPublisher(const DtModeCInterrogatorPublisher& orig);

   DtModeCInterrogatorPublisher& operator=(
      const DtModeCInterrogatorPublisher& orig);

public:

   virtual DtModeCInterrogatorStateRepository* modeCInterrogatorStateRep();

   virtual DtModeCInterrogatorStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtModeCInterrogatorStateRepository* DtModeCInterrogatorPublisher::modeCInterrogatorStateRep()
{
   return (DtModeCInterrogatorStateRepository*)myStateRep;
}

inline DtModeCInterrogatorStateRepository* DtModeCInterrogatorPublisher::msr()
{
   return (DtModeCInterrogatorStateRepository*)myStateRep;
}

class DT_DLL_VL DtModeCTransponderPublisher : public DtObjectPublisher
{
public:
   typedef DtModeCTransponderStateRepository* (*DtStateRepCreator)();

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

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

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

   DtModeCTransponderPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtModeCTransponderPublisher();

private:
   DtModeCTransponderPublisher(const DtModeCTransponderPublisher& orig);

   DtModeCTransponderPublisher& operator=(
      const DtModeCTransponderPublisher& orig);

public:

   virtual DtModeCTransponderStateRepository* modeCTransponderStateRep();

   virtual DtModeCTransponderStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtModeCTransponderStateRepository* DtModeCTransponderPublisher::modeCTransponderStateRep()
{
   return (DtModeCTransponderStateRepository*)myStateRep;
}

inline DtModeCTransponderStateRepository* DtModeCTransponderPublisher::msr()
{
   return (DtModeCTransponderStateRepository*)myStateRep;
}

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(
      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);

   static const char * objectClassName();

   virtual ~DtModeSPublisher();

private:
   DtModeSPublisher(const DtModeSPublisher& orig);

   DtModeSPublisher& operator=(
      const DtModeSPublisher& orig);

public:

   virtual DtModeSStateRepository* modeSStateRep();

   virtual DtModeSStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtModeSInterrogatorPublisher : public DtObjectPublisher
{
public:
   typedef DtModeSInterrogatorStateRepository* (*DtStateRepCreator)();

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

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

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

   DtModeSInterrogatorPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtModeSInterrogatorPublisher();

private:
   DtModeSInterrogatorPublisher(const DtModeSInterrogatorPublisher& orig);

   DtModeSInterrogatorPublisher& operator=(
      const DtModeSInterrogatorPublisher& orig);

public:

   virtual DtModeSInterrogatorStateRepository* modeSInterrogatorStateRep();

   virtual DtModeSInterrogatorStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtModeSInterrogatorStateRepository* DtModeSInterrogatorPublisher::modeSInterrogatorStateRep()
{
   return (DtModeSInterrogatorStateRepository*)myStateRep;
}

inline DtModeSInterrogatorStateRepository* DtModeSInterrogatorPublisher::msr()
{
   return (DtModeSInterrogatorStateRepository*)myStateRep;
}

class DT_DLL_VL DtModeSTransponderPublisher : public DtObjectPublisher
{
public:
   typedef DtModeSTransponderStateRepository* (*DtStateRepCreator)();

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

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

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

   DtModeSTransponderPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtModeSTransponderPublisher();

private:
   DtModeSTransponderPublisher(const DtModeSTransponderPublisher& orig);

   DtModeSTransponderPublisher& operator=(
      const DtModeSTransponderPublisher& orig);

public:

   virtual DtModeSTransponderStateRepository* modeSTransponderStateRep();

   virtual DtModeSTransponderStateRepository* msr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtModeSTransponderStateRepository* DtModeSTransponderPublisher::modeSTransponderStateRep()
{
   return (DtModeSTransponderStateRepository*)myStateRep;
}

inline DtModeSTransponderStateRepository* DtModeSTransponderPublisher::msr()
{
   return (DtModeSTransponderStateRepository*)myStateRep;
}

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(
      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);

   static 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);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtSovietInterrogatorPublisher : public DtObjectPublisher
{
public:
   typedef DtSovietInterrogatorStateRepository* (*DtStateRepCreator)();

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

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

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

   DtSovietInterrogatorPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtSovietInterrogatorPublisher();

private:
   DtSovietInterrogatorPublisher(const DtSovietInterrogatorPublisher& orig);

   DtSovietInterrogatorPublisher& operator=(
      const DtSovietInterrogatorPublisher& orig);

public:

   virtual DtSovietInterrogatorStateRepository* sovietInterrogatorStateRep();

   virtual DtSovietInterrogatorStateRepository* ssr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtSovietInterrogatorStateRepository* DtSovietInterrogatorPublisher::sovietInterrogatorStateRep()
{
   return (DtSovietInterrogatorStateRepository*)myStateRep;
}

inline DtSovietInterrogatorStateRepository* DtSovietInterrogatorPublisher::ssr()
{
   return (DtSovietInterrogatorStateRepository*)myStateRep;
}

class DT_DLL_VL DtSovietTransponderPublisher : public DtObjectPublisher
{
public:
   typedef DtSovietTransponderStateRepository* (*DtStateRepCreator)();

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

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

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

   DtSovietTransponderPublisher(DtHlaObjectWithStateRep* obj, DtExerciseConn* conn);

   static const char * objectClassName();

   virtual ~DtSovietTransponderPublisher();

private:
   DtSovietTransponderPublisher(const DtSovietTransponderPublisher& orig);

   DtSovietTransponderPublisher& operator=(
      const DtSovietTransponderPublisher& orig);

public:

   virtual DtSovietTransponderStateRepository* sovietTransponderStateRep();

   virtual DtSovietTransponderStateRepository* ssr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

inline DtSovietTransponderStateRepository* DtSovietTransponderPublisher::sovietTransponderStateRep()
{
   return (DtSovietTransponderStateRepository*)myStateRep;
}

inline DtSovietTransponderStateRepository* DtSovietTransponderPublisher::ssr()
{
   return (DtSovietTransponderStateRepository*)myStateRep;
}

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(
      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);

   static const char * objectClassName();

   virtual ~DtTCASDataPublisher();

private:
   DtTCASDataPublisher(const DtTCASDataPublisher& orig);

   DtTCASDataPublisher& operator=(
      const DtTCASDataPublisher& orig);

public:

   virtual DtTCASDataStateRepository* TCASDataStateRep();

   virtual DtTCASDataStateRepository* Tsr();

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

#endif