rtiTemplateMsg.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2011 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/


#ifndef DtRtiTemplateMsg_H_
#define DtRtiTemplateMsg_H_


#include "rtiMsg.h"
#include "connectMgr.h"
#include <rtiutil/rtiTemplateMsgParams.h>
#include <vector>

class DtRtiBaseMsgParam;
class DtNetMsgHeaderParam;

class DT_DLL_LRC DtRtiTemplateMsg : public DtRtiMsg
{
public:

   virtual ~DtRtiTemplateMsg();

   unsigned addParameter(DtRtiBaseMsgParam* param);

   virtual void printData(DtLogicalTimeFactory* logicalTimeFactory) const;

protected:

   DtRtiTemplateMsg(DtRtiMsgKind msgKind);
   
   virtual DtRtiMsgKind internalDtRtiMsgKind();

   virtual int minSize() const;

   friend class DtNetMsgHeaderParam;

protected:

   DtNetMsgHeaderParam* myHeaderParam;

   std::vector<DtRtiBaseMsgParam*> myMsgParams;

   DtRtiMsgKind myMsgKind;

   int myMinSize;

};


class DtNetMsgHeaderParam : public DtRtiBaseMsgParam
{
public:

   static const char* headerName()
   {
      static const char theName[] = "Header";
      return theName;
   }

   DtNetMsgHeaderParam(DtRtiTemplateMsg* msg) 
      : DtRtiBaseMsgParam(headerName())
      , myMsg(msg) {}
   ~DtNetMsgHeaderParam() {}

   void* endPtr() { return myMsg->netHeader() + 1; }
   const void* endPtr() const { return myMsg->netHeader() + 1; };

   unsigned minSize() { return sizeof(DtNetMsgHeader); }

   unsigned elementSize() { return sizeof(DtNetMsgHeader); }

   void print() const {}

   void setOctetBoundary(unsigned prevBoundary)
   {
      myOctetBoundary = minSize() % 8;
   }

protected:
   DtNetMsgHeaderParam(const DtNetMsgHeaderParam&);

   DtRtiTemplateMsg* myMsg;
};


// This macro will automatically declare all of the methods necessary to
// create a standard RTI message with the exception of the set and get
// functions for the individual parameters.
#define DtDECLARE_STANDARD_MSG_METHODS(ClassName)                  \
   public:                                                         \
   typedef void (*ClassName##Cb)(const ClassName& msg, void* usr); \
   ClassName(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);          \
   ClassName(const DtNetMsgHeader* netHeader,                      \
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);                 \
   virtual ~ClassName();                                           \
   void addAllParameters();                                        \
   virtual DtRtiMsg* clone(bool copy = true) const;                \
   static DtRtiMsg* create(const DtNetMsgHeader* initial,          \
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);                 \
   static DtRtiMsg* create(                                        \
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);                 \
   static void addCallback(DtConnectionMgr* conn,                  \
      ClassName##Cb cb, void* usr);                                \
   static void removeCallback(DtConnectionMgr* conn,               \
      ClassName##Cb cb, void* usr);                                \
   protected:                                                      \
   ClassName* self() const /* Casts away const-ness */             \
      { return const_cast<ClassName*>( this ); }

// This macro will automatically define most of the methods declared by
// DtDECLARE_STANDARD_MSG_METHODS, with the exception of addAllParameters().
#define DtDEFINE_STANDARD_MSG_METHODS(ClassName)                   \
   ClassName::ClassName(DtBufferPtr buffer)                        \
      : DtRtiTemplateMsg(ClassName##Kind)                          \
   {                                                               \
      addAllParameters();                                          \
      initDtRtiMsg(minSize(), internalDtRtiMsgKind(), buffer);     \
   }                                                               \
   ClassName::ClassName(const DtNetMsgHeader* netHdr,              \
                        DtBufferPtr buffer)                        \
      : DtRtiTemplateMsg(ClassName##Kind)                          \
   {                                                               \
      addAllParameters();                                          \
      initDtRtiMsg(netHdr, buffer);                                \
   }                                                               \
   ClassName::~ClassName() {}                                      \
   DtRtiMsg* ClassName::clone(bool copy) const                     \
   {                                                               \
      if (copy)                                                    \
      {                                                            \
         return new ClassName(this->netHeader());                  \
      }                                                            \
      else                                                         \
      {                                                            \
         return new ClassName();                                   \
      }                                                            \
   }                                                               \
   DtRtiMsg* ClassName::create(DtBufferPtr buffer)                 \
   {                                                               \
      return new ClassName(buffer);                                \
   }                                                               \
   DtRtiMsg* ClassName::create(const DtNetMsgHeader* initial,      \
                               DtBufferPtr buffer)                 \
   {                                                               \
      return new ClassName(initial, buffer);                       \
   }                                                               \
   void ClassName::addCallback(DtConnectionMgr* conn,              \
                               ClassName##Cb cb, void* usr)        \
   {                                                               \
      conn->addMsgCallback(ClassName##Kind,                        \
         (DtRtiMsgCbMgr::DtCallbackFcn) cb, usr);                  \
   }                                                               \
   void ClassName::removeCallback(DtConnectionMgr* conn,           \
                                  ClassName##Cb cb, void* usr)     \
   {                                                               \
      conn->removeMsgCallback(ClassName##Kind,                     \
         (DtRtiMsgCbMgr::DtCallbackFcn) cb, usr);                  \
   }




#endif