rtiMsg.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1998 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: rtiMsg.h,v $ $Revision: 1.109 $ $State: Exp $
*********************************************************************/


#ifndef DtRtiMsg_H_
#define DtRtiMsg_H_

#include <memory>
#include "netRtiMsgHdr.h"
#include <vlutil/vlBaseMsg.h>
#include "internalTypes.h"
#include <vlutil/vlString.h>
#include "rtiMsgKind.h"

#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
#include <RTI/Handle.h>
#include <RTI/Typedefs.h>
#include <RTI/LogicalTime.h>
#include <RTI/LogicalTimeInterval.h>
#else
#ifdef DtIFSPEC13DLC
#include "RTI13.h"
#define RTI rti13
#else
#include "RTI.hh"
#endif
#endif

#include "bitMask.h"

class DtLogicalTimeFactory;

#define MSG_STATUS_OK     0
#define MSG_STATUS_NOT_OK 1 


class DT_DLL_LRC DtRtiMsg : public MAKRti::DtBaseMsg
{
public:

   virtual ~DtRtiMsg();

   virtual DtRtiMsg* clone(bool copy          = true) const         =0; 

   virtual DtRtiMsg* cloneWithTransport(bool copy          = true) const; 

   virtual DtNetMsgHeader* netHeader() const;

   virtual int version() const;

   virtual bool isValidVersion() const;

 
   virtual void setFedEx(const MAKRti::DtString& name);

   virtual void setFedEx(int handle);   
   
   virtual bool isForExec(const MAKRti::DtString& execName, int execHandle) const;




   virtual const MAKRti::DtString fedExName() const;
   virtual int fedExHandle() const;


   virtual void setFederateHandle(DtFederateHandle handle);
   virtual DtFederateHandle federateHandle() const;


   virtual void setSequenceNumber(unsigned long value);
   virtual unsigned long sequenceNumber() const;


   virtual void setServiceCallNumber(unsigned long value);
   virtual unsigned long serviceCallNumber() const;


   virtual void setTriggerMessageNumber(unsigned long value);
   virtual unsigned long triggerMessageNumber() const;

   virtual DtRtiMsgKind msgKind() const;

   virtual const char* kindString() const;

   virtual bool isConstrained() const;

   virtual bool isAllowedDuringSave() const;

#ifdef DtIFSPEC1516
   virtual void setTime(const rti1516::LogicalTime& time);
   virtual rti1516::LogicalTime const * time(
      DtLogicalTimeFactory* fedTimeFactory) const;
#elif defined(DtIFSPEC1516E)
   virtual void setTime(const rti1516e::LogicalTime& time);
   virtual rti1516e::LogicalTime const * time(
       DtLogicalTimeFactory* fedTimeFactory) const;
#else
   virtual void setTime(const RTI::FedTime& time);
   virtual RTI::FedTime const * time(
      DtLogicalTimeFactory* fedTimeFactory) const;
#endif

   virtual bool hasTime() const;

   virtual void setSerialNumber(unsigned long serialNumberValue);
   virtual unsigned long serialNumber() const;

   virtual void setTransportType(DtTransportHandle type);
   virtual DtTransportHandle transportType() const;

   virtual DtOrderHandle orderType() const;

   virtual bool isMetadataPresent() const;

   virtual bool addMetadata( caddr_t* mtdAddr, unsigned int size, 
                  unsigned int* alignPad, unsigned int* headerPad          = NULL );

   virtual void removeMetadata( unsigned int size );

   bool isInteractionMsgType() const;
   bool isUpdateMsgType() const;



   virtual void print(DtLogicalTimeFactory* logicalTimeFactory) const; 
   virtual void printHeader(DtLogicalTimeFactory* logicalTimeFactory) const;
   virtual void printData(DtLogicalTimeFactory* logicalTimeFactory) const;

#ifdef DtIFSPEC1516
   virtual void printTime(const char* label,
      rti1516::LogicalTime const * timeValue) const;

   virtual void printInterval(const char* label,
      rti1516::LogicalTimeInterval const* intervalValue) const;
#elif defined(DtIFSPEC1516E)
   virtual void printTime(const char* label,
       rti1516e::LogicalTime const * timeValue) const;

