iffDataReflected.h

Go to the documentation of this file.

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

#pragma once

#if DtHLA

#include <vl/reflectedObjectHLA.h>
#include <vl/reflectedObjectListHLA.h>
#include <vl/IFFDataStateRepository.h>


class DT_DLL_VL DtReflectedIFFData;
class DT_DLL_VL DtReflectedMode1;
class DT_DLL_VL DtReflectedMode1Interrogator;
class DT_DLL_VL DtReflectedMode1Transponder;
class DT_DLL_VL DtReflectedMode2;
class DT_DLL_VL DtReflectedMode2Interrogator;
class DT_DLL_VL DtReflectedMode2Transponder;
class DT_DLL_VL DtReflectedMode3A;
class DT_DLL_VL DtReflectedMode3AInterrogator;
class DT_DLL_VL DtReflectedMode3ATransponder;
class DT_DLL_VL DtReflectedMode4;
class DT_DLL_VL DtReflectedMode4Interrogator;
class DT_DLL_VL DtReflectedMode4Transponder;
class DT_DLL_VL DtReflectedMode5;
class DT_DLL_VL DtReflectedMode5Interrogator;
class DT_DLL_VL DtReflectedMode5Transponder;
class DT_DLL_VL DtReflectedModeC;
class DT_DLL_VL DtReflectedModeCInterrogator;
class DT_DLL_VL DtReflectedModeCTransponder;
class DT_DLL_VL DtReflectedModeS;
class DT_DLL_VL DtReflectedModeSInterrogator;
class DT_DLL_VL DtReflectedModeSTransponder;
class DT_DLL_VL DtReflectedSoviet;
class DT_DLL_VL DtReflectedSovietInterrogator;
class DT_DLL_VL DtReflectedSovietTransponder;
class DT_DLL_VL DtReflectedTCASData;

typedef void(*DtIFFDataCallbackFunction)(
   DtReflectedIFFData* obj, void* userData);

