interactionDecoder.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*********************************************************************/


#ifndef DtInteractionDecoder_H_
#define DtInteractionDecoder_H_

#if DtHLA 

#include <vl/interactionWithEncDec.h>
#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlPrint.h>
#include <vlpi/bufferMgr.h>

#include "rtiNamespace.h"
#include "rtiCompatibility.h"
#include <map>

class DT_DLL_VL DtExerciseConn;
class DT_DLL_VL DtInterClassDesc;
class DT_DLL_VL DtNetEventId;

class DT_DLL_VL DtInteractionRep;


class DT_DLL_VL DtInteractionDecoder
{
public:

   typedef void (*DtParameterDecoder)(DtInteractionRep* inter,
      const RTI::ParameterHandleValuePairSet& pvlist,
      int i);

public:

   DtInteractionDecoder(DtExerciseConn* exConn,
      DtInterClassDesc* classDesc);

   virtual ~DtInteractionDecoder();

   DtParameterDecoder addDecoder(RTI::ParameterHandle handle,
      DtParameterDecoder proc);

   DtParameterDecoder addDecoder(char* name,
      DtParameterDecoder proc);

   virtual DtParameterDecoder decoder(RTI::ParameterHandle handle) const;

   virtual void decode(
      DtInteractionRep* interaction,
#if DtHLA_1516
      const RTI::ParameterHandleValueMap& pvMap
#else
      const RTI::ParameterHandleValuePairSet& pvList
#endif
      );

   virtual RTI::InteractionClassHandle interactionClassHandle();

   virtual DtInteractionDecoder* clone() const;

   virtual DtInteractionDecoder* clone(DtInterClassDesc* interDesc) const;

public:

   static char* decodingBuffer(int length);

   static char* parameterData(const RTI::ParameterHandleValuePairSet& pvList,
      int index, RTI::ULong& length);

   static char* parameterData(
      const RTI::ParameterHandleValuePairSet& pvList, int index, RTI::ULong& length,
      unsigned int expectedDataSize, char* paramName);

   static DtNetEventId* eventIdParameterData(
      const RTI::ParameterHandleValuePairSet& params, int index);

   static bool theUseGetValuePointer;

   static void decodeGenericParameter(DtInteractionWithEncDec* inter,
      const RTI::ParameterHandleValuePairSet& pvlist, int i);
 

protected:

   DtInteractionDecoder(const DtInteractionDecoder& orig);

   DtInteractionDecoder& operator=(const DtInteractionDecoder& orig);

   virtual void decodeParameter(DtInteractionRep* inter,
      const RTI::ParameterHandleValuePairSet& pvList, int index);

protected:

   DtExerciseConn* myExConn;
   DtInterClassDesc* myClassDesc;

   RTI::InteractionClassHandle myClassHandle;

   std::map<RTI::ParameterHandle, DtParameterDecoder> myList;

};

inline RTI::InteractionClassHandle 
   DtInteractionDecoder::interactionClassHandle() 
{
   return myClassHandle;
}

inline char* DtInteractionDecoder::decodingBuffer(int length)
{
   return DtDecodingBuffer(length);
}

inline char* DtInteractionDecoder::parameterData(
   const RTI::ParameterHandleValuePairSet& pvList, int index, RTI::ULong& length)
{
   char* dataPtr = 0;
   if (theUseGetValuePointer)
   {
      dataPtr = pvList.getValuePointer(index, length);
   }
   else
   {
      length = pvList.getValueLength(index);
      if (length > 0)
      {
         dataPtr = decodingBuffer(length);
         pvList.getValue(index, dataPtr, length);
      }
   }
   return dataPtr;
}

inline char* DtInteractionDecoder::parameterData(
   const RTI::ParameterHandleValuePairSet& pvList, int index, RTI::ULong& length,
   unsigned int expectedDataSize, char* paramName)
{
   char* outDataPtr = 0;
   if (theUseGetValuePointer)
   {
      outDataPtr = pvList.getValuePointer(index, length);
   }
   else
   {
      length = pvList.getValueLength(index);
      if (length > 0 && length >= expectedDataSize)
      {
         outDataPtr = decodingBuffer(length);
         pvList.getValue(index, outDataPtr, length);
      }
   }

   if (length != expectedDataSize)
   {
      if (length < expectedDataSize)
      {
         DtWarn("Cannot decode parameter %s.\n"
            "Size of data (%d) is smaller than expected (%d).\n",
            paramName, length, expectedDataSize);
         length = 0;
         outDataPtr = 0;
      }
      else if (length > expectedDataSize && DtNotifyLevel >= DtNlVerbose)
      {
         DtVerbose("When decoding parameter %s,\n"
            "found size of data (%d) is larger than expected (%d).\n",
            paramName, length, expectedDataSize);
      }
   }

   return outDataPtr;
}

