rtiTemplateMsgParams.h

Go to the documentation of this file.

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


#ifndef DtRtiTemplateMsgParams_H_
#define DtRtiTemplateMsgParams_H_

//#include "rtiTemplateMsg.h"
#include <vlutil/vlNetTypes.h>
#include <vlutil/vlPrint.h>
#include <assert.h>

class DtRtiBaseMsgParam
{
public:
   ~DtRtiBaseMsgParam() {}

   void setPrevParam(DtRtiBaseMsgParam* prevParam) {
      myPrevParam = prevParam;
      setOctetBoundary(prevParam->octetBoundary()); }

   virtual void* endPtr() = 0;
   virtual const void* endPtr() const = 0;

   void* beginPtr() {
      void* p = myPrevParam->endPtr();
      //DtWarn << std::hex << p << std::dec << std::endl;
      return p; }
   const void* beginPtr() const { 
      const void* p = myPrevParam->endPtr();
      //DtWarn << std::hex << p << std::dec << std::endl;
      return p; }

   virtual unsigned minSize() = 0;

   virtual void print() const = 0;

   virtual const char* name() const { return myName; }

   unsigned octetBoundary() const { return myOctetBoundary; }

   virtual void setOctetBoundary(unsigned prevBoundary) = 0;

   virtual unsigned elementSize() = 0;

protected:
   DtRtiBaseMsgParam(const char* paramName) 
      : myPrevParam(0),
      myOctetBoundary(0),
      myName(paramName) {}

   DtRtiBaseMsgParam* myPrevParam;

   unsigned myOctetBoundary;

   const char* myName;
};

template<typename ParamType, typename NetParamType>
class DtRtiMsgParam : public DtRtiBaseMsgParam
{
public:
   DtRtiMsgParam(const char* paramName) : DtRtiBaseMsgParam(paramName) {}
   ~DtRtiMsgParam() {}

   void setParam(ParamType val)
   {
      NetParamType* ptr = paramPtr();
      *ptr = val;
   }

   void setParamRef(const ParamType& val)
   {
      NetParamType* ptr = paramPtr();
      *ptr = val;
   }

   ParamType param() const
   {
      return static_cast<ParamType>(*paramPtr());
   }

   void getParam(ParamType& val) const
   {
      val = static_cast<ParamType>(*paramPtr());
   }

   void* endPtr()
   {
      return (reinterpret_cast<char*>(paramPtr()) + sizeof(NetParamType));
   }
   
   const void* endPtr() const
   {
      return (reinterpret_cast<const char*>(paramPtr()) + sizeof(NetParamType));
   }

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

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

   void print() const
   {
      MAKRti::DtVerbose << name() << ": " << param() << std::endl;
   }
   
   void setOctetBoundary(unsigned prevBoundary)
   {
      myOctetBoundary = (prevBoundary + minSize()) % 8;

      // Check that our message is assembled properly
      assert(prevBoundary == 0 || (prevBoundary % minSize()) == 0);
   }

protected:
   DtRtiMsgParam(const DtRtiMsgParam&);

   NetParamType* paramPtr() { return reinterpret_cast<NetParamType*>(beginPtr()); }
   const NetParamType* paramPtr() const { return reinterpret_cast<const NetParamType*>(beginPtr()); }

};



// PARAMETER DECLARATION MACROS
// These macros declare parameters and their accessor methods within a message.
// In your class definition, simply use one of the type-specific macros
// below (e.g. DtDECLARE_UNSIGNED_PARAMETER_METHODS, 
// DtDECLARE_BOOL_PARAMETER_METHODS, etc.)

// Declares the generic set and get methods for a parameter. Should not be used
// directly. Use one of the more type specific versions below, which will also
// define the parameter itself.
// ParamName = the name of the parameter
// ParamType = the input type of the set and the return type of the get
#define DtDECLARE_PARAMETER_METHODS(ParamName, ParamType)                     \
   public:                                                                    \
   static const char* ParamName##Name;                                        \
   void set##ParamName(ParamType val);                                        \
   ParamType get##ParamName() const;

