designatorPublisherDIS.h

Go to the documentation of this file.

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


#pragma once

#if DtDIS

#include <vl/pdu.h>
#include <vl/objectPublisherDIS.h>
#include <vl/designatorRepository.h>
#include <vl/designatorDecoderDIS.h>
#include <vl/designatorEncoderDIS.h>
#include <vlutil/vlPrint.h>

class DT_DLL_VL DtDesignatorPublisher : public DtObjectPublisher
{
public:

   typedef DtDesignatorRepository* (*DtStateRepCreator)();

public:

   DtDesignatorPublisher( DtExerciseConn* conn,
      const DtObjectId& entityId = DtObjectId::defaultId() );

   DtDesignatorPublisher( DtDesignatorRepository* stateRepToUse,
      DtExerciseConn* conn, const DtObjectId& entityId = DtObjectId::defaultId() );

   virtual ~DtDesignatorPublisher();

   virtual void tick();

   virtual inline DtDesignatorRepository* designatorStateRep();

   virtual inline DtDesignatorRepository* dsr();

   virtual inline DtDesignatorDecoder* decoder() { return myDecoder; }

   virtual inline DtDesignatorEncoder* encoder() { return myEncoder; }

   virtual const DtObjectId& id() const;

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

   virtual inline const DtGlobalObjectDesignator& globalId() const { return id(); }

   virtual inline void sendFinalPduOnDestruction( bool onOff );

   virtual inline void forceUpdate();

   virtual void setRelPosThreshold( double val );
   virtual double relPosThreshold() const;

   virtual void setAbsPosThreshold( double val );
   virtual double absPosThreshold() const;

   virtual void setAccelThreshold( double val );
   virtual double accelThreshold() const;

   static inline void setDfltRelPosThreshold( double val );
   static inline double dfltRelPosThreshold();

   static inline void setDfltAbsPosThreshold( double val );
   static inline double dfltAbsPosThreshold();

   static inline void setDfltAccelThreshold( double val );
   static inline double dfltAccelThreshold();

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

   static void setClassDfltTimeThreshold(DtTime threshold);

protected:

   void init( const DtObjectId& );

   void sendFinalPdu();

private:

   DtDesignatorPublisher( const DtDesignatorPublisher& );

   DtDesignatorPublisher& operator = ( const DtDesignatorPublisher& );

protected:

   static DtStateRepCreator theStateRepCreator;

   static double theDfltRelPosThreshold;
   static double theDfltAbsPosThreshold;
   static double theDfltAccelThreshold;
   static DtTime theClassDfltTimeThreshold;
   static bool theClassDfltIsSetFlag;

   DtDesignatorDecoder* myDecoder;
   DtDesignatorEncoder* myEncoder;
   bool mySendFinalInDtor;

};


inline DtDesignatorRepository* DtDesignatorPublisher::designatorStateRep()
{
   return dsr();
}

inline DtDesignatorRepository* DtDesignatorPublisher::dsr()
{
   return static_cast<DtDesignatorRepository*>(myStateRep);
}

inline void DtDesignatorPublisher::forceUpdate()
{
   myEncoder->setSendNeeded();
}

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

inline void DtDesignatorPublisher::setDfltRelPosThreshold( double val )
{
   theDfltRelPosThreshold = val;
}

inline double DtDesignatorPublisher::dfltRelPosThreshold()
{
   return theDfltRelPosThreshold;
}

inline void DtDesignatorPublisher::setDfltAbsPosThreshold( double val )
{
   theDfltAbsPosThreshold = val;
}

inline double DtDesignatorPublisher::dfltAbsPosThreshold()
{
   return theDfltAbsPosThreshold;
}

inline void DtDesignatorPublisher::setDfltAccelThreshold( double val )
{
   theDfltAccelThreshold = val;
}

inline double DtDesignatorPublisher::dfltAccelThreshold()
{
   return theDfltAccelThreshold;
}

#endif // DtDIS