assistantTemplateMsg.h

Go to the documentation of this file.

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


#ifndef DtAssistantTemplateMsg_H_
#define DtAssistantTemplateMsg_H_


#include "assistantMsg.h"
#include <rtiutil/rtiTemplateMsgParams.h>
#include <vector>

class DtRtiBaseMsgParam;
class DtNetAssistantMsgHeaderParam;

class DT_DLL_ASSISTANT DtAssistantTemplateMsg : public DtAssistantMsg
{
public:

   virtual ~DtAssistantTemplateMsg();

   unsigned addParameter(DtRtiBaseMsgParam* param);

   virtual void printData() const;

protected:

   DtAssistantTemplateMsg(DtAssistantMsgKind msgKind);
   
   virtual DtAssistantMsgKind internalMsgKind();

   virtual int minSize() const;

   friend class DtNetAssistantMsgHeaderParam;

protected:

   DtNetAssistantMsgHeaderParam* myHeaderParam;

   std::vector<DtRtiBaseMsgParam*> myMsgParams;

   DtAssistantMsgKind myMsgKind;

   int myMinSize;

};


class DtNetAssistantMsgHeaderParam : public DtRtiBaseMsgParam
{
public:

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

   DtNetAssistantMsgHeaderParam(DtAssistantTemplateMsg* msg) 
      : DtRtiBaseMsgParam(headerName())
      , myMsg(msg) {}
   ~DtNetAssistantMsgHeaderParam() {}

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

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

   unsigned elementSize() { return sizeof(MAKRti::DtNetU128); }

   void print() const {}

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

protected:
   DtNetAssistantMsgHeaderParam(const DtNetAssistantMsgHeaderParam&);

   DtAssistantTemplateMsg* myMsg;
};


