pdu.h

Go to the documentation of this file.

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




#include <stdlib.h>
#include "packets/pduHeader.h"
#include <vlpi/disEnums.h>
#include <vlutil/vlTimeStampType.h>
#include <vlutil/vlBaseMsg.h>


#define DtPDU_STATUS_BIT_SHIFT(attr, val) \
   const unsigned int DtPduStatus##attr##BitShift = val;

DtPDU_STATUS_BIT_SHIFT(TransferredEntityIndicator, 0);
DtPDU_STATUS_BIT_SHIFT(LVCIndicator, 1);
DtPDU_STATUS_BIT_SHIFT(CoupledExtensionIndicator, 3);
DtPDU_STATUS_BIT_SHIFT(FireTypeIndicator, 4);
DtPDU_STATUS_BIT_SHIFT(DetonationTypeIndicator, 4);
DtPDU_STATUS_BIT_SHIFT(RadioAttachedIndicator, 4);
DtPDU_STATUS_BIT_SHIFT(IntercomAttachedIndicator, 4);
DtPDU_STATUS_BIT_SHIFT(IFFSimulationMode, 4);
DtPDU_STATUS_BIT_SHIFT(ActiveInterrogationIndicator, 5);

#define DtPDU_STATUS_UNSET_INDICATOR_ONE_BIT(attr) \
   val &= ~(0x1 << DtPduStatus##attr##BitShift)

#define DtPDU_STATUS_SET_INDICATOR_ONE_BIT(attr, indicator) \
   DtPDU_STATUS_UNSET_INDICATOR_ONE_BIT(attr); \
   val |= DtPduStatus##attr##indicator << DtPduStatus##attr##BitShift

#define DtPDU_STATUS_GET_BOOL_ONE_BIT(attr) \
   (((val >> DtPduStatus##attr##BitShift) & 0x1) == 0x1)

#define DtPDU_STATUS_GET_ENUM_ONE_BIT(attr) \
   DtPduStatus##attr((val >> DtPduStatus##attr##BitShift) & 0x1)

#define DtPDU_STATUS_SET_INDICATOR_TWO_BIT(attr, indicator) \
   DtPDU_STATUS_UNSET_INDICATOR_TWO_BIT(attr); \
   val |= indicator << DtPduStatus##attr##BitShift

#define DtPDU_STATUS_UNSET_INDICATOR_TWO_BIT(attr) \
   val &= ~(0x3 << DtPduStatus##attr##BitShift)

#define DtPDU_STATUS_GET_ENUM_TWO_BIT(attr) \
   DtPduStatus##attr((val >> DtPduStatus##attr##BitShift) & 0x3)

#define DtSTATUS_OK     0
#define DtSTATUS_NOT_OK 1 

extern DT_DLL_VL int DtProtocolVersionToSend;
extern DT_DLL_VL int DtProtocolVersionToRecvMin;
extern DT_DLL_VL int DtProtocolVersionToRecvMax;

class DtPduEncoder;
class DtPduDecoder;
class DtPduFactory;

class DT_DLL_VL DtPdu : public DtBaseMsg
{
public:

   virtual ~DtPdu();

   DtPdu(const DtPdu &pdu, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

   DtPdu &operator=(const DtPdu &pdu);


   virtual void* packet() const; 
   
   virtual int status() const;

   virtual void setVersion(int vers);
   virtual int protocolVersion() const;
 
   virtual void setExerciseId(int id);
   virtual int exerciseId() const;

   virtual DtPduKind kind() const;

   virtual DtProtocolFamily protocolFamily() const;
   
   virtual void setTimeStamp(DtTime time, 
      DtTimeStampType type = DtTimeStampRelative);
   
   virtual DtTime timeStamp() const;    

   virtual DtTimeStampType timeStampType() const;

   virtual void setPduLength(unsigned int length);

   virtual unsigned int pduLength() const;

   virtual void setPduStatus(int);

   virtual int pduStatus() const;

   virtual void setTransferredEntityIndicator(bool difference);
   virtual bool transferredEntityIndicator() const;

   virtual void setLvcIndicator(DtPduStatusLVCIndicator lvcIndicator);
   virtual DtPduStatusLVCIndicator lvcIndicator() const;

   virtual void setCoupledExtensionIndicator(bool coupled);
   virtual bool coupledExtensionIndicator() const;

   virtual void setFireTypeIndicator(DtPduStatusFireTypeIndicator fireTypeIndicator);
   virtual DtPduStatusFireTypeIndicator fireTypeIndicator() const;

   virtual void setDetonationTypeIndicator(DtPduStatusDetonationTypeIndicator detonationTypeIndicator);
   virtual DtPduStatusDetonationTypeIndicator detonationTypeIndicator() const;

   virtual void setRadioAttachedIndicator(DtPduStatusRadioAttachedIndicator radioAttachedIndicator);
   virtual DtPduStatusRadioAttachedIndicator radioAttachedIndicator() const;

   virtual void setIntercomAttachedIndicator(DtPduStatusIntercomAttachedIndicator intercomAttachedIndicator);
   virtual DtPduStatusIntercomAttachedIndicator intercomAttachedIndicator() const;

   virtual void setIffSimulationMode(bool interactive);
   virtual bool iffSimulationMode() const;

   virtual void setActiveInterrogationIndicator(bool active);
   virtual bool activeInterrogationIndicator() const;

   virtual DtTime guessTimeValid(DtTime referenceTime) const;

   virtual DtNetPduHeader* netHeader() const;

   virtual void print() const; 

   virtual void printToStream(std::ostream& stream) const;

   virtual void printHeader() const;

   virtual void printHeaderToStream(std::ostream& stream) const;

   
   virtual void printData() const;
   virtual void printDataToStream(std::ostream& stream) const;
   virtual void printDataToString(DtString& str) const;

   virtual void printPduInHexToStream(std::ostream& stream, unsigned int numberOfColumns) const;

   virtual void encode();

   virtual void decode(DtPduFactory* pduFactory);

   virtual bool isTransientPdu() const;

protected:

   DtPdu();

   virtual void setStatus(int okStatus);

   virtual void initPdu(int size, DtBufferPtr buffer);

   virtual void initPdu(const void* initial, DtBufferPtr buffer, DtPduFactory* pduFactory);

   virtual DtPduKind internalGetPduKind() const = 0;

   virtual DtProtocolFamily kindToFamily(DtPduKind kind) const;

   virtual void sizeChanged(int size);

   virtual void clearData();

   virtual void initHeader(DtPduKind kind, int size);

   virtual bool isTEIApplicable() const;
   virtual bool isLVCApplicable() const;
   virtual bool isCEIApplicable() const;
   virtual bool isFTIApplicable() const;
   virtual bool isDTIApplicable() const;
   virtual bool isRAIApplicable() const;
   virtual bool isIAIApplicable() const;
   virtual bool isISMApplicable() const;
   virtual bool isAIIApplicable() const;

protected:

   DtPduEncoder* myEncoder;
   DtPduDecoder* myDecoder;
   int myOKStatus;
};

#define netPdu packet()

inline DtNetPduHeader* DtPdu::netHeader() const
{
   return (DtNetPduHeader*) netRep();
}
 
inline void* DtPdu::packet() const
{
   return (void*) netRep();
}

inline int DtPdu::protocolVersion() const 
{
   return netHeader()->version;
}

inline int DtPdu::exerciseId() const 
{
   return netHeader()->DtExercise;
}

inline DtPduKind DtPdu::kind() const 
{   return DtPduKind(netHeader()->DtKind);
}

inline DtProtocolFamily DtPdu::protocolFamily() const 
{
   return DtProtocolFamily(netHeader()->family);
}

inline DtTime DtPdu::timeStamp() const
{
   return netHeader()->DtTime.time();
}

inline DtTimeStampType DtPdu::timeStampType() const
{
   return netHeader()->DtTime.type();
}

inline void DtPdu::setExerciseId(int id)
{
   netHeader()->DtExercise = id;
}

inline void DtPdu::setTimeStamp(DtTime time, DtTimeStampType relOrAbs)
{
   netHeader()->DtTime = DtNetTimeStamp(time, relOrAbs);
}


inline void DtPdu::setPduLength(unsigned int length)
{
   netHeader()->DtLength = length;
}

inline unsigned int DtPdu::pduLength() const
{
   return netHeader()->DtLength;
}


inline int DtPdu::pduStatus() const
{
   return netHeader()->pduStatus;
}

inline void DtPdu::setPduStatus(int pduStatus)
{
   netHeader()->pduStatus = pduStatus;
}

inline int DtPdu::status() const
{
   return myOKStatus;
}

inline void DtPdu::setStatus(int okStatus)
{
   myOKStatus = okStatus;
}

inline void DtPdu::setVersion(int vers)
{
   netHeader()->version = (unsigned char) (DtU32) vers;
}