entityPublisherDIS.h

Go to the documentation of this file.

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

#if DtDIS


#include "objectPublisherDIS.h"
#include "entityStateRepository.h"
#include "entityStateEncoder.h"
#include "entityStateDecoder.h"
#include "objectId.h"

class DT_DLL_VL DtEntityPublisher : public DtObjectPublisher
{        
public:

   //g++ forces us to define this function before we define
   //our constructors
   static const DtEntityType& guiseSameAsType();

public:

   typedef DtEntityStateRepository* (*DtStateRepCreator)();

public:


   DtEntityPublisher(
      DtEntityStateRepository *stateRepToUse,
      DtExerciseConn* conn,
      const DtObjectId& id = DtObjectId::defaultId());

   DtEntityPublisher(
      DtExerciseConn* conn,
      const DtObjectId& id = DtObjectId::defaultId());

   DtEntityPublisher(
      const DtEntityType& type,
      DtExerciseConn* conn,
      const DtObjectId& id = DtObjectId::defaultId());

   DtEntityPublisher(
      const DtEntityType& type,
      DtExerciseConn* conn,
      DtDeadReckonTypes algorithm,
      DtForceType forceId,
      const DtEntityType& guise = guiseSameAsType(),
      const DtObjectId& id = DtObjectId::defaultId());

   virtual ~DtEntityPublisher();

private:

   DtEntityPublisher(const DtEntityPublisher& orig);

   DtEntityPublisher& operator=(const DtEntityPublisher& orig);

public:
   virtual void tick();

   virtual DtEntityStateRepository* entityStateRep();

   virtual DtEntityStateRepository* esr();

   virtual DtEntityStateDecoder* decoder();

   virtual DtEntityStateEncoder* encoder();

   virtual const DtObjectId& id() const;

   virtual const DtObjectId& localId() const;
   
   virtual const DtGlobalObjectDesignator& globalId() const;

   virtual void sendFinalPduOnDestruction(bool on);

   virtual void forceUpdate();

   virtual void setSendDiGuyPdus(bool yesNo);

   virtual bool sendDiGuyPdus() const;

   virtual void setSendSeesPdus(bool yesNo);

   virtual bool sendSeesPdus() const;

   virtual void setSeesTimeThreshold(DtTime time);

   virtual DtTime seesTimeThreshold() const;

   DtTime entityTypeHeartbeat(int type, int domain);

public:

   static void setStateRepCreator(DtStateRepCreator creator);
   static DtStateRepCreator stateRepCreator(void);

   static void setClassDfltTimeThreshold(DtTime threshold);
   static void setStationaryDfltTimeThreshold(DtTime threshold);
   static void setEntityTypeDfltTimeThreshold(int type, int domain, DtTime threshold);


   static void setDfltRotationThreshold(double r);
   static double dfltRotationThreshold();
   static void setDfltTranslationThreshold(double t);
   static double dfltTranslationThreshold();

protected:
   
   void sendFinalPdu();

   virtual void createAndSendDiGuyPdus();

   virtual void createAndSendSeesPdu();

   virtual bool sendSeesNeeded() const;

   void init( const DtObjectId& vehId);

protected:
   DtObjectId            myId;
   DtEntityStateDecoder* myEntityDecoder; 
   DtEntityStateEncoder* myEntityEncoder;
   bool                  mySendFinalInDtor;
   bool                  mySendDiGuyPdus;
   bool                  mySendSeesPdus;
   DtTime                mySeesPdusTimeThreshold;
   DtTime                myLastSeesPdusUpdate;

protected:
   static DtStateRepCreator theStateRepCreator;
   static DtTime            theClassDfltTimeThreshold;
   static bool              theClassDfltIsSetFlag;
   static DtTime            theStationaryDfltTimeThreshold;
   static bool              theStationaryDfltIsSetFlag;
   static std::map<std::pair<int,int>,DtTime> theEntityTypeHeartbeat;
};

inline DtEntityStateRepository* DtEntityPublisher::entityStateRep()
{
   return esr();
}

inline DtEntityStateRepository* DtEntityPublisher::esr()
{
   return (DtEntityStateRepository*) stateRep();
}

inline DtEntityStateEncoder* DtEntityPublisher::encoder()
{
   return myEntityEncoder;
}

inline DtEntityStateDecoder* DtEntityPublisher::decoder()
{
   return myEntityDecoder;
}

inline void DtEntityPublisher::sendFinalPduOnDestruction(bool onOff)
{
   mySendFinalInDtor = onOff;
}

inline const DtObjectId& DtEntityPublisher::id() const
{
   return myId;
}

inline double DtEntityPublisher::dfltRotationThreshold()
{
   return DtThresholder::dfltRotationThreshold();
}

inline double DtEntityPublisher::dfltTranslationThreshold()
{
   return DtThresholder::dfltTranslationThreshold();
}

inline void DtEntityPublisher::setDfltTranslationThreshold(double t)
{   
   DtThresholder::setDfltTranslationThreshold(t);
}

inline void DtEntityPublisher::setDfltRotationThreshold(double r)
{
   DtThresholder::setDfltRotationThreshold(r);
}

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



#endif