// This macro will automatically declare all of the methods necessary to
// create a standard Assistant message with the exception of callback
// addition & removal functions and parameter accessors.
#define DtASTNT_DECLARE_STANDARD_MSG_METHODS(ClassName)            \
   public:                                                         \
   typedef void (*ClassName##Cb)(const ClassName& msg, void* usr); \
   ClassName(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);          \
   ClassName(const DtNetAssistantMsgHeader* netHeader,             \
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);                 \
   virtual ~ClassName();                                           \
   void addAllParameters();                                        \
   virtual DtAssistantMsg* clone(bool copy = true) const;          \
   static DtAssistantMsg* create(const DtNetAssistantMsgHeader* initial, \
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);                 \
   static DtAssistantMsg* create(                                  \
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);                 \
   protected:                                                      \
   ClassName* self() const /* Casts away const-ness */             \
      { return const_cast<ClassName*>( this ); }

// This macro will automatically declare the methods for adding
// and removing callbacks for receipt of this message from a
// DtRtiAssistantPeer.
#define DtASTNT_DECLARE_PEER_CALLBACK_METHODS(ClassName)           \
   public:                                                         \
   static void addCallback(DtRtiAssistantPeer* peer,               \
      ClassName##Cb cb, void* usr);                                \
   static void removeCallback(DtRtiAssistantPeer* peer,            \
      ClassName##Cb cb, void* usr);

// This macro will automatically declare the methods for adding
// and removing callbacks for receipt of this message from a
// DtRtiAssistantServer.
#define DtASTNT_DECLARE_SERVER_CALLBACK_METHODS(ClassName)         \
   public:                                                         \
   static void addCallback(DtRtiAssistantServer* srvr,             \
      ClassName##Cb cb, void* usr);                                \
   static void removeCallback(DtRtiAssistantServer* srvr,          \
     ClassName##Cb cb, void* usr);

// This macro will automatically declare the methods for adding
// and removing callbacks for receipt of this message from a
// DtRtiAssistantClient.
#define DtASTNT_DECLARE_CLIENT_CALLBACK_METHODS(ClassName)         \
   public:                                                         \
   static void addCallback(DtRtiAssistantClient* client,           \
      ClassName##Cb cb, void* usr);                                \
   static void removeCallback(DtRtiAssistantClient* client,        \
      ClassName##Cb cb, void* usr);

// This macro will automatically declare the methods for adding
// and removing callbacks for receipt of this message from a
// DtAssistantMsgQueue.
#define DtASTNT_DECLARE_QUEUE_CALLBACK_METHODS(ClassName)          \
   public:                                                         \
   static void addCallback(DtAssistantMsgQueue* qu,                \
      ClassName##Cb cb, void* usr);                                \
   static void removeCallback(DtAssistantMsgQueue* qu,             \
      ClassName##Cb cb, void* usr);

// This macro will automatically define most of the methods declared by
// DtASTNT_DECLARE_STANDARD_MSG_METHODS, with the exception of addAllParameters().
#define DtASTNT_DEFINE_STANDARD_MSG_METHODS(ClassName)             \
   ClassName::ClassName(DtBufferPtr buffer)                        \
      : DtAssistantTemplateMsg(ClassName##Kind)                    \
   {                                                               \
      addAllParameters();                                          \
      initAssistantMsg(minSize(), internalMsgKind(), buffer);      \
   }                                                               \
   ClassName::ClassName(const DtNetAssistantMsgHeader* netHdr,     \
                        DtBufferPtr buffer)                        \
      : DtAssistantTemplateMsg(ClassName##Kind)                    \
   {                                                               \
      addAllParameters();                                          \
      initAssistantMsg(netHdr, buffer);                            \
   }                                                               \
   ClassName::~ClassName() {}                                      \
   DtAssistantMsg* ClassName::clone(bool copy) const               \
   {                                                               \
      if (copy)                                                    \
      {                                                            \
         return new ClassName(this->netHeader());                  \
      }                                                            \
      else                                                         \
      {                                                            \
         return new ClassName();                                   \
      }                                                            \
   }                                                               \
   DtAssistantMsg* ClassName::create(DtBufferPtr buffer)           \
   {                                                               \
      return new ClassName(buffer);                                \
   }                                                               \
   DtAssistantMsg* ClassName::create(const DtNetAssistantMsgHeader* initial,\
                                     DtBufferPtr buffer)           \
   {                                                               \
      return new ClassName(initial, buffer);                       \
   }

// This macro will automatically define the methods declared by
// DtASTNT_DECLARE_PEER_CALLBACK_METHODS.
#define DtASTNT_DEFINE_PEER_CALLBACK_METHODS(ClassName)            \
   void ClassName::addCallback(DtRtiAssistantPeer* conn,           \
                               ClassName##Cb cb, void* usr)        \
   {                                                               \
      conn->addMsgCallback(ClassName##Kind,                        \
         (DtAssistantMsgCbMgr::DtCallbackFcn) cb, usr);            \
   }                                                               \
   void ClassName::removeCallback(DtRtiAssistantPeer* conn,        \
                                  ClassName##Cb cb, void* usr)     \
   {                                                               \
      conn->removeMsgCallback(ClassName##Kind,                     \
         (DtAssistantMsgCbMgr::DtCallbackFcn) cb, usr);            \
   }

// This macro will automatically define the methods declared by
// DtASTNT_DECLARE_SERVER_CALLBACK_METHODS.
#define DtASTNT_DEFINE_SERVER_CALLBACK_METHODS(ClassName)          \
   void ClassName::addCallback(DtRtiAssistantServer* conn,         \
                               ClassName##Cb cb, void* usr)        \
   {                                                               \
      conn->addMsgCallback(ClassName##Kind,                        \
         (DtAssistantMsgCbMgr::DtCallbackFcn) cb, usr);            \
   }                                                               \
   void ClassName::removeCallback(DtRtiAssistantServer* conn,      \
                                  ClassName##Cb cb, void* usr)     \
   {                                                               \
      conn->removeMsgCallback(ClassName##Kind,                     \
         (DtAssistantMsgCbMgr::DtCallbackFcn) cb, usr);            \
   }

// This macro will automatically define the methods declared by
// DtASTNT_DECLARE_CLIENT_CALLBACK_METHODS.
#define DtASTNT_DEFINE_CLIENT_CALLBACK_METHODS(ClassName)          \
   void ClassName::addCallback(DtRtiAssistantClient* conn,         \
                               ClassName##Cb cb, void* usr)        \
   {                                                               \
      conn->addMsgCallback(ClassName##Kind,                        \
         (DtAssistantMsgCbMgr::DtCallbackFcn) cb, usr);            \
   }                                                               \
   void ClassName::removeCallback(DtRtiAssistantClient* conn,      \
                                  ClassName##Cb cb, void* usr)     \
   {                                                               \
      conn->removeMsgCallback(ClassName##Kind,                     \
         (DtAssistantMsgCbMgr::DtCallbackFcn) cb, usr);            \
   }

// This macro will automatically define the methods declared by
// DtASTNT_DECLARE_QUEUE_CALLBACK_METHODS.
#define DtASTNT_DEFINE_QUEUE_CALLBACK_METHODS(ClassName)           \
   void ClassName::addCallback(DtAssistantMsgQueue* conn,          \
                               ClassName##Cb cb, void* usr)        \
   {                                                               \
      conn->addMsgCallback(ClassName##Kind,                        \
         (DtAssistantMsgCbMgr::DtCallbackFcn) cb, usr);            \
   }                                                               \
   void ClassName::removeCallback(DtAssistantMsgQueue* conn,       \
                                  ClassName##Cb cb, void* usr)     \
   {                                                               \
      conn->removeMsgCallback(ClassName##Kind,                     \
         (DtAssistantMsgCbMgr::DtCallbackFcn) cb, usr);            \
   }




#endif