rtiTemplateMsgInetAddrParams.h

Go to the documentation of this file.

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


#ifndef DtRtiTemplateMsgInetAddrParams_H_
#define DtRtiTemplateMsgInetAddrParams_H_

#include "rtiTemplateMsgParams.h"
#include "rtiTemplateMsgArrayParams.h"
#include <vlutil/vlInetAddr.h>
#include <assert.h>


template<>
class DtRtiMsgParam<MAKRti::DtInetAddr, MAKRti::DtNetU128> : public DtRtiBaseMsgParam
{
public:
   DtRtiMsgParam(const char* paramName,
      DtRtiMsgParam<MAKRti::DtU32, MAKRti::DtNetU32>* familyParam)
      : DtRtiBaseMsgParam(paramName)
      , myFamilyParam(familyParam) {}
   ~DtRtiMsgParam() {}

   void setParamRef(const MAKRti::DtInetAddr& addr)
   {
      MAKRti::DtNetU128* ptr = paramPtr();
      *ptr = addr.toU128();
      myFamilyParam->setParam(addr.family());
   }

   MAKRti::DtInetAddr param() const
   {
      const MAKRti::DtNetU128* ptr = paramPtr();
      return MAKRti::DtInetAddr(*ptr,
         MAKRti::DtInetUtils::DtInetAddrFamily(
         static_cast<MAKRti::DtU32>(myFamilyParam->param())));
   }

   void getParam(MAKRti::DtInetAddr& addr) const
   {
      const MAKRti::DtNetU128* ptr = paramPtr();
      addr = MAKRti::DtInetAddr(*ptr,
         MAKRti::DtInetUtils::DtInetAddrFamily(
         static_cast<MAKRti::DtU32>(myFamilyParam->param())));
   }

   void* endPtr()
   {
      return (reinterpret_cast<char*>(paramPtr()) + sizeof(MAKRti::DtNetU128));
   }

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

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

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

   void print() const
   {
      MAKRti::DtVerbose << name() << ": " << param().toDtString() << std::endl;
   }

   void setOctetBoundary(unsigned prevBoundary)
   {
      myOctetBoundary = 0;

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

protected:
   DtRtiMsgParam(const DtRtiMsgParam&);

   MAKRti::DtNetU128* paramPtr() { return reinterpret_cast<MAKRti::DtNetU128*>(beginPtr()); }
   const MAKRti::DtNetU128* paramPtr() const { return reinterpret_cast<const MAKRti::DtNetU128*>(beginPtr()); }

protected:

   DtRtiMsgParam<MAKRti::DtU32, MAKRti::DtNetU32>* myFamilyParam;

};


template<typename AllocatedMsgParamType>
class DtRtiArrayMsgParam<MAKRti::DtInetAddr, MAKRti::DtU128, MAKRti::DtNetU128, AllocatedMsgParamType> : public DtRtiBaseMsgParam
{
public:
   DtRtiArrayMsgParam(const char* paramName, 
      AllocatedMsgParamType* allocatedNumParam, DtRtiMsgParam<MAKRti::DtU32,
      MAKRti::DtNetU32>* familyParam) 
      : DtRtiBaseMsgParam(paramName)
      , myAllocatedNumParam(allocatedNumParam)
      , myFamilyParam(familyParam) 
      , myNumUsed(0)
      , myMutableNextParamIndex(0){}
   ~DtRtiArrayMsgParam() {}

   bool addParam(const MAKRti::DtInetAddr& addr)
   {
      bool result = false;
      if(myNumUsed+1 <= numItems())
      {
         result = true;

         MAKRti::DtNetU128* ptr = paramPtr() + myNumUsed;
         *ptr = addr.toU128();
         ++myNumUsed;
      }

      return result;
   }

