reflectedObjectHLA.h

Go to the documentation of this file.

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


#if DtHLA 

#ifndef DtHlaReflectedObject_H_
#define DtHlaReflectedObject_H_


#include "globalObjectDesignator.h"
#include "hlaObjectWithStateRep.h"
#include "reflectedObjectCallbackInfo.h"
#include "reflectedObjectListHLA.h"
#include "objectId.h"


class DT_DLL_VL DtStateRepository;
class DT_DLL_VL DtExerciseConn;
class DT_DLL_VL DtHlaStateDecoder;
class DT_DLL_VL DtStateMsg;
class DT_DLL_VL DtReflectedObject;


class DT_DLL_VL DtReflectedObject
{
   friend class DtReflectedObjectList;

public:

   typedef DtStateRepository* (*DtBaseStateRepCreator)();

public:

   DtReflectedObject(DtExerciseConn* conn, 
      DtStateRepository* stateRep);

   DtReflectedObject(DtHlaObject* obj, 
      DtExerciseConn* conn, DtBaseStateRepCreator creator);

   DtReflectedObject(const DtObjectId& id, 
      const DtGlobalObjectDesignator& des,
      DtExerciseConn* conn, DtBaseStateRepCreator creator);

   virtual ~DtReflectedObject();

   virtual DtStateRepository* stateRep() const;

   virtual DtStateRepository* sr() const;

   virtual DtHlaStateDecoder* decoder();

   virtual DtHlaObjectWithStateRep* hlaObject() const;

   virtual const DtObjectId& objectId() const;

   virtual const DtObjectId& id() const;

   virtual const DtObjectId& localId() const;

   virtual const DtString& name() const;

   virtual const DtGlobalObjectDesignator& globalId() const;

#if DtHLA_1516_EVOLVED
   virtual const DtString& lastProducingFederate() const;
#endif

   virtual DtTime lastSimTimeUpdated() const;


   virtual DtTime lastReceivedTimeStamp() const;

   virtual void baseAddPostUpdateCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);
   virtual void baseRemovePostUpdateCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);

   virtual DtReflectedObject* nextObj() const;

   virtual DtReflectedObject* prevObj() const;

   virtual DtReflectedObject* wrapNextObj() const;

   virtual DtReflectedObject* wrapPrevObj() const;

   void setHlaObject(DtHlaObject* obj, 
      DtHlaStateDecoder* decoder = NULL);

   virtual void setNoHlaObject(const DtObjectId& id,
      const DtGlobalObjectDesignator& des);
   
   void detachHlaObject();

   virtual void requestUpdate();

protected:

   DtReflectedObject(const DtReflectedObject& orig);

   DtReflectedObject& operator=(const DtReflectedObject& orig);

   virtual void processPostUpdateCallbacks();

protected:

   static void requestUpdatePostDrainCb(void* usr);

   static void processPostUpdateCallbacksCb(
      const DtStateMsg& stateMsg, 
      DtHlaObject* obj,
      void* usr);

protected:

   DtExerciseConn* myExConn;
   DtHlaObjectWithStateRep* myHlaObj;
   DtStateRepository* myStateRep;
   DtHlaStateDecoder* myDecoder;
   bool myRequestCbRegistered;
   DtIntrusiveList myStateUpdateCallbacks;
   DtObjectId myId;
   DtString myName;

   //This variable is maintained privately by the parent list so that nextObj functions work
   DtRefHlaObjectMap::iterator myReflIterator;
   DtRefHlaObjectMap* myReflMap;
};


inline const DtObjectId& DtReflectedObject::localId() const
{
   return id();
}

inline DtStateRepository* DtReflectedObject::stateRep() const
{
   return myStateRep;
}

inline DtStateRepository* DtReflectedObject::sr() const
{
   return myStateRep;
}

inline DtHlaObjectWithStateRep* DtReflectedObject::hlaObject() const
{
   return myHlaObj;
}

inline DtReflectedObject* DtReflectedObject::nextObj() const
{ 
   if(myReflMap)
   {
      DtRefHlaObjectMap::iterator nextIter = myReflIterator;
      ++nextIter;
      if(nextIter != myReflMap->end()) 
      {
         return nextIter->second;
      }
   }
   return 0; 
}

inline DtReflectedObject* DtReflectedObject::prevObj() const
{ 
   if(myReflMap)
   {
      DtRefHlaObjectMap::iterator nextIter = myReflIterator;
      if(nextIter != myReflMap->begin()) 
      {
         --nextIter;
         return nextIter->second;
      }
   }
   return 0; 
}

inline DtReflectedObject* DtReflectedObject::wrapNextObj() const
{ 
   if(myReflMap)
   {
      DtReflectedObject* obj = nextObj();
      if(obj) 
      {
            return obj;
      }
      else 
      {
         if(!myReflMap->empty())
         {
            return myReflMap->begin()->second;
         }
         return 0;
      }
   }
   return 0;
}

inline DtReflectedObject* DtReflectedObject::wrapPrevObj() const
{ 
   if(myReflMap)
   {
      DtReflectedObject* obj = prevObj();
      if(obj) 
      {
         return obj;
      }
      else 
      {
         if(!myReflMap->empty())
         {
            return myReflMap->rend()->second;
         }
         return 0;
      }
   }
   return 0;
}

#endif
#endif