// Declares the generic set and get methods for a parameter which is passed by
// reference. Should not be used directly. Use one of the more type specific 
// versions below, which will also define the parameter itself.
// ParamName = the name of the parameter
// ParamType = the input type of the set and the return type of the get
#define DtDECLARE_BY_REF_PARAMETER_METHODS(ParamName, ParamType)              \
   public:                                                                    \
   static const char* ParamName##Name;                                        \
   void set##ParamName(const ParamType& val);                                 \
   ParamType get##ParamName() const;                                          \
   void get##ParamName(ParamType& val) const;

// Defines a new unsigned integer parameter in a message and declares its
// get and set methods.
// ParamName = the name of the parameter
// BitSize   = the storage size in the message (in bits, obviously)
#define DtDECLARE_UNSIGNED_PARAMETER_METHODS(ParamName, BitSize)              \
   DtDECLARE_PARAMETER_METHODS(ParamName, MAKRti::DtU##BitSize)               \
   protected:                                                                 \
   typedef DtRtiMsgParam<MAKRti::DtU##BitSize, MAKRti::DtNetU##BitSize> ParamName##Type; \
   ParamName##Type* my##ParamName;

// Defines a new boolean parameter in a message and declares its
// get and set methods. Bool parameters will be stored as 8 bit
// unsigned integers.
// ParamName = the name of the parameter
#define DtDECLARE_BOOL_PARAMETER_METHODS(ParamName)                           \
   DtDECLARE_PARAMETER_METHODS(ParamName, bool)                               \
   protected:                                                                 \
   typedef DtRtiMsgParam<MAKRti::DtU8, MAKRti::DtNetU8> ParamName##Type;      \
   ParamName##Type* my##ParamName;

// Defines a new integer parameter in a message and declares its
// get and set methods.
// ParamName = the name of the parameter
// BitSize   = the storage size in the message (in bits, obviously)
#define DtDECLARE_INT_PARAMETER_METHODS(ParamName, BitSize)                   \
   DtDECLARE_PARAMETER_METHODS(ParamName, MAKRti::DtInt##BitSize)             \
   protected:                                                                 \
   typedef DtRtiMsgParam<MAKRti::DtInt##BitSize, MAKRti::DtNetInt##BitSize> ParamName##Type; \
   ParamName##Type* my##ParamName;

// Defines a new enumeration parameter in a message and declares its
// get and set methods.
// ParamName = the name of the parameter
// EnumType  = the type of the enumeration for the input to set and the return of get
// BitSize   = the storage size in the message (in bits, obviously)
#define DtDECLARE_ENUMERATION_PARAMETER_METHODS(ParamName, EnumType, BitSize) \
   DtDECLARE_PARAMETER_METHODS(ParamName, EnumType)                           \
   protected:                                                                 \
   typedef DtRtiMsgParam<MAKRti::DtU##BitSize, MAKRti::DtNetU##BitSize> ParamName##Type; \
   ParamName##Type* my##ParamName;

// Defines a new float parameter in a message and declares its
// get and set methods.
// ParamName = the name of the parameter
// BitSize   = the storage size in the message (in bits, obviously)
#define DtDECLARE_FLOAT_PARAMETER_METHODS(ParamName, BitSize)                   \
   DtDECLARE_PARAMETER_METHODS(ParamName, MAKRti::DtFloat##BitSize)             \
   protected:                                                                 \
   typedef DtRtiMsgParam<MAKRti::DtFloat##BitSize, MAKRti::DtNetFloat##BitSize> ParamName##Type; \
   ParamName##Type* my##ParamName;




// PARAMETER DEFINITION MACROS
// These macros define the accessor methods for a message parameter.
// In your .cxx file, simply use one of the type-specific macros
// below (e.g. DtDEFINE_UNSIGNED_PARAMETER_METHODS, 
// DtDEFINE_BOOL_PARAMETER_METHODS, etc.). The macro should match the
// type used in the DtDECLARE macro in your class definition.

// Defines the set and get methods for a general parameter. Should not be used
// directly. Use one of the more type specific versions below.
// ClassName = the name of the message class
// ParamName = the name of the parameter
// ParamType = the input type of the set and the return type of the get
#define DtDEFINE_PARAMETER_METHODS(ClassName, ParamName, ParamType)           \
   const char* ClassName::ParamName##Name = #ParamName;                       \
   void ClassName::set##ParamName(ParamType val)                              \
   {                                                                          \
      my##ParamName->setParam(val);                                           \
   }                                                                          \
   ParamType ClassName::get##ParamName() const                                \
   {                                                                          \
      return static_cast<ParamType>(my##ParamName->param());                  \
   }

// Defines the generic set and get methods for a parameter which is passed by
// reference. Should not be used directly. Use one of the more type specific 
// versions below.
// ClassName = the name of the message class
// ParamName = the name of the parameter
// ParamType = the input type of the set and the return type of the get
#define DtDEFINE_BY_REF_PARAMETER_METHODS(ClassName, ParamName, ParamType)    \
   const char* ClassName::ParamName##Name = #ParamName;                       \
   void ClassName::set##ParamName(const ParamType& val)                       \
   {                                                                          \
      my##ParamName->setParamRef(val);                                        \
   }                                                                          \
   ParamType ClassName::get##ParamName() const                                \
   {                                                                          \
      return my##ParamName->param();                                          \
   }                                                                          \
   void ClassName::get##ParamName(ParamType& val) const                       \
   {                                                                          \
      my##ParamName->getParam(val);                                           \
   }

// Defines the set and get methods for parameters which are to be stored as
// an unsigned integer of some size.
// ClassName = the name of the message class
// ParamName = the name of the parameter
// BitSize   = the storage size in the message (in bits, obviously)
#define DtDEFINE_UNSIGNED_PARAMETER_METHODS(ClassName, ParamName, BitSize)    \
   DtDEFINE_PARAMETER_METHODS(ClassName, ParamName, DtU##BitSize)

// Defines the set and get methods for parameters which are to be stored as
// a bool.
// ClassName = the name of the message class
// ParamName = the name of the parameter
#define DtDEFINE_BOOL_PARAMETER_METHODS(ClassName, ParamName)                 \
   DtDEFINE_PARAMETER_METHODS(ClassName, ParamName, bool)

// Defines the set and get methods for parameters which are to be stored as
// an integer of some size.
// ClassName = the name of the message class
// ParamName = the name of the parameter
// BitSize   = the storage size in the message (in bits, obviously)
#define DtDEFINE_INT_PARAMETER_METHODS(ClassName, ParamName, BitSize)         \
   DtDEFINE_PARAMETER_METHODS(ClassName, ParamName, DtInt##BitSize)

// Defines the set and get methods for parameters which are to be stored as
// an enumeration.
// ClassName = the name of the message class
// ParamName = the name of the parameter
// EnumType  = the type of the enumeration for the input to set and the return of get
#define DtDEFINE_ENUMERATION_PARAMETER_METHODS(ClassName, ParamName, EnumType)\
   DtDEFINE_PARAMETER_METHODS(ClassName, ParamName, EnumType)

// Defines the set and get methods for parameters which are to be stored as
// a floats of some size.
// ClassName = the name of the message class
// ParamName = the name of the parameter
// BitSize   = the storage size in the message (in bits, obviously)
#define DtDEFINE_FLOAT_PARAMETER_METHODS(ClassName, ParamName, BitSize)         \
   DtDEFINE_PARAMETER_METHODS(ClassName, ParamName, DtFloat##BitSize)


// PARAMETER ADDITION MACROS
// These macros should be used within the addAllParameters() function of your
// new message class. The order parameters are added matters! You must order
// them in a way to ensure proper alignment. If you don't, the parameter
// classes will try to help you out by asserting in debug builds.

// Adds a basic parameter to the message.
// ParamName = the name of the parameter
#define DtADD_PARAMETER(ParamName) \
   addParameter(my##ParamName = new ParamName##Type(ParamName##Name));

#endif