reflectedEntityListHLA.h

Go to the documentation of this file.

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


#if DtHLA

#pragma once

#include <vl/reflectedObjectListHLA.h>
#include <vl/reflectedEntityHLA.h>
#include <vl/region.h>
#include <matrix/geodeticCoord.h>
#include <vector>

class DtGeodeticRegion;
class DtReflectedDIGuyObject;
class DtReflectedDIGuyObjectList;

class DT_DLL_VL DtReflectedEntityList : public DtReflectedObjectList
{
public:

   DtReflectedEntityList(
      DtExerciseConn* exConn,
      bool smoothCapable = false,
      const DtDDMRegionSet* regionSetToUse = 0 );

   DtReflectedEntityList(
      DtExerciseConn* exConn,
      const DtString& updateRateTag,
      bool smoothCapable = false,
      const DtDDMRegionSet* regionSetToUse = 0 );


   DtReflectedEntityList(
      DtExerciseConn* exConn,
      const DtList *handleList,
      bool smoothCapable = false,
      const DtDDMRegionSet* regionSetToUse = 0 );

   DtReflectedEntityList(
      DtExerciseConn* exConn,
      const DtList *handleList,
      const DtString& updateRateTag,
      bool smoothCapable = false,
      const DtDDMRegionSet* regionSetToUse = 0 );

   virtual ~DtReflectedEntityList();

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

   virtual DtReflectedEntity* lookup(const DtGlobalObjectDesignator& objName);

   virtual DtReflectedEntity* lookup(const DtEntityIdentifier& entityId);

   virtual DtReflectedEntity* first() const;

   virtual DtReflectedEntity* last() const;

   virtual void addToObjectList(DtReflectedObject* refObj);

   virtual void addToEntityIdentifierHashList(DtReflectedEntity* ent);

   virtual void addEntityAdditionCallback(
      DtEntityCallbackFunction cb, void* userData);

   virtual void removeEntityAdditionCallback(
      DtEntityCallbackFunction cb, void* userData);

   virtual void addEntityRemovalCallback(
      DtEntityCallbackFunction cb, void* userData);

   virtual void removeEntityRemovalCallback(
      DtEntityCallbackFunction cb, void* userData);

   virtual void discoverOnlyWhenEntityTypeKnown(bool yesNo);

protected:

   virtual const DtList* dfltHandleList();

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;

   virtual DtReflectedEntity* newReflectedEntity(DtHlaObject* obj) const;

   virtual void removeAndDelete(DtReflectedObject* object, char* msg);

   virtual void removeAndDelete(DtReflectedEntity* entity, char* msg = NULL);

   virtual void objectAdded(DtReflectedObject* obj);

   virtual void entityAdded(DtReflectedEntity* ent);

   virtual void initializeDIGuy();

   virtual void processDiGuyObjectAddition( DtReflectedDIGuyObject* beam );
   virtual void processDiGuyObjectUpdate( DtReflectedDIGuyObject* beam );
   virtual void processDiGuyObjectRemoval( DtReflectedDIGuyObject* beam );

   virtual void resolveOrphans();

protected:

   static bool checkEntityType(DtReflectedObject* obj, void* usr);

   static void checkEntityId(DtReflectedEntity* ent, void* usr);

   static void diGuyObjectAdditionCb(
      DtReflectedDIGuyObject* beam, void* usr );
   static void diGuyObjectUpdateCb(
      DtReflectedDIGuyObject* beam, void* usr );
   static void diGuyObjectRemovalCb(
      DtReflectedDIGuyObject* beam, void* usr );

   static void resolveOrphansPostDrainCb( void* usr );

   static bool delayDiGuyObjectDiscoveryCondition(
      DtReflectedObject* beam, void* usr );

private:

   DtReflectedEntityList(const DtReflectedEntityList& orig);

   DtReflectedEntityList& operator=(const DtReflectedEntityList& orig);

protected:

   bool mySmoothCapable;

   DtHashlist myEntityIdentifierHashlist;

   std::set<DtReflectedDIGuyObject*> myOrphanDiGuyObjects;
   DtReflectedDIGuyObjectList* myReflectedDiGuyObjects;

};

#endif // DtHLA