   bool setParams(const MAKRti::DtInetAddr* addrs, unsigned num)
   {
      bool result = false;
      if(num <= numItems())
      {
         result = true;

         MAKRti::DtNetU128* ptr = paramPtr();
         myNumUsed = num;

         for(unsigned i = 0; i < num; ++i)
         {
            if(i == 0)
            {
               myFamilyParam->setParam(static_cast<MAKRti::DtU32>(addrs[i].family()));
            }
            ptr[i] = addrs[i].toU128();
         }
      }

      return result;
   }

   template <typename ParamContainerType>
   bool setParams(const ParamContainerType& container)
   {
      bool result = false;
      if(container.size() <= numItems())
      {
         result = true;

         MAKRti::DtNetU128* ptr = paramPtr();
         myNumUsed = container.size();

         typename ParamContainerType::const_iterator iter = container.begin();
         typename ParamContainerType::const_iterator iterEnd = container.end();
         for(unsigned i = 0; iter != iterEnd; ++iter, ++i)
         {
            if(i == 0)
            {
               myFamilyParam->setParam(static_cast<MAKRti::DtU32>(iter->family()));
            }
            ptr[i] = iter->toU128();
         }
      }

      return result;
   }           

   template <typename ParamContainerType>
   void getParams(ParamContainerType& container) const
   {
      unsigned count = numItems();
      const MAKRti::DtNetU128* ptr = paramPtr();
      DtInetUtils::DtInetAddrFamily family =
         DtInetUtils::DtInetAddrFamily(static_cast<DtU32>(myFamilyParam->param()));
      for(unsigned i = 0; i < count; ++i)
      {
         container.insert(container.end(), MAKRti::DtInetAddr(ptr[i], family));
      }
   }

   unsigned getParams(MAKRti::DtInetAddr* buff) const
   {
      unsigned count = numItems();
      const MAKRti::DtNetU128* ptr = paramPtr();
      DtInetUtils::DtInetAddrFamily family =
         DtInetUtils::DtInetAddrFamily(static_cast<MAKRti::DtU32>(myFamilyParam->param()));
      for(unsigned i = 0; i < count; ++i)
      {
         buff[i] = MAKRti::DtInetAddr(ptr[i], family);
      }

      return count;
   }

   bool getFirstParam(MAKRti::DtInetAddr& addr) const
   {
      bool itemExists = numItems() > 0;
      if(itemExists)
      {
         const MAKRti::DtNetU128* ptr = paramPtr();
         addr = MAKRti::DtInetAddr(ptr[0],
            DtInetUtils::DtInetAddrFamily(static_cast<MAKRti::DtU32>(myFamilyParam->param())));
         myMutableNextParamIndex = 1;
      }
      return itemExists;
   }

   bool getNextParam(MAKRti::DtInetAddr& addr) const
   {
      bool itemExists = numItems() > myMutableNextParamIndex;
      if(itemExists)
      {
         const MAKRti::DtNetU128* ptr = paramPtr();
         addr = MAKRti::DtInetAddr(ptr[myMutableNextParamIndex++],
            DtInetUtils::DtInetAddrFamily(static_cast<MAKRti::DtU32>(myFamilyParam->param())));
      }
      return itemExists;
   }

   void* endPtr()
   {
      return (paramPtr() + myAllocatedNumParam->param());
   }
   
   const void* endPtr() const
   {
      return (paramPtr() + myAllocatedNumParam->param());
   }

   unsigned minSize() { return 0; }

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

   unsigned numItems() const { return myAllocatedNumParam->param(); }

   void setNumItems(unsigned num) { myAllocatedNumParam->setParam(num); }

   void print() const
   {
      MAKRti::DtVerbose << name() << ": " << std::endl;
      MAKRti::DtInetAddr addr;
      if(getFirstParam(addr))
      {
         MAKRti::DtVerbose << "   " << addr.toDtString() << std::endl;
         while(getNextParam(addr))
         {
            MAKRti::DtVerbose << "   " << addr.toDtString() << std::endl;
         }
      }
      else
      {
         MAKRti::DtVerbose << "   Empty" << std::endl;
      }
   }