   virtual void printInterval(const char* label,
       rti1516e::LogicalTimeInterval const* intervalValue) const;
#else
   virtual void printTime(const char* label,
      RTI::FedTime const * timeValue) const;

   virtual void printInterval(const char* label,
      RTI::FedTime const* intervalValue) const;
#endif

   virtual int status() const;

public:

   static inline const DtNetMsgHeader* netHeader(const void *buffer);

   static const char* kindToString(DtRtiMsgKind kind);

   static const char* kindString(const void *buffer);

   static unsigned long totalSize(const void* buffer);

   static const DtRtiMsgKind msgKind(const void *buffer);

   static unsigned int version(const void* buffer);

   static unsigned int fedExHandle(const void* buffer);

   static DtFederateHandle federateHandle(const void* buffer);

   static unsigned long sequenceNumber(const void* buffer);

   static unsigned char flags(const void* buffer);

   static unsigned long metadataSize(const void* buffer);

   static void setDefaultRegionSet(unsigned long defaultRegionSet);

   static void setUse32BitsForValueSize(bool use32BitsForValueSizeEnabled);
   static bool use32BitsForValueSize();

   static void setSmartForwardingEnabled( bool enabled );
   static bool smartForwardingEnabled();
  
public:
   static unsigned long theDefaultRegionSetHandle;
#ifdef DtIFSPEC1516
   static const rti1516::VariableLengthData theDefaultTag;
#elif defined(DtIFSPEC1516E)
   static const rti1516e::VariableLengthData theDefaultTag;
#else
   static const char* theDefaultTag;
#endif

protected:

   DtRtiMsg();

   virtual DtRtiMsgKind internalDtRtiMsgKind()          = 0;
   
   virtual void sizeChanged(int size);

   void initDtRtiMsg(int size, DtRtiMsgKind msgKindVal, DtBufferPtr buffer);
   void initDtRtiMsg(const void *initial, int size, DtBufferPtr buffer);
   void initDtRtiMsg(const DtNetMsgHeader *header, DtBufferPtr buffer);

   virtual void adjustBytes(int offset, int numBytes);

   virtual void adjustBytes(void *address, int numBytes);

protected:

   DtTransportHandle myTransportType;
   DtOrderHandle myOrderType;
#ifdef DtIFSPEC1516
   rti1516::LogicalTime* myFedTime;
#elif defined(DtIFSPEC1516E)
   rti1516e::LogicalTime* myFedTime;
#else
   RTI::FedTime * myFedTime;
#endif
   bool myTimeIsValid;
   bool myConstrained;
   bool myAllowedDuringSave;   
   unsigned long mySerialNumber;
   unsigned long myServiceCallNumber;
   unsigned long myTriggerMessage;

protected:

   static bool theUse32BitsForValueSize;

   static bool theSmartForwardingEnabled;
};

inline DtNetMsgHeader* DtRtiMsg::netHeader() const
{
   return (DtNetMsgHeader*) netRep();
}

inline const DtNetMsgHeader* DtRtiMsg::netHeader(const void *buffer)
{
   return reinterpret_cast<const DtNetMsgHeader*>(buffer);
}

inline DtRtiMsgKind DtRtiMsg::msgKind() const
{
   return DtRtiMsgKind((DtU32) (DtU8) netHeader()->msgKind);
}

inline int DtRtiMsg::status() const
{
   return MSG_STATUS_OK;
}

inline DtFederateHandle DtRtiMsg::federateHandle() const
{
   return (DtFederateHandle) (DtU16) netHeader()->fedHandle;
}


inline void DtRtiMsg::adjustBytes(int offset, int numBytes)
{
   if (numBytes > 0)
      insertBytes(offset, numBytes);
   else
   if (numBytes < 0)
      deleteBytes(offset, -numBytes);
}

inline void DtRtiMsg::adjustBytes(void *address, int numBytes)
{
   if (numBytes > 0)
      insertBytes(address, numBytes);
   else
   if (numBytes < 0)
      deleteBytes(address, -numBytes);
}

#endif