reflectedEntityListHLA.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*********************************************************************/

#ifndef reflectedEntityListHLA_H_
#define reflectedEntityListHLA_H_

#if DtHLA 

#include "reflectedObjectListHLA.h"
#include "reflectedEntityHLA.h"
#include "region.h"

#include <matrix/geodeticCoord.h>
#include <vector>
class DtGeodeticRegion;
class DtReflectedDIGuyObjectList;
class DtReflectedDIGuyObject;


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

private:

   DtReflectedEntityList(const DtReflectedEntityList& orig);

   DtReflectedEntityList& operator=(const DtReflectedEntityList& orig);

public:

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

protected:

   bool mySmoothCapable;

   DtHashlist myEntityIdentifierHashlist;

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

#endif
#endif