   void setOctetBoundary(unsigned prevBoundary)
   {
      myOctetBoundary = 0;

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

protected:

   MAKRti::DtNetU128* paramPtr() { return reinterpret_cast<MAKRti::DtNetU128*>(beginPtr()); }
   const MAKRti::DtNetU128* paramPtr() const { return reinterpret_cast<const MAKRti::DtNetU128*>(beginPtr()); }

protected:

   DtRtiArrayMsgParam(const DtRtiArrayMsgParam&);

   AllocatedMsgParamType* myAllocatedNumParam;

   DtRtiMsgParam<MAKRti::DtU32, MAKRti::DtNetU32>* myFamilyParam;

   unsigned myNumUsed;

   mutable unsigned myMutableNextParamIndex;

};



// PARAMETER DECLARATION MACROS
// These macros declare parameters and their accessor methods within a message.
// In your class definition, simply use one of the macros below. All DtInetAddr
// parameters will require the definition of a separate parameter which stores
// 32 bit unsigned integer which represents the address family (IPv4 or IPv6).
// DtInetAddr array parameters also require another parameter to store the size
// of the array. Arrays are expected to contain address of the same family.

// Defines a new DtInetAddr message parameter and declares its get and set
// methods.
// ParamName = the name of the parameter
#define DtDECLARE_INET_ADDR_PARAMETER_METHODS(ParamName)                      \
   DtDECLARE_BY_REF_PARAMETER_METHODS(ParamName, MAKRti::DtInetAddr)          \
   protected:                                                                 \
   typedef DtRtiMsgParam<MAKRti::DtInetAddr, MAKRti::DtNetU128> ParamName##Type; \
   ParamName##Type* my##ParamName;

// Defines a message parameter which is an array of DtInetAddrs declares
// its get and set methods.
// ParamName    = the name of the parameter
// CountBitSize = the number of bits in the parameter that holds the item count
#define DtDECLARE_INET_ADDR_ARRAY_PARAMETER_METHODS(ParamName, CountBitSize)  \
   DtDECLARE_ARRAY_PARAMETER_METHODS(ParamName, MAKRti::DtInetAddr)           \
   protected:                                                                 \
   typedef DtRtiArrayMsgParam<MAKRti::DtInetAddr, MAKRti::DtU128, MAKRti::DtNetU128, \
      DtRtiMsgParam<MAKRti::DtU##CountBitSize, MAKRti::DtNetU##CountBitSize> > 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 macros below. The macro should
// match the type used in the DtDECLARE macro in your class definition.

// Defines the set and get methods for DtInetAddr parameters.
// ClassName = the name of the message class
// ParamName = the name of the parameter
#define DtDEFINE_INET_ADDR_PARAMETER_METHODS(ClassName, ParamName)            \
   DtDEFINE_BY_REF_PARAMETER_METHODS(ClassName, ParamName, MAKRti::DtInetAddr)

// Defines the set and get methods which take a standard container type for
// input and output for DtInetAddr array parameters. Should not be used
// directly. Use DtDEFINE_INET_ADDR_ARRAY_PARAMETER_METHODS instead.
// ClassName = the name of the message class
// ClassName = the name of the message class
// ParamName = the name of the parameter
// CtrType   = the type of a container to be accepted as input/output (e.g. set)
#define DtDEFINE_INET_ADDR_ARRAY_PARAMETER_CONTAINER_METHODS(ClassName, ParamName, CtrType)\
   void ClassName::set##ParamName(const CtrType& container,                   \
      DtResizeArrayFlag resizeFlag)                                           \
   {                                                                          \
      unsigned currNum = my##ParamName->numItems();                           \
      if(resizeFlag == DtResizeIfNeeded && container.size() != currNum)       \
      {                                                                       \
         unsigned currSize = currNum * sizeof(MAKRti::DtNetU128);             \
         unsigned newSize = container.size() * sizeof(MAKRti::DtNetU128);     \
         char* begPtr = static_cast<char*>(my##ParamName->beginPtr());        \
         if(newSize > currSize)                                               \
         {                                                                    \
            insertBytes(begPtr + currSize, newSize - currSize);               \
         }                                                                    \
         else if(currSize > newSize)                                          \
         {                                                                    \
            deleteBytes(begPtr + newSize, currSize - newSize);                \
         }                                                                    \
         my##ParamName->setNumItems(container.size());                        \
      }                                                                       \
      my##ParamName->setParams(container);                                    \
   }                                                                          \
   void ClassName::get##ParamName(CtrType& container) const                   \
   {                                                                          \
      my##ParamName->getParams(container);                                    \
   } 

// Defines the set and get methods for parameters which are an array of
// DtInetAddrs.
// ClassName = the name of the message class
// ParamName = the name of the parameter
#define DtDEFINE_INET_ADDR_ARRAY_PARAMETER_METHODS(ClassName, ParamName)      \
   const char* ClassName::ParamName##Name = #ParamName;                       \
   DtDEFINE_INET_ADDR_ARRAY_PARAMETER_CONTAINER_METHODS(ClassName, ParamName, std::set<MAKRti::DtInetAddr>) \
   DtDEFINE_INET_ADDR_ARRAY_PARAMETER_CONTAINER_METHODS(ClassName, ParamName, std::vector<MAKRti::DtInetAddr>) \
   DtDEFINE_INET_ADDR_ARRAY_PARAMETER_CONTAINER_METHODS(ClassName, ParamName, std::list<MAKRti::DtInetAddr>) \
   DtDEFINE_INET_ADDR_ARRAY_PARAMETER_CONTAINER_METHODS(ClassName, ParamName, std::deque<MAKRti::DtInetAddr>) \
   void ClassName::set##ParamName(const MAKRti::DtInetAddr* buff,             \
      unsigned num, DtResizeArrayFlag resizeFlag)                             \
   {                                                                          \
      unsigned currNum = my##ParamName->numItems();                           \
      if(resizeFlag == DtResizeIfNeeded && num != currNum)                    \
      {                                                                       \
         unsigned currSize = currNum * sizeof(MAKRti::DtNetU128);             \
         unsigned newSize = num * sizeof(MAKRti::DtNetU128);                  \
         char* begPtr = static_cast<char*>(my##ParamName->beginPtr());        \
         if(newSize > currSize)                                               \
         {                                                                    \
            insertBytes(begPtr + currSize, newSize - currSize);               \
         }                                                                    \
         else if(currSize > newSize)                                          \
         {                                                                    \
            deleteBytes(begPtr + newSize, currSize - newSize);                \
         }                                                                    \
         my##ParamName->setNumItems(num);                                     \
      }                                                                       \
      my##ParamName->setParams(buff, num);                                    \
   }                                                                          \
   unsigned ClassName::get##ParamName(MAKRti::DtInetAddr* buff) const         \
   {                                                                          \
      return my##ParamName->getParams(buff);                                  \
   }




// 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 an IP address parameter to the message.
// ParamName = the name of the parameter
// FamilyParamName = the name of the parameter which stores the address family
#define DtADD_INET_ADDR_PARAMETER(ParamName, FamilyParamName) \
   addParameter(my##ParamName = new ParamName##Type(ParamName##Name, my##FamilyParamName));

// Adds an IP address array parameter to the message.
// ParamName = the name of the parameter
// SizeParamName = the name of the parameter which stores the number of items
// FamilyParamName = the name of the parameter which stores the address family
#define DtADD_INET_ADDR_ARRAY_PARAMETER(ParamName, SizeParamName, FamilyParamName) \
   addParameter(my##ParamName = new ParamName##Type(ParamName##Name, my##SizeParamName, my##FamilyParamName));

#endif