reflectedObjectListHLA.h

Go to the documentation of this file.

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


#pragma once

#if DtHLA


#include <vl/reflectedObjectCallbackInfo.h>
#include <vl/globalObjectDesignator.h>
#include <vl/objectIdHashlist.h>
#include <vl/region.h>
#include <vector>

class DtStateMsg;
class DtHlaObject;
class DtExerciseConn;
class DtReflectedObject;

typedef bool (*DtDiscoveryCondition)(DtReflectedObject* refObj, void* usr);
typedef std::map<DtObjectId, DtReflectedObject*> DtRefHlaObjectMap;

class DT_DLL_VL DtReflectedObjectList
{
public:

   DtReflectedObjectList(DtExerciseConn* exConn,
                         const DtDDMRegionSet* regionSetToUse = 0,
                         const DtString& updateRateTag = DtString("") );

   virtual ~DtReflectedObjectList();

private:

   DtReflectedObjectList(const DtReflectedObjectList& orig);

   DtReflectedObjectList& operator=(const DtReflectedObjectList& orig);

public:

   virtual DtReflectedObject* lookupObj(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedObject* lookupObj(
      const DtGlobalObjectDesignator& objName);

   virtual DtReflectedObject* firstObj() const;
   virtual DtReflectedObject* lastObj() const;

   virtual int count() const;

   virtual DtExerciseConn *exerciseConn() const;

   virtual void manageObjectClass(RTI::ObjectClassHandle handle);

   virtual bool removeObject(const DtObjectId& id);

   virtual void addObjectAdditionCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);
   virtual void removeObjectAdditionCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);

   virtual void addObjectRemovalCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);
   virtual void removeObjectRemovalCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);

   virtual void print();

   virtual void setTimeoutProcessing(bool onOff);

   virtual bool isTimeoutProcessing() const;

   virtual void setWaitListRefreshEnabled(bool on);

   virtual void setTimeoutInterval(DtTime time);
   virtual DtTime timeoutInterval();

   virtual void setWaitlistRefreshPeriod(DtTime time);
   virtual DtTime waitlistRefreshPeriod();

   virtual void setDiscoveryCondition(DtDiscoveryCondition fn, void* usr);

   virtual void clearDiscoveryCondition();

   virtual const DtDDMRegionSet& subscribedRegions();


public:

   static void setAutoSubscribeFlag(bool flag);
   static bool autoSubscribeFlag();

   static void setRequestClassUpdateFlag(bool onOff);
   static bool requestClassUpdateFlag();

   static void setRequestObjectUpdateFlag(bool onOff);
   static bool requestObjectUpdateFlag();

   static void findDiscoveredObjectsCb(void* usr);


protected:

   virtual void processDiscoverObject(DtHlaObject* obj);

   virtual void processRemoveObject(DtHlaObject* obj);

   virtual void processTimedOutObjectReflect(const DtStateMsg& msg,
      DtHlaObject* obj);

   virtual void doTimeouts();

   virtual void doRequestWaitListUpdates();

   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const = 0;

   virtual void removeAndDelete(DtReflectedObject* obj,
      char* msg = NULL);

   virtual void objectAdded(DtReflectedObject* object);

   virtual bool shouldBeTimedOut(DtReflectedObject* object);

   virtual void timeOutObject(DtReflectedObject* object);

   virtual void unTimeOutObject(DtHlaObject* obj);

   virtual void addObjectClass(RTI::ObjectClassHandle handle);

   virtual void addObjectClassByName(const char* className);

   virtual void init(const DtList* handleList);

   void emptyLists();

   void emptyCallbackLists();

   virtual void processObjectAdditionCallbacks(
      DtReflectedObject* object);
   virtual void processObjectRemovalCallbacks(
      DtReflectedObject* object);

   virtual void findAlreadyDiscoveredObjects();

   virtual void checkDiscoveryCondition(DtReflectedObject* refObj);

   virtual bool readyToAdd(DtReflectedObject* obj);

   virtual void addToObjectList(DtReflectedObject* refObj);

   virtual DtReflectedObject* lookupObjInWaitList(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id);
#else
      RTI::ObjectHandle id);
#endif

   virtual DtReflectedObject* lookupObjInWaitList(
      const DtGlobalObjectDesignator& name);

   void unsubscribeRegions();

#if DtHLA_1516_EVOLVED
   const DtString& updateRateSubscriptionName() const;
#endif

protected:

   static void discoverObjectCb(DtHlaObject* hlaObj, void* rel);

   static void removeObjectCb(DtHlaObject* hlaObj, void* rel);

   static void timedOutObjectReflectCb(const DtStateMsg& msg,
      DtHlaObject* obj,
      void* usr);

   static void doTimeoutsPostDrainCb(void* usr);

   static void doRequestWaitListUpdatesPostDrainCb(void* usr);

   static void postUpdateCb(DtReflectedObject* obj, void* usr);

protected:

   DtExerciseConn* myExConn;
   DtRefHlaObjectMap myObjectList;
   DtHashList myObjectListByName;
   DtRefHlaObjectMap  myWaitList;
   DtList myTimedOutObjectList;
   std::vector<RTI::ObjectClassHandle> myHandleList;
   DtIntrusiveList                     myObjectAddedCallbacks;
   DtIntrusiveList                     myObjectRemovedCallbacks;
   DtTime myTimeoutInterval;
   bool myTimeoutProcessingFlag;
   bool myWaitListRequestUpdateFlag;
   DtDiscoveryCondition myDiscoveryCondition;
   void* myDiscoveryConditionParameter;
   DtTime myWaitlistTime;
   DtTime myWaitlistRefreshPeriod;
   DtDDMRegionSet mySubscribedRegions;
   DtString myUpdateRateTag;

protected:

   static bool theAutoSubscribeFlag;
   static bool theRequestClassUpdateFlag;
   static bool theRequestObjectUpdateFlag;
};

inline DtReflectedObject* DtReflectedObjectList::firstObj() const
{
   return myObjectList.size() > 0 ?
     (DtReflectedObject* ) myObjectList.begin()->second : NULL;
}

inline DtReflectedObject* DtReflectedObjectList::lastObj() const
{
   return myObjectList.size() > 0 ?
      (DtReflectedObject* ) myObjectList.rend()->second : NULL;
}

inline void DtReflectedObjectList::setTimeoutInterval(DtTime time)
{
   myTimeoutInterval = time;
}

inline DtTime DtReflectedObjectList::timeoutInterval()
{
   return myTimeoutInterval;
}

inline void DtReflectedObjectList::setWaitlistRefreshPeriod(DtTime time)
{
   myWaitlistRefreshPeriod = time;
}

inline DtTime DtReflectedObjectList::waitlistRefreshPeriod()
{
   return myWaitlistRefreshPeriod;
}

inline DtExerciseConn* DtReflectedObjectList::exerciseConn() const
{
   return myExConn;
}

#endif