class DT_DLL_VL DtReflectedIFFData : public DtReflectedObject
{
public:
   typedef DtIFFDataStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedIFFData(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedIFFData();

   virtual DtIFFDataStateRepository* IFFDataStateRep() const;

   virtual DtIFFDataStateRepository* Isr() const;

   virtual DtReflectedIFFData* next() const;

   virtual DtReflectedIFFData* prev() const;

   virtual DtReflectedIFFData* wrapNext() const;

   virtual DtReflectedIFFData* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtIFFDataCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtIFFDataCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedIFFData(const DtReflectedIFFData& orig);

   DtReflectedIFFData& operator=(const DtReflectedIFFData& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedIFFDataList : public DtReflectedObjectList
{
public:
   DtReflectedIFFDataList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedIFFDataList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedIFFDataList();

private:

   DtReflectedIFFDataList(const DtReflectedIFFDataList& orig);

   DtReflectedIFFDataList& operator=(const DtReflectedIFFDataList&orig);

public:

   virtual DtReflectedIFFData* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedIFFData* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedIFFData* first() const;

   virtual DtReflectedIFFData* last() const;

   virtual void addIFFDataAdditionCallback(
      DtIFFDataCallbackFunction cb, void* userData);

   virtual void removeIFFDataAdditionCallback(
      DtIFFDataCallbackFunction cb, void* userData);

   virtual void addIFFDataRemovalCallback(
      DtIFFDataCallbackFunction cb, void* userData);

   virtual void removeIFFDataRemovalCallback(
      DtIFFDataCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode1CallbackFunction)(
   DtReflectedMode1* obj, void* userData);

class DT_DLL_VL DtReflectedMode1 : public DtReflectedObject
{
public:
   typedef DtMode1StateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode1(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode1();

   virtual DtMode1StateRepository* mode1StateRep() const;

   virtual DtMode1StateRepository* msr() const;

   virtual DtReflectedMode1* next() const;

   virtual DtReflectedMode1* prev() const;

   virtual DtReflectedMode1* wrapNext() const;

   virtual DtReflectedMode1* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode1CallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode1CallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode1(const DtReflectedMode1& orig);

   DtReflectedMode1& operator=(const DtReflectedMode1& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode1List : public DtReflectedObjectList
{
public:
   DtReflectedMode1List(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode1List(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode1List();

private:

   DtReflectedMode1List(const DtReflectedMode1List& orig);

   DtReflectedMode1List& operator=(const DtReflectedMode1List&orig);

public:

   virtual DtReflectedMode1* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode1* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode1* first() const;

   virtual DtReflectedMode1* last() const;

   virtual void addMode1AdditionCallback(
      DtMode1CallbackFunction cb, void* userData);

   virtual void removeMode1AdditionCallback(
      DtMode1CallbackFunction cb, void* userData);

   virtual void addMode1RemovalCallback(
      DtMode1CallbackFunction cb, void* userData);

   virtual void removeMode1RemovalCallback(
      DtMode1CallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode1InterrogatorCallbackFunction)(
   DtReflectedMode1Interrogator* obj, void* userData);

class DT_DLL_VL DtReflectedMode1Interrogator : public DtReflectedObject
{
public:
   typedef DtMode1InterrogatorStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode1Interrogator(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode1Interrogator();

   virtual DtMode1InterrogatorStateRepository* mode1InterrogatorStateRep() const;

   virtual DtMode1InterrogatorStateRepository* msr() const;

   virtual DtReflectedMode1Interrogator* next() const;

   virtual DtReflectedMode1Interrogator* prev() const;

   virtual DtReflectedMode1Interrogator* wrapNext() const;

   virtual DtReflectedMode1Interrogator* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode1InterrogatorCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode1InterrogatorCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode1Interrogator(const DtReflectedMode1Interrogator& orig);

   DtReflectedMode1Interrogator& operator=(const DtReflectedMode1Interrogator& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode1InterrogatorList : public DtReflectedObjectList
{
public:
   DtReflectedMode1InterrogatorList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode1InterrogatorList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode1InterrogatorList();

private:

   DtReflectedMode1InterrogatorList(const DtReflectedMode1InterrogatorList& orig);

   DtReflectedMode1InterrogatorList& operator=(const DtReflectedMode1InterrogatorList&orig);

public:

   virtual DtReflectedMode1Interrogator* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode1Interrogator* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode1Interrogator* first() const;

   virtual DtReflectedMode1Interrogator* last() const;

   virtual void addMode1InterrogatorAdditionCallback(
      DtMode1InterrogatorCallbackFunction cb, void* userData);

   virtual void removeMode1InterrogatorAdditionCallback(
      DtMode1InterrogatorCallbackFunction cb, void* userData);

   virtual void addMode1InterrogatorRemovalCallback(
      DtMode1InterrogatorCallbackFunction cb, void* userData);

   virtual void removeMode1InterrogatorRemovalCallback(
      DtMode1InterrogatorCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode1TransponderCallbackFunction)(
   DtReflectedMode1Transponder* obj, void* userData);

class DT_DLL_VL DtReflectedMode1Transponder : public DtReflectedObject
{
public:
   typedef DtMode1TransponderStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode1Transponder(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode1Transponder();

   virtual DtMode1TransponderStateRepository* mode1TransponderStateRep() const;

   virtual DtMode1TransponderStateRepository* msr() const;

   virtual DtReflectedMode1Transponder* next() const;

   virtual DtReflectedMode1Transponder* prev() const;

   virtual DtReflectedMode1Transponder* wrapNext() const;

   virtual DtReflectedMode1Transponder* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode1TransponderCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode1TransponderCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode1Transponder(const DtReflectedMode1Transponder& orig);

   DtReflectedMode1Transponder& operator=(const DtReflectedMode1Transponder& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode1TransponderList : public DtReflectedObjectList
{
public:
   DtReflectedMode1TransponderList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode1TransponderList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode1TransponderList();

private:

   DtReflectedMode1TransponderList(const DtReflectedMode1TransponderList& orig);

   DtReflectedMode1TransponderList& operator=(const DtReflectedMode1TransponderList&orig);

public:

   virtual DtReflectedMode1Transponder* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode1Transponder* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode1Transponder* first() const;

   virtual DtReflectedMode1Transponder* last() const;

   virtual void addMode1TransponderAdditionCallback(
      DtMode1TransponderCallbackFunction cb, void* userData);

   virtual void removeMode1TransponderAdditionCallback(
      DtMode1TransponderCallbackFunction cb, void* userData);

   virtual void addMode1TransponderRemovalCallback(
      DtMode1TransponderCallbackFunction cb, void* userData);

   virtual void removeMode1TransponderRemovalCallback(
      DtMode1TransponderCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode2CallbackFunction)(
   DtReflectedMode2* obj, void* userData);

class DT_DLL_VL DtReflectedMode2 : public DtReflectedObject
{
public:
   typedef DtMode2StateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode2(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode2();

   virtual DtMode2StateRepository* mode2StateRep() const;

   virtual DtMode2StateRepository* msr() const;

   virtual DtReflectedMode2* next() const;

   virtual DtReflectedMode2* prev() const;

   virtual DtReflectedMode2* wrapNext() const;

   virtual DtReflectedMode2* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode2CallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode2CallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode2(const DtReflectedMode2& orig);

   DtReflectedMode2& operator=(const DtReflectedMode2& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode2List : public DtReflectedObjectList
{
public:
   DtReflectedMode2List(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode2List(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode2List();

private:

   DtReflectedMode2List(const DtReflectedMode2List& orig);

   DtReflectedMode2List& operator=(const DtReflectedMode2List&orig);

public:

   virtual DtReflectedMode2* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode2* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode2* first() const;

   virtual DtReflectedMode2* last() const;

   virtual void addMode2AdditionCallback(
      DtMode2CallbackFunction cb, void* userData);

   virtual void removeMode2AdditionCallback(
      DtMode2CallbackFunction cb, void* userData);

   virtual void addMode2RemovalCallback(
      DtMode2CallbackFunction cb, void* userData);

   virtual void removeMode2RemovalCallback(
      DtMode2CallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode2InterrogatorCallbackFunction)(
   DtReflectedMode2Interrogator* obj, void* userData);

class DT_DLL_VL DtReflectedMode2Interrogator : public DtReflectedObject
{
public:
   typedef DtMode2InterrogatorStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode2Interrogator(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode2Interrogator();

   virtual DtMode2InterrogatorStateRepository* mode2InterrogatorStateRep() const;

   virtual DtMode2InterrogatorStateRepository* msr() const;

   virtual DtReflectedMode2Interrogator* next() const;

   virtual DtReflectedMode2Interrogator* prev() const;

   virtual DtReflectedMode2Interrogator* wrapNext() const;

   virtual DtReflectedMode2Interrogator* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode2InterrogatorCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode2InterrogatorCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode2Interrogator(const DtReflectedMode2Interrogator& orig);

   DtReflectedMode2Interrogator& operator=(const DtReflectedMode2Interrogator& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode2InterrogatorList : public DtReflectedObjectList
{
public:
   DtReflectedMode2InterrogatorList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode2InterrogatorList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode2InterrogatorList();

private:

   DtReflectedMode2InterrogatorList(const DtReflectedMode2InterrogatorList& orig);

   DtReflectedMode2InterrogatorList& operator=(const DtReflectedMode2InterrogatorList&orig);

public:

   virtual DtReflectedMode2Interrogator* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode2Interrogator* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode2Interrogator* first() const;

   virtual DtReflectedMode2Interrogator* last() const;

   virtual void addMode2InterrogatorAdditionCallback(
      DtMode2InterrogatorCallbackFunction cb, void* userData);

   virtual void removeMode2InterrogatorAdditionCallback(
      DtMode2InterrogatorCallbackFunction cb, void* userData);

   virtual void addMode2InterrogatorRemovalCallback(
      DtMode2InterrogatorCallbackFunction cb, void* userData);

   virtual void removeMode2InterrogatorRemovalCallback(
      DtMode2InterrogatorCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode2TransponderCallbackFunction)(
   DtReflectedMode2Transponder* obj, void* userData);

class DT_DLL_VL DtReflectedMode2Transponder : public DtReflectedObject
{
public:
   typedef DtMode2TransponderStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode2Transponder(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode2Transponder();

   virtual DtMode2TransponderStateRepository* mode2TransponderStateRep() const;

   virtual DtMode2TransponderStateRepository* msr() const;

   virtual DtReflectedMode2Transponder* next() const;

   virtual DtReflectedMode2Transponder* prev() const;

   virtual DtReflectedMode2Transponder* wrapNext() const;

   virtual DtReflectedMode2Transponder* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode2TransponderCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode2TransponderCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode2Transponder(const DtReflectedMode2Transponder& orig);

   DtReflectedMode2Transponder& operator=(const DtReflectedMode2Transponder& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode2TransponderList : public DtReflectedObjectList
{
public:
   DtReflectedMode2TransponderList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode2TransponderList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode2TransponderList();

private:

   DtReflectedMode2TransponderList(const DtReflectedMode2TransponderList& orig);

   DtReflectedMode2TransponderList& operator=(const DtReflectedMode2TransponderList&orig);

public:

   virtual DtReflectedMode2Transponder* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode2Transponder* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode2Transponder* first() const;

   virtual DtReflectedMode2Transponder* last() const;

   virtual void addMode2TransponderAdditionCallback(
      DtMode2TransponderCallbackFunction cb, void* userData);

   virtual void removeMode2TransponderAdditionCallback(
      DtMode2TransponderCallbackFunction cb, void* userData);

   virtual void addMode2TransponderRemovalCallback(
      DtMode2TransponderCallbackFunction cb, void* userData);

   virtual void removeMode2TransponderRemovalCallback(
      DtMode2TransponderCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode3ACallbackFunction)(
   DtReflectedMode3A* obj, void* userData);

class DT_DLL_VL DtReflectedMode3A : public DtReflectedObject
{
public:
   typedef DtMode3AStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode3A(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode3A();

   virtual DtMode3AStateRepository* mode3AStateRep() const;

   virtual DtMode3AStateRepository* msr() const;

   virtual DtReflectedMode3A* next() const;

   virtual DtReflectedMode3A* prev() const;

   virtual DtReflectedMode3A* wrapNext() const;

   virtual DtReflectedMode3A* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode3ACallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode3ACallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode3A(const DtReflectedMode3A& orig);

   DtReflectedMode3A& operator=(const DtReflectedMode3A& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode3AList : public DtReflectedObjectList
{
public:
   DtReflectedMode3AList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode3AList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode3AList();

private:

   DtReflectedMode3AList(const DtReflectedMode3AList& orig);

   DtReflectedMode3AList& operator=(const DtReflectedMode3AList&orig);

public:

   virtual DtReflectedMode3A* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode3A* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode3A* first() const;

   virtual DtReflectedMode3A* last() const;

   virtual void addMode3AAdditionCallback(
      DtMode3ACallbackFunction cb, void* userData);

   virtual void removeMode3AAdditionCallback(
      DtMode3ACallbackFunction cb, void* userData);

   virtual void addMode3ARemovalCallback(
      DtMode3ACallbackFunction cb, void* userData);

   virtual void removeMode3ARemovalCallback(
      DtMode3ACallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode3AInterrogatorCallbackFunction)(
   DtReflectedMode3AInterrogator* obj, void* userData);

class DT_DLL_VL DtReflectedMode3AInterrogator : public DtReflectedObject
{
public:
   typedef DtMode3AInterrogatorStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode3AInterrogator(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode3AInterrogator();

   virtual DtMode3AInterrogatorStateRepository* mode3AInterrogatorStateRep() const;

   virtual DtMode3AInterrogatorStateRepository* msr() const;

   virtual DtReflectedMode3AInterrogator* next() const;

   virtual DtReflectedMode3AInterrogator* prev() const;

   virtual DtReflectedMode3AInterrogator* wrapNext() const;

   virtual DtReflectedMode3AInterrogator* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode3AInterrogatorCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode3AInterrogatorCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode3AInterrogator(const DtReflectedMode3AInterrogator& orig);

   DtReflectedMode3AInterrogator& operator=(const DtReflectedMode3AInterrogator& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode3AInterrogatorList : public DtReflectedObjectList
{
public:
   DtReflectedMode3AInterrogatorList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode3AInterrogatorList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode3AInterrogatorList();

private:

   DtReflectedMode3AInterrogatorList(const DtReflectedMode3AInterrogatorList& orig);

   DtReflectedMode3AInterrogatorList& operator=(const DtReflectedMode3AInterrogatorList&orig);

public:

   virtual DtReflectedMode3AInterrogator* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode3AInterrogator* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode3AInterrogator* first() const;

   virtual DtReflectedMode3AInterrogator* last() const;

   virtual void addMode3AInterrogatorAdditionCallback(
      DtMode3AInterrogatorCallbackFunction cb, void* userData);

   virtual void removeMode3AInterrogatorAdditionCallback(
      DtMode3AInterrogatorCallbackFunction cb, void* userData);

   virtual void addMode3AInterrogatorRemovalCallback(
      DtMode3AInterrogatorCallbackFunction cb, void* userData);

   virtual void removeMode3AInterrogatorRemovalCallback(
      DtMode3AInterrogatorCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode3ATransponderCallbackFunction)(
   DtReflectedMode3ATransponder* obj, void* userData);

class DT_DLL_VL DtReflectedMode3ATransponder : public DtReflectedObject
{
public:
   typedef DtMode3ATransponderStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode3ATransponder(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode3ATransponder();

   virtual DtMode3ATransponderStateRepository* mode3ATransponderStateRep() const;

   virtual DtMode3ATransponderStateRepository* msr() const;

   virtual DtReflectedMode3ATransponder* next() const;

   virtual DtReflectedMode3ATransponder* prev() const;

   virtual DtReflectedMode3ATransponder* wrapNext() const;

   virtual DtReflectedMode3ATransponder* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode3ATransponderCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode3ATransponderCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode3ATransponder(const DtReflectedMode3ATransponder& orig);

   DtReflectedMode3ATransponder& operator=(const DtReflectedMode3ATransponder& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode3ATransponderList : public DtReflectedObjectList
{
public:
   DtReflectedMode3ATransponderList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode3ATransponderList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode3ATransponderList();

private:

   DtReflectedMode3ATransponderList(const DtReflectedMode3ATransponderList& orig);

   DtReflectedMode3ATransponderList& operator=(const DtReflectedMode3ATransponderList&orig);

public:

   virtual DtReflectedMode3ATransponder* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode3ATransponder* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode3ATransponder* first() const;

   virtual DtReflectedMode3ATransponder* last() const;

   virtual void addMode3ATransponderAdditionCallback(
      DtMode3ATransponderCallbackFunction cb, void* userData);

   virtual void removeMode3ATransponderAdditionCallback(
      DtMode3ATransponderCallbackFunction cb, void* userData);

   virtual void addMode3ATransponderRemovalCallback(
      DtMode3ATransponderCallbackFunction cb, void* userData);

   virtual void removeMode3ATransponderRemovalCallback(
      DtMode3ATransponderCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode4CallbackFunction)(
   DtReflectedMode4* obj, void* userData);

class DT_DLL_VL DtReflectedMode4 : public DtReflectedObject
{
public:
   typedef DtMode4StateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode4(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode4();

   virtual DtMode4StateRepository* mode4StateRep() const;

   virtual DtMode4StateRepository* msr() const;

   virtual DtReflectedMode4* next() const;

   virtual DtReflectedMode4* prev() const;

   virtual DtReflectedMode4* wrapNext() const;

   virtual DtReflectedMode4* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode4CallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode4CallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode4(const DtReflectedMode4& orig);

   DtReflectedMode4& operator=(const DtReflectedMode4& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode4List : public DtReflectedObjectList
{
public:
   DtReflectedMode4List(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode4List(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode4List();

private:

   DtReflectedMode4List(const DtReflectedMode4List& orig);

   DtReflectedMode4List& operator=(const DtReflectedMode4List&orig);

public:

   virtual DtReflectedMode4* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode4* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode4* first() const;

   virtual DtReflectedMode4* last() const;

   virtual void addMode4AdditionCallback(
      DtMode4CallbackFunction cb, void* userData);

   virtual void removeMode4AdditionCallback(
      DtMode4CallbackFunction cb, void* userData);

   virtual void addMode4RemovalCallback(
      DtMode4CallbackFunction cb, void* userData);

   virtual void removeMode4RemovalCallback(
      DtMode4CallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode4InterrogatorCallbackFunction)(
   DtReflectedMode4Interrogator* obj, void* userData);

class DT_DLL_VL DtReflectedMode4Interrogator : public DtReflectedObject
{
public:
   typedef DtMode4InterrogatorStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode4Interrogator(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode4Interrogator();

   virtual DtMode4InterrogatorStateRepository* mode4InterrogatorStateRep() const;

   virtual DtMode4InterrogatorStateRepository* msr() const;

   virtual DtReflectedMode4Interrogator* next() const;

   virtual DtReflectedMode4Interrogator* prev() const;

   virtual DtReflectedMode4Interrogator* wrapNext() const;

   virtual DtReflectedMode4Interrogator* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode4InterrogatorCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode4InterrogatorCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode4Interrogator(const DtReflectedMode4Interrogator& orig);

   DtReflectedMode4Interrogator& operator=(const DtReflectedMode4Interrogator& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode4InterrogatorList : public DtReflectedObjectList
{
public:
   DtReflectedMode4InterrogatorList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode4InterrogatorList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode4InterrogatorList();

private:

   DtReflectedMode4InterrogatorList(const DtReflectedMode4InterrogatorList& orig);

   DtReflectedMode4InterrogatorList& operator=(const DtReflectedMode4InterrogatorList&orig);

public:

   virtual DtReflectedMode4Interrogator* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode4Interrogator* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode4Interrogator* first() const;

   virtual DtReflectedMode4Interrogator* last() const;

   virtual void addMode4InterrogatorAdditionCallback(
      DtMode4InterrogatorCallbackFunction cb, void* userData);

   virtual void removeMode4InterrogatorAdditionCallback(
      DtMode4InterrogatorCallbackFunction cb, void* userData);

   virtual void addMode4InterrogatorRemovalCallback(
      DtMode4InterrogatorCallbackFunction cb, void* userData);

   virtual void removeMode4InterrogatorRemovalCallback(
      DtMode4InterrogatorCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode4TransponderCallbackFunction)(
   DtReflectedMode4Transponder* obj, void* userData);

class DT_DLL_VL DtReflectedMode4Transponder : public DtReflectedObject
{
public:
   typedef DtMode4TransponderStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode4Transponder(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode4Transponder();

   virtual DtMode4TransponderStateRepository* mode4TransponderStateRep() const;

   virtual DtMode4TransponderStateRepository* msr() const;

   virtual DtReflectedMode4Transponder* next() const;

   virtual DtReflectedMode4Transponder* prev() const;

   virtual DtReflectedMode4Transponder* wrapNext() const;

   virtual DtReflectedMode4Transponder* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode4TransponderCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode4TransponderCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode4Transponder(const DtReflectedMode4Transponder& orig);

   DtReflectedMode4Transponder& operator=(const DtReflectedMode4Transponder& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode4TransponderList : public DtReflectedObjectList
{
public:
   DtReflectedMode4TransponderList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode4TransponderList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode4TransponderList();

private:

   DtReflectedMode4TransponderList(const DtReflectedMode4TransponderList& orig);

   DtReflectedMode4TransponderList& operator=(const DtReflectedMode4TransponderList&orig);

public:

   virtual DtReflectedMode4Transponder* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode4Transponder* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode4Transponder* first() const;

   virtual DtReflectedMode4Transponder* last() const;

   virtual void addMode4TransponderAdditionCallback(
      DtMode4TransponderCallbackFunction cb, void* userData);

   virtual void removeMode4TransponderAdditionCallback(
      DtMode4TransponderCallbackFunction cb, void* userData);

   virtual void addMode4TransponderRemovalCallback(
      DtMode4TransponderCallbackFunction cb, void* userData);

   virtual void removeMode4TransponderRemovalCallback(
      DtMode4TransponderCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode5CallbackFunction)(
   DtReflectedMode5* obj, void* userData);

class DT_DLL_VL DtReflectedMode5 : public DtReflectedObject
{
public:
   typedef DtMode5StateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode5(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode5();

   virtual DtMode5StateRepository* mode5StateRep() const;

   virtual DtMode5StateRepository* msr() const;

   virtual DtReflectedMode5* next() const;

   virtual DtReflectedMode5* prev() const;

   virtual DtReflectedMode5* wrapNext() const;

   virtual DtReflectedMode5* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode5CallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode5CallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode5(const DtReflectedMode5& orig);

   DtReflectedMode5& operator=(const DtReflectedMode5& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode5List : public DtReflectedObjectList
{
public:
   DtReflectedMode5List(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode5List(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode5List();

private:

   DtReflectedMode5List(const DtReflectedMode5List& orig);

   DtReflectedMode5List& operator=(const DtReflectedMode5List&orig);

public:

   virtual DtReflectedMode5* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode5* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode5* first() const;

   virtual DtReflectedMode5* last() const;

   virtual void addMode5AdditionCallback(
      DtMode5CallbackFunction cb, void* userData);

   virtual void removeMode5AdditionCallback(
      DtMode5CallbackFunction cb, void* userData);

   virtual void addMode5RemovalCallback(
      DtMode5CallbackFunction cb, void* userData);

   virtual void removeMode5RemovalCallback(
      DtMode5CallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode5InterrogatorCallbackFunction)(
   DtReflectedMode5Interrogator* obj, void* userData);

class DT_DLL_VL DtReflectedMode5Interrogator : public DtReflectedObject
{
public:
   typedef DtMode5InterrogatorStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode5Interrogator(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode5Interrogator();

   virtual DtMode5InterrogatorStateRepository* mode5InterrogatorStateRep() const;

   virtual DtMode5InterrogatorStateRepository* msr() const;

   virtual DtReflectedMode5Interrogator* next() const;

   virtual DtReflectedMode5Interrogator* prev() const;

   virtual DtReflectedMode5Interrogator* wrapNext() const;

   virtual DtReflectedMode5Interrogator* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode5InterrogatorCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode5InterrogatorCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode5Interrogator(const DtReflectedMode5Interrogator& orig);

   DtReflectedMode5Interrogator& operator=(const DtReflectedMode5Interrogator& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode5InterrogatorList : public DtReflectedObjectList
{
public:
   DtReflectedMode5InterrogatorList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode5InterrogatorList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode5InterrogatorList();

private:

   DtReflectedMode5InterrogatorList(const DtReflectedMode5InterrogatorList& orig);

   DtReflectedMode5InterrogatorList& operator=(const DtReflectedMode5InterrogatorList&orig);

public:

   virtual DtReflectedMode5Interrogator* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode5Interrogator* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode5Interrogator* first() const;

   virtual DtReflectedMode5Interrogator* last() const;

   virtual void addMode5InterrogatorAdditionCallback(
      DtMode5InterrogatorCallbackFunction cb, void* userData);

   virtual void removeMode5InterrogatorAdditionCallback(
      DtMode5InterrogatorCallbackFunction cb, void* userData);

   virtual void addMode5InterrogatorRemovalCallback(
      DtMode5InterrogatorCallbackFunction cb, void* userData);

   virtual void removeMode5InterrogatorRemovalCallback(
      DtMode5InterrogatorCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtMode5TransponderCallbackFunction)(
   DtReflectedMode5Transponder* obj, void* userData);

class DT_DLL_VL DtReflectedMode5Transponder : public DtReflectedObject
{
public:
   typedef DtMode5TransponderStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedMode5Transponder(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedMode5Transponder();

   virtual DtMode5TransponderStateRepository* mode5TransponderStateRep() const;

   virtual DtMode5TransponderStateRepository* msr() const;

   virtual DtReflectedMode5Transponder* next() const;

   virtual DtReflectedMode5Transponder* prev() const;

   virtual DtReflectedMode5Transponder* wrapNext() const;

   virtual DtReflectedMode5Transponder* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtMode5TransponderCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtMode5TransponderCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedMode5Transponder(const DtReflectedMode5Transponder& orig);

   DtReflectedMode5Transponder& operator=(const DtReflectedMode5Transponder& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedMode5TransponderList : public DtReflectedObjectList
{
public:
   DtReflectedMode5TransponderList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedMode5TransponderList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedMode5TransponderList();

private:

   DtReflectedMode5TransponderList(const DtReflectedMode5TransponderList& orig);

   DtReflectedMode5TransponderList& operator=(const DtReflectedMode5TransponderList&orig);

public:

   virtual DtReflectedMode5Transponder* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedMode5Transponder* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedMode5Transponder* first() const;

   virtual DtReflectedMode5Transponder* last() const;

   virtual void addMode5TransponderAdditionCallback(
      DtMode5TransponderCallbackFunction cb, void* userData);

   virtual void removeMode5TransponderAdditionCallback(
      DtMode5TransponderCallbackFunction cb, void* userData);

   virtual void addMode5TransponderRemovalCallback(
      DtMode5TransponderCallbackFunction cb, void* userData);

   virtual void removeMode5TransponderRemovalCallback(
      DtMode5TransponderCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtModeCCallbackFunction)(
   DtReflectedModeC* obj, void* userData);

class DT_DLL_VL DtReflectedModeC : public DtReflectedObject
{
public:
   typedef DtModeCStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedModeC(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedModeC();

   virtual DtModeCStateRepository* modeCStateRep() const;

   virtual DtModeCStateRepository* msr() const;

   virtual DtReflectedModeC* next() const;

   virtual DtReflectedModeC* prev() const;

   virtual DtReflectedModeC* wrapNext() const;

   virtual DtReflectedModeC* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtModeCCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtModeCCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedModeC(const DtReflectedModeC& orig);

   DtReflectedModeC& operator=(const DtReflectedModeC& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedModeCList : public DtReflectedObjectList
{
public:
   DtReflectedModeCList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedModeCList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedModeCList();

private:

   DtReflectedModeCList(const DtReflectedModeCList& orig);

   DtReflectedModeCList& operator=(const DtReflectedModeCList&orig);

public:

   virtual DtReflectedModeC* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedModeC* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedModeC* first() const;

   virtual DtReflectedModeC* last() const;

   virtual void addModeCAdditionCallback(
      DtModeCCallbackFunction cb, void* userData);

   virtual void removeModeCAdditionCallback(
      DtModeCCallbackFunction cb, void* userData);

   virtual void addModeCRemovalCallback(
      DtModeCCallbackFunction cb, void* userData);

   virtual void removeModeCRemovalCallback(
      DtModeCCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtModeCInterrogatorCallbackFunction)(
   DtReflectedModeCInterrogator* obj, void* userData);

class DT_DLL_VL DtReflectedModeCInterrogator : public DtReflectedObject
{
public:
   typedef DtModeCInterrogatorStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedModeCInterrogator(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedModeCInterrogator();

   virtual DtModeCInterrogatorStateRepository* modeCInterrogatorStateRep() const;

   virtual DtModeCInterrogatorStateRepository* msr() const;

   virtual DtReflectedModeCInterrogator* next() const;

   virtual DtReflectedModeCInterrogator* prev() const;

   virtual DtReflectedModeCInterrogator* wrapNext() const;

   virtual DtReflectedModeCInterrogator* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtModeCInterrogatorCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtModeCInterrogatorCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedModeCInterrogator(const DtReflectedModeCInterrogator& orig);

   DtReflectedModeCInterrogator& operator=(const DtReflectedModeCInterrogator& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedModeCInterrogatorList : public DtReflectedObjectList
{
public:
   DtReflectedModeCInterrogatorList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedModeCInterrogatorList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedModeCInterrogatorList();

private:

   DtReflectedModeCInterrogatorList(const DtReflectedModeCInterrogatorList& orig);

   DtReflectedModeCInterrogatorList& operator=(const DtReflectedModeCInterrogatorList&orig);

public:

   virtual DtReflectedModeCInterrogator* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedModeCInterrogator* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedModeCInterrogator* first() const;

   virtual DtReflectedModeCInterrogator* last() const;

   virtual void addModeCInterrogatorAdditionCallback(
      DtModeCInterrogatorCallbackFunction cb, void* userData);

   virtual void removeModeCInterrogatorAdditionCallback(
      DtModeCInterrogatorCallbackFunction cb, void* userData);

   virtual void addModeCInterrogatorRemovalCallback(
      DtModeCInterrogatorCallbackFunction cb, void* userData);

   virtual void removeModeCInterrogatorRemovalCallback(
      DtModeCInterrogatorCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtModeCTransponderCallbackFunction)(
   DtReflectedModeCTransponder* obj, void* userData);

class DT_DLL_VL DtReflectedModeCTransponder : public DtReflectedObject
{
public:
   typedef DtModeCTransponderStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedModeCTransponder(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedModeCTransponder();

   virtual DtModeCTransponderStateRepository* modeCTransponderStateRep() const;

   virtual DtModeCTransponderStateRepository* msr() const;

   virtual DtReflectedModeCTransponder* next() const;

   virtual DtReflectedModeCTransponder* prev() const;

   virtual DtReflectedModeCTransponder* wrapNext() const;

   virtual DtReflectedModeCTransponder* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtModeCTransponderCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtModeCTransponderCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedModeCTransponder(const DtReflectedModeCTransponder& orig);

   DtReflectedModeCTransponder& operator=(const DtReflectedModeCTransponder& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedModeCTransponderList : public DtReflectedObjectList
{
public:
   DtReflectedModeCTransponderList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedModeCTransponderList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedModeCTransponderList();

private:

   DtReflectedModeCTransponderList(const DtReflectedModeCTransponderList& orig);

   DtReflectedModeCTransponderList& operator=(const DtReflectedModeCTransponderList&orig);

public:

   virtual DtReflectedModeCTransponder* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedModeCTransponder* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedModeCTransponder* first() const;

   virtual DtReflectedModeCTransponder* last() const;

   virtual void addModeCTransponderAdditionCallback(
      DtModeCTransponderCallbackFunction cb, void* userData);

   virtual void removeModeCTransponderAdditionCallback(
      DtModeCTransponderCallbackFunction cb, void* userData);

   virtual void addModeCTransponderRemovalCallback(
      DtModeCTransponderCallbackFunction cb, void* userData);

   virtual void removeModeCTransponderRemovalCallback(
      DtModeCTransponderCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtModeSCallbackFunction)(
   DtReflectedModeS* obj, void* userData);

class DT_DLL_VL DtReflectedModeS : public DtReflectedObject
{
public:
   typedef DtModeSStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedModeS(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedModeS();

   virtual DtModeSStateRepository* modeSStateRep() const;

   virtual DtModeSStateRepository* msr() const;

   virtual DtReflectedModeS* next() const;

   virtual DtReflectedModeS* prev() const;

   virtual DtReflectedModeS* wrapNext() const;

   virtual DtReflectedModeS* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtModeSCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtModeSCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedModeS(const DtReflectedModeS& orig);

   DtReflectedModeS& operator=(const DtReflectedModeS& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedModeSList : public DtReflectedObjectList
{
public:
   DtReflectedModeSList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedModeSList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedModeSList();

private:

   DtReflectedModeSList(const DtReflectedModeSList& orig);

   DtReflectedModeSList& operator=(const DtReflectedModeSList&orig);

public:

   virtual DtReflectedModeS* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedModeS* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedModeS* first() const;

   virtual DtReflectedModeS* last() const;

   virtual void addModeSAdditionCallback(
      DtModeSCallbackFunction cb, void* userData);

   virtual void removeModeSAdditionCallback(
      DtModeSCallbackFunction cb, void* userData);

   virtual void addModeSRemovalCallback(
      DtModeSCallbackFunction cb, void* userData);

   virtual void removeModeSRemovalCallback(
      DtModeSCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtModeSInterrogatorCallbackFunction)(
   DtReflectedModeSInterrogator* obj, void* userData);

class DT_DLL_VL DtReflectedModeSInterrogator : public DtReflectedObject
{
public:
   typedef DtModeSInterrogatorStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedModeSInterrogator(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedModeSInterrogator();

   virtual DtModeSInterrogatorStateRepository* modeSInterrogatorStateRep() const;

   virtual DtModeSInterrogatorStateRepository* msr() const;

   virtual DtReflectedModeSInterrogator* next() const;

   virtual DtReflectedModeSInterrogator* prev() const;

   virtual DtReflectedModeSInterrogator* wrapNext() const;

   virtual DtReflectedModeSInterrogator* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtModeSInterrogatorCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtModeSInterrogatorCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedModeSInterrogator(const DtReflectedModeSInterrogator& orig);

   DtReflectedModeSInterrogator& operator=(const DtReflectedModeSInterrogator& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedModeSInterrogatorList : public DtReflectedObjectList
{
public:
   DtReflectedModeSInterrogatorList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedModeSInterrogatorList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedModeSInterrogatorList();

private:

   DtReflectedModeSInterrogatorList(const DtReflectedModeSInterrogatorList& orig);

   DtReflectedModeSInterrogatorList& operator=(const DtReflectedModeSInterrogatorList&orig);

public:

   virtual DtReflectedModeSInterrogator* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedModeSInterrogator* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedModeSInterrogator* first() const;

   virtual DtReflectedModeSInterrogator* last() const;

   virtual void addModeSInterrogatorAdditionCallback(
      DtModeSInterrogatorCallbackFunction cb, void* userData);

   virtual void removeModeSInterrogatorAdditionCallback(
      DtModeSInterrogatorCallbackFunction cb, void* userData);

   virtual void addModeSInterrogatorRemovalCallback(
      DtModeSInterrogatorCallbackFunction cb, void* userData);

   virtual void removeModeSInterrogatorRemovalCallback(
      DtModeSInterrogatorCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtModeSTransponderCallbackFunction)(
   DtReflectedModeSTransponder* obj, void* userData);

class DT_DLL_VL DtReflectedModeSTransponder : public DtReflectedObject
{
public:
   typedef DtModeSTransponderStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedModeSTransponder(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedModeSTransponder();

   virtual DtModeSTransponderStateRepository* modeSTransponderStateRep() const;

   virtual DtModeSTransponderStateRepository* msr() const;

   virtual DtReflectedModeSTransponder* next() const;

   virtual DtReflectedModeSTransponder* prev() const;

   virtual DtReflectedModeSTransponder* wrapNext() const;

   virtual DtReflectedModeSTransponder* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtModeSTransponderCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtModeSTransponderCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedModeSTransponder(const DtReflectedModeSTransponder& orig);

   DtReflectedModeSTransponder& operator=(const DtReflectedModeSTransponder& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedModeSTransponderList : public DtReflectedObjectList
{
public:
   DtReflectedModeSTransponderList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedModeSTransponderList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedModeSTransponderList();

private:

   DtReflectedModeSTransponderList(const DtReflectedModeSTransponderList& orig);

   DtReflectedModeSTransponderList& operator=(const DtReflectedModeSTransponderList&orig);

public:

   virtual DtReflectedModeSTransponder* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedModeSTransponder* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedModeSTransponder* first() const;

   virtual DtReflectedModeSTransponder* last() const;

   virtual void addModeSTransponderAdditionCallback(
      DtModeSTransponderCallbackFunction cb, void* userData);

   virtual void removeModeSTransponderAdditionCallback(
      DtModeSTransponderCallbackFunction cb, void* userData);

   virtual void addModeSTransponderRemovalCallback(
      DtModeSTransponderCallbackFunction cb, void* userData);

   virtual void removeModeSTransponderRemovalCallback(
      DtModeSTransponderCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtSovietCallbackFunction)(
   DtReflectedSoviet* obj, void* userData);

class DT_DLL_VL DtReflectedSoviet : public DtReflectedObject
{
public:
   typedef DtSovietStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedSoviet(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedSoviet();

   virtual DtSovietStateRepository* sovietStateRep() const;

   virtual DtSovietStateRepository* ssr() const;

   virtual DtReflectedSoviet* next() const;

   virtual DtReflectedSoviet* prev() const;

   virtual DtReflectedSoviet* wrapNext() const;

   virtual DtReflectedSoviet* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtSovietCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtSovietCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedSoviet(const DtReflectedSoviet& orig);

   DtReflectedSoviet& operator=(const DtReflectedSoviet& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedSovietList : public DtReflectedObjectList
{
public:
   DtReflectedSovietList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedSovietList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedSovietList();

private:

   DtReflectedSovietList(const DtReflectedSovietList& orig);

   DtReflectedSovietList& operator=(const DtReflectedSovietList&orig);

public:

   virtual DtReflectedSoviet* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedSoviet* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedSoviet* first() const;

   virtual DtReflectedSoviet* last() const;

   virtual void addSovietAdditionCallback(
      DtSovietCallbackFunction cb, void* userData);

   virtual void removeSovietAdditionCallback(
      DtSovietCallbackFunction cb, void* userData);

   virtual void addSovietRemovalCallback(
      DtSovietCallbackFunction cb, void* userData);

   virtual void removeSovietRemovalCallback(
      DtSovietCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtSovietInterrogatorCallbackFunction)(
   DtReflectedSovietInterrogator* obj, void* userData);

class DT_DLL_VL DtReflectedSovietInterrogator : public DtReflectedObject
{
public:
   typedef DtSovietInterrogatorStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedSovietInterrogator(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedSovietInterrogator();

   virtual DtSovietInterrogatorStateRepository* sovietInterrogatorStateRep() const;

   virtual DtSovietInterrogatorStateRepository* ssr() const;

   virtual DtReflectedSovietInterrogator* next() const;

   virtual DtReflectedSovietInterrogator* prev() const;

   virtual DtReflectedSovietInterrogator* wrapNext() const;

   virtual DtReflectedSovietInterrogator* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtSovietInterrogatorCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtSovietInterrogatorCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedSovietInterrogator(const DtReflectedSovietInterrogator& orig);

   DtReflectedSovietInterrogator& operator=(const DtReflectedSovietInterrogator& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedSovietInterrogatorList : public DtReflectedObjectList
{
public:
   DtReflectedSovietInterrogatorList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedSovietInterrogatorList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedSovietInterrogatorList();

private:

   DtReflectedSovietInterrogatorList(const DtReflectedSovietInterrogatorList& orig);

   DtReflectedSovietInterrogatorList& operator=(const DtReflectedSovietInterrogatorList&orig);

public:

   virtual DtReflectedSovietInterrogator* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedSovietInterrogator* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedSovietInterrogator* first() const;

   virtual DtReflectedSovietInterrogator* last() const;

   virtual void addSovietInterrogatorAdditionCallback(
      DtSovietInterrogatorCallbackFunction cb, void* userData);

   virtual void removeSovietInterrogatorAdditionCallback(
      DtSovietInterrogatorCallbackFunction cb, void* userData);

   virtual void addSovietInterrogatorRemovalCallback(
      DtSovietInterrogatorCallbackFunction cb, void* userData);

   virtual void removeSovietInterrogatorRemovalCallback(
      DtSovietInterrogatorCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtSovietTransponderCallbackFunction)(
   DtReflectedSovietTransponder* obj, void* userData);

class DT_DLL_VL DtReflectedSovietTransponder : public DtReflectedObject
{
public:
   typedef DtSovietTransponderStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedSovietTransponder(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedSovietTransponder();

   virtual DtSovietTransponderStateRepository* sovietTransponderStateRep() const;

   virtual DtSovietTransponderStateRepository* ssr() const;

   virtual DtReflectedSovietTransponder* next() const;

   virtual DtReflectedSovietTransponder* prev() const;

   virtual DtReflectedSovietTransponder* wrapNext() const;

   virtual DtReflectedSovietTransponder* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtSovietTransponderCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtSovietTransponderCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedSovietTransponder(const DtReflectedSovietTransponder& orig);

   DtReflectedSovietTransponder& operator=(const DtReflectedSovietTransponder& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedSovietTransponderList : public DtReflectedObjectList
{
public:
   DtReflectedSovietTransponderList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedSovietTransponderList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedSovietTransponderList();

private:

   DtReflectedSovietTransponderList(const DtReflectedSovietTransponderList& orig);

   DtReflectedSovietTransponderList& operator=(const DtReflectedSovietTransponderList&orig);

public:

   virtual DtReflectedSovietTransponder* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedSovietTransponder* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedSovietTransponder* first() const;

   virtual DtReflectedSovietTransponder* last() const;

   virtual void addSovietTransponderAdditionCallback(
      DtSovietTransponderCallbackFunction cb, void* userData);

   virtual void removeSovietTransponderAdditionCallback(
      DtSovietTransponderCallbackFunction cb, void* userData);

   virtual void addSovietTransponderRemovalCallback(
      DtSovietTransponderCallbackFunction cb, void* userData);

   virtual void removeSovietTransponderRemovalCallback(
      DtSovietTransponderCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

typedef void(*DtTCASDataCallbackFunction)(
   DtReflectedTCASData* obj, void* userData);

class DT_DLL_VL DtReflectedTCASData : public DtReflectedObject
{
public:
   typedef DtTCASDataStateRepository* (*DtStateRepCreator)();

public:
   DtReflectedTCASData(DtHlaObject* obj, DtExerciseConn* exConn);

   virtual ~DtReflectedTCASData();

   virtual DtTCASDataStateRepository* TCASDataStateRep() const;

   virtual DtTCASDataStateRepository* Tsr() const;

   virtual DtReflectedTCASData* next() const;

   virtual DtReflectedTCASData* prev() const;

   virtual DtReflectedTCASData* wrapNext() const;

   virtual DtReflectedTCASData* wrapPrev() const;

   virtual void addPostUpdateCallback(
      DtTCASDataCallbackFunction cb, void* userData);

   virtual void removePostUpdateCallback(
      DtTCASDataCallbackFunction cb, void* userData);

public:
   static DtStateRepCreator setStateRepCreator(DtStateRepCreator creator);

protected:
   DtReflectedTCASData(const DtReflectedTCASData& orig);

   DtReflectedTCASData& operator=(const DtReflectedTCASData& orig);

protected:
   static DtStateRepCreator theStateRepCreator;
};

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

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

class DT_DLL_VL DtReflectedTCASDataList : public DtReflectedObjectList
{
public:
   DtReflectedTCASDataList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse = 0);

   DtReflectedTCASDataList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

   virtual ~DtReflectedTCASDataList();

private:

   DtReflectedTCASDataList(const DtReflectedTCASDataList& orig);

   DtReflectedTCASDataList& operator=(const DtReflectedTCASDataList&orig);

public:

   virtual DtReflectedTCASData* lookup(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedTCASData* lookup(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedTCASData* first() const;

   virtual DtReflectedTCASData* last() const;

   virtual void addTCASDataAdditionCallback(
      DtTCASDataCallbackFunction cb, void* userData);

   virtual void removeTCASDataAdditionCallback(
      DtTCASDataCallbackFunction cb, void* userData);

   virtual void addTCASDataRemovalCallback(
      DtTCASDataCallbackFunction cb, void* userData);

   virtual void removeTCASDataRemovalCallback(
      DtTCASDataCallbackFunction cb, void* userData);

protected:

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual void objectAdded(DtReflectedObject* obj);

};

#endif