inline DtNetEventId* DtInteractionDecoder::eventIdParameterData(
   const RTI::ParameterHandleValuePairSet& params, int index)
{
   RTI::ULong length = 0;
   char* dataPtr = 0;
   length = params.getValueLength(index);
   if (length > 0)
   {
      dataPtr = decodingBuffer(length+1);
      params.getValue(index, dataPtr, length);
      dataPtr[length] = 0;
   }

   return (DtNetEventId*)dataPtr;
}

#define DtADD_PARAM_DECODER(paramName) \
   addDecoder((char *)#paramName, (DtParameterDecoder) decode##paramName)

#define DtDECLARE_PARAM_DECODER(RepT, paramName) \
   static void decode##paramName(RepT* inter, \
      const RTI::ParameterHandleValuePairSet& params, int pairSetIndex)

#define DtDEFINE_SIMPLE_PARAM_DECODER_WITH_CAST(decClass, interClass, \
   paramName, netType, mutator, castExpr) \
void decClass::decode##paramName(interClass* inter, \
   const RTI::ParameterHandleValuePairSet& params, \
   int index) \
{ \
   RTI::ULong length = 0; \
   netType* netValPtr = (netType*)parameterData(params, index, length, sizeof(netType), #paramName); \
   if (netValPtr) \
   { \
      inter->mutator(castExpr *netValPtr); \
   } \
}

#define DtDEFINE_SIMPLE_PARAM_DECODER_WITH_CAST_SET(decClass, interClass, \
   paramName, netType, castExpr) \
   DtDEFINE_SIMPLE_PARAM_DECODER_WITH_CAST(decClass, interClass, \
      paramName, netType, set##paramName, castExpr)

#define DtDEFINE_SIMPLE_PARAM_DECODER_MUTATOR(decClass, interClass, \
   paramName, netType, mutator) \
   void decClass::decode##paramName(interClass* inter, \
   const RTI::ParameterHandleValuePairSet& params, \
   int index) \
{ \
   RTI::ULong length = 0; \
   netType* netValPtr = (netType*)parameterData(params, index, length, sizeof(netType), #paramName); \
   if (netValPtr) \
   { \
      inter->mutator(*netValPtr); \
   } \
}

#define DtDEFINE_SIMPLE_PARAM_DECODER_MUTATOR_SET(decClass, interClass, \
   paramName, netType) \
   DtDEFINE_SIMPLE_PARAM_DECODER_MUTATOR(decClass, interClass, \
      paramName, netType, set##paramName)

#define DtDEFINE_SIMPLE_GLOBAL_OBJECT_DESIGNATOR_PARAM_DECODER( \
   decClass, interClass, paramName, mutator) \
void decClass::decode##paramName(interClass* inter, \
   const RTI::ParameterHandleValuePairSet& params, \
   int index) \
{ \
   RTI::ULong length = 0; \
   DtGlobalObjectDesignator objName = (char*) params.getValuePointer(index, length); \
   inter->mutator(objName); \
}

#define DtDEFINE_SIMPLE_PARAM_DECODER_BUFF(decClass, interClass, \
   paramName, mutator) \
void decClass::decode##paramName(interClass* inter, \
   const RTI::ParameterHandleValuePairSet& params, \
   int index) \
{ \
   RTI::ULong length = 0; \
   char* buff = parameterData(params, index, length); \
   if (length > 0) \
   { \
      inter->mutator(buff, length); \
   } \
}

#define DtDEFINE_SIMPLE_PARAM_DECODER(decClass, interClass, \
   paramName, netType, mutator) \
   DtDEFINE_SIMPLE_PARAM_DECODER_MUTATOR(decClass, interClass, \
      paramName, netType, mutator)

#endif
#endif