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;

struct DtTimeReflectedObjectIdKey
{
   DtTimeReflectedObjectIdKey(DtTime timeValue, const DtObjectId& idValue);

   DtTimeReflectedObjectIdKey(const DtReflectedObject* object);

   DtTime time;
   DtObjectId id;
};

bool operator<(const DtTimeReflectedObjectIdKey& left, const DtTimeReflectedObjectIdKey& right);
bool operator< (const DtTimeReflectedObjectIdKey& left, DtTime right);

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


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

   virtual void setTimeoutProcessing(bool onOff);

   virtual bool isTimeoutProcessing() const;


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

   virtual bool requestsEnabled() const;


   virtual void setWaitListRefreshEnabled(bool on);
   virtual bool waitListRefreshEnabled() const;


   virtual void setWaitListRefreshPeriod(DtTime period);
   virtual DtTime waitListRefreshPeriod() const;


   virtual DtReflectedObject* firstWaitingObj() const;
   virtual DtReflectedObject* lastWaitingObj() const;

   virtual int numberObjectsWaiting() const;

   virtual DtTime nextRequestTime() const;

   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 setRequestWhenInitializedFlag(bool onOff);
   static bool requestWhenInitializedFlag();


   static void setDefaultWaitListRefreshFlag(bool onOff);
   static bool defaultWaitListRefreshFlag();


   static void setDefaultWaitListRefreshPeriod(DtTime period);
   static DtTime defaultWaitListRefreshPeriod();

   static bool requestUpdateFlags();

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

   // or any objects which have not met their discovery criteria yet.
   virtual void doRequestUpdates();

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

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

   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 void addToWaitList(DtReflectedObject* refObj);

   virtual void removeFromWaitList(DtReflectedObject* refObj);

   virtual void addToRefreshList(DtReflectedObject* refObj, DtTime timeToRefresh);

   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 doRequestUpdatesPostDrainCb(void* usr);

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

protected:

   DtExerciseConn* myExConn;
   DtRefHlaObjectMap myObjectList;
   DtHashList myObjectListByName;

   // When an object is unable to be discovered due to not meeting discovery criteria
   // it is placed on wait list and initially on discovery request list.
   // If object instance requests are enabled, after first request it is moved to refresh list
   DtRefHlaObjectMap  myWaitList;
   DtRefHlaObjectMap  myDiscoveryList;
   DtRefHlaObjectTimeMap  myRefreshList;
   bool myWaitListRefreshEnabled;
   DtTime myNextRequestTime;
   DtTime myWaitListRefreshPeriod;

   DtList myTimedOutObjectList;
   DtTime myTimeoutInterval;
   bool myTimeoutProcessingFlag;

   std::vector<RTI::ObjectClassHandle> myHandleList;
   DtIntrusiveList                     myObjectAddedCallbacks;
   DtIntrusiveList                     myObjectRemovedCallbacks;
   DtDiscoveryCondition myDiscoveryCondition;
   void* myDiscoveryConditionParameter;
   DtDDMRegionSet mySubscribedRegions;
   DtString myUpdateRateTag;

protected:

   static bool theAutoSubscribeFlag;
   static bool theRequestClassUpdateFlag;
   static bool theRequestObjectUpdateFlag;
   static bool theRequestWhenInitializedFlag;
   static bool theRequestUpdateFlags;
   static bool theDefaultWaitListRefreshFlag;
   static DtTime theDefaultWaitListRefreshPeriod;
};

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

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

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

inline DtReflectedObject* DtReflectedObjectList::firstWaitingObj() const
{
   return myWaitList.size() > 0 ? (DtReflectedObject*)myWaitList.begin()->second : nullptr;
}

inline DtReflectedObject* DtReflectedObjectList::lastWaitingObj() const
{
   return myWaitList.size() > 0 ? (DtReflectedObject*)myWaitList.rend()->second : nullptr;
}

inline int DtReflectedObjectList::numberObjectsWaiting() const
{
   return myWaitList.size();
}

inline DtTime DtReflectedObjectList::waitListRefreshPeriod() const
{
   return myWaitListRefreshPeriod;
}

inline bool DtReflectedObjectList::waitListRefreshEnabled() const
{
   return myWaitListRefreshEnabled;
}

inline bool DtReflectedObjectList::defaultWaitListRefreshFlag()
{
   return theDefaultWaitListRefreshFlag;
}

inline DtTime DtReflectedObjectList::defaultWaitListRefreshPeriod()
{
   return theDefaultWaitListRefreshPeriod;
}

inline bool DtReflectedObjectList::requestClassUpdateFlag()
{
   return theRequestClassUpdateFlag;
}

inline bool DtReflectedObjectList::requestObjectUpdateFlag()
{
   return theRequestObjectUpdateFlag;
}

inline bool DtReflectedObjectList::requestWhenInitializedFlag()
{
   return theRequestWhenInitializedFlag;
}

inline bool DtReflectedObjectList::requestUpdateFlags()
{
   return theRequestUpdateFlags;
}

inline bool DtReflectedObjectList::isTimeoutProcessing() const
{
   return myTimeoutProcessingFlag;
}

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

inline bool operator<(const DtTimeReflectedObjectIdKey& left, DtTime right)
{
   return left.time < right;
}

inline bool operator<(const DtTimeReflectedObjectIdKey& left, const DtTimeReflectedObjectIdKey& right)
{
   if (left.time < right.time)  return true;
   if (left.time > right.time)  return false;

   // time are equal, compare Id
   return (left.id < right.id);
}


#endif