objectPublisherHLA.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2010 MAK Technologies, Inc
** All rights reserved.
*********************************************************************/


#if DtHLA 

#ifndef objectPublisherHLA_H_
#define objectPublisherHLA_H_


#include <vlutil/vlMachineTypes.h>
#include "rtiNamespace.h"
#include "objectId.h"
#include "globalObjectDesignator.h"
#include "hlaObjectWithStateRep.h"
#include "region.h"


class DtStateRepository;
class DtExerciseConn;
class DtHlaStateDecoder;
class DtHlaStateEncoder;

class DT_DLL_VL DtObjectPublisher
{
public:

   DtObjectPublisher(DtExerciseConn* conn,
      DtStateRepository* stateRep,
      DtStateRepository* asSeenByRemote, 
      bool okToDeleteStateRep = true,
      const DtDDMRegionSet* regionSet = 0);
      
   virtual ~DtObjectPublisher();

private:

   DtObjectPublisher(const DtObjectPublisher& orig);

   DtObjectPublisher& operator= (const DtObjectPublisher& orig);

public:

   
   virtual void setHlaObject(
      const char* className,
      DtHlaStateEncoder* encoder = 0,
      DtHlaStateDecoder* decoder = 0,
      const char* objectName = 0,
      const DtDDMRegionSet* regionSet = 0);

   virtual void setHlaObject(
      RTI::ObjectClassHandle hand,
      DtHlaStateEncoder* encoder = 0,
      DtHlaStateDecoder* decoder = 0,
      const char* objectName = 0,
      const DtDDMRegionSet* regionSet = 0);

   virtual void setHlaObject(
      DtHlaObjectWithStateRep* obj,
      DtHlaStateEncoder* encoder = 0,
      DtHlaStateDecoder* decoder = 0);
      
   virtual void detachHlaObject();
   
   virtual DtStateRepository* stateRep();

   virtual DtStateRepository* sr();

   virtual DtStateRepository* approximateRemoteStateRep();

   virtual DtHlaStateDecoder* decoder();

   virtual DtHlaStateEncoder* encoder();

   virtual DtHlaObjectWithStateRep* hlaObject();

   virtual DtExerciseConn* exerciseConn();

   virtual const DtObjectId& id() const;

   virtual const DtObjectId& objectId() const;

   virtual const DtObjectId& localId() const;

   virtual const DtString& name() const;

   virtual const DtGlobalObjectDesignator& globalId() const;

   virtual void forceUpdate();
   virtual void forceUpdate(const RTI::AttributeHandleSet& set);

   virtual bool tick();

   virtual bool parallelTick();

   virtual void setDeleteObjInDtorFlag(bool onOff);
   virtual bool deleteObjInDtorFlag() const;

   virtual const DtDDMRegionSet& publishingRegions() const;

   virtual void addRegion(DtDDMRegionSP regionToAdd);

   virtual void removeRegion(DtDDMRegionSP regionToRemove);

   virtual void setUpdateRateWarningThreshold(unsigned short updatesPerSecond);

   virtual unsigned short updateRateWarningThreshold() const;

   virtual void checkForUpdateRateWarning();

public:
   
   static void removeObjectCb(DtHlaObject* obj, void* pub);

   static void setDfltUpdateRateWarningThreshold(unsigned short updatesPerSecond);

   static unsigned short dfltUpdateRateWarningThreshold();

protected:

   DtObjectPublisher(DtStateRepository* stateRep,
      DtStateRepository* asSeenByRemote, 
      bool okToDeleteStateRep = true,
      const DtDDMRegionSet* regionSet = 0);

   virtual void setExerciseConn(DtExerciseConn* conn);

   virtual void processRemoveObject(DtHlaObject* obj);

protected:

   DtExerciseConn* myExConn;
   DtHlaObjectWithStateRep* myHlaObj;
   DtStateRepository* myStateRep;
   DtStateRepository* myAsSeenByRemote;
   DtHlaStateEncoder* myEncoder;
   DtHlaStateDecoder* myDecoder;
   DtObjectId myObjectId;
   bool myOkToDeleteStateRepFlag;
   DtString myName;
   bool myDeleteObjInDtorFlag;
   DtDDMRegionSet myPublishingRegions;
   DtTime myRealTimeLastUpdate;
   DtTime myLastSpamCheckTime;
   unsigned short myNumberOfUpdatesPerSecond;
   unsigned short myUpdateRateWarningThreshold;
   bool myCanWarn;

public:
   
   DtObjectPublisher(DtExerciseConn* conn, const char* name = 0);
   void init(RTI::ObjectClassHandle hand, DtStateRepository* stateRep,
      DtStateRepository* asSeenByRemote, DtHlaStateEncoder* encoder = 0,
      DtHlaStateDecoder* decoder = 0);
   void init(const char* className, DtStateRepository* stateRep,
      DtStateRepository* asSeenByRemote, DtHlaStateEncoder* encoder = 0,
      DtHlaStateDecoder* decoder = 0);

protected:
   static unsigned short theDfltUpdateRateWarningThreshold;

};

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

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

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

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

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

inline DtStateRepository* DtObjectPublisher::approximateRemoteStateRep()
{
   return myAsSeenByRemote;
}


#endif   //DtObjectPublisher_H_
#endif   //DtHLA