hlaStateDecoder.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2010 MAK Technologies, Inc
** All rights reserved.
*********************************************************************/


#ifndef DtHlaStateDecoder_H_
#define DtHlaStateDecoder_H_

#if DtHLA 


#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlPrint.h>
#include <vlutil/vlUuid.h>
#include <vlpi/bufferMgr.h>
#include "rtiNamespace.h"
#include "rtiCompatibility.h"
#include <map>
#include <vector>

class DT_DLL_VL DtExerciseConn;
class DT_DLL_VL DtObjClassDesc;
class DT_DLL_VL DtStateRepository;
class DT_DLL_VL DtStateMsg;
class DT_DLL_VL DtNetEventId;


class DT_DLL_VL DtHlaStateDecoder
{
public:

   DtHlaStateDecoder(
      DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtHlaStateDecoder();

   DtHlaStateDecoder(const DtHlaStateDecoder& orig);

   DtHlaStateDecoder& operator=(const DtHlaStateDecoder& orig);

   typedef void (*DtAttributeDecoder) (
      DtStateRepository* stateRep,
      const RTI::AttributeHandleValuePairSet& avlist,
      unsigned long pairSetIndex);

   DtAttributeDecoder addDecoder(RTI::AttributeHandle h,
                                 DtAttributeDecoder func);
   DtAttributeDecoder removeDecoder(RTI::AttributeHandle h);

   DtAttributeDecoder addDecoder(char* attrName,
      DtAttributeDecoder func, bool complain = true);
   DtAttributeDecoder removeDecoder(char* attrName, bool complain = true);

   virtual DtAttributeDecoder decoder(const RTI::AttributeHandle &handle) const;

   virtual void decode(const DtStateMsg& msg,
      DtStateRepository* stateRep) const ;

   virtual RTI::ObjectClassHandle objectClassHandle() const;

   virtual DtHlaStateDecoder* clone() const;

   virtual DtHlaStateDecoder* clone(DtObjClassDesc* classDesc) const;

public:

   static inline char* decodingBuffer(int length);

   static char* attributeData(const RTI::AttributeHandleValuePairSet& attrs,
      int index, RTI::ULong& length);

   static char* attributeData(
      const RTI::AttributeHandleValuePairSet& attrs, int index, RTI::ULong& length,
      unsigned int expectedDataSize, char* attrName);

   static DtNetEventId* eventIdAttributeData(const RTI::AttributeHandleValuePairSet& attrs,
      int index);

   static bool theUseGetValuePointer;

   static std::wstring wideStringFromHlaUnicodeString(char* buffer, int size, bool* error = nullptr);

   static bool getVectorFromArrayOfUuid(char* buffer, int size, std::vector< DtVrlUuid >& uuids);

protected:

   virtual void decodeAttribute(
      DtStateRepository* stateRep,
      const RTI::AttributeHandleValuePairSet& attrs,
      unsigned long pairSetIndex) const;

   virtual void copyDecFuncs( const DtHlaStateDecoder& orig);
protected:

   typedef std::map<RTI::AttributeHandle, DtAttributeDecoder> AttributeHandleDecoderMap;
   typedef std::map<RTI::AttributeHandle, bool> AttributeHandleBoolMap;

protected:

   DtExerciseConn* myExConn;
   DtObjClassDesc* myClassDesc;
   RTI::ObjectClassHandle myHandle;


   AttributeHandleDecoderMap myDecoderList;

private:

   mutable AttributeHandleBoolMap myMutableReportedWarning;

};

inline RTI::ObjectClassHandle DtHlaStateDecoder::objectClassHandle() const
{
   return myHandle;
}

inline DtHlaStateDecoder::DtAttributeDecoder 
DtHlaStateDecoder::decoder(const RTI::AttributeHandle &handle) const
{
   AttributeHandleDecoderMap::const_iterator pos = myDecoderList.find(handle);
   if (pos != myDecoderList.end()) 
   {
      return pos->second;
   }
   return 0;
};

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

inline char* DtHlaStateDecoder::attributeData(
   const RTI::AttributeHandleValuePairSet& attrs, int index, RTI::ULong& length)
{
   char* dataPtr = 0;
   if (theUseGetValuePointer)
   {
      dataPtr = attrs.getValuePointer(index, length);
   }
   else
   {
      length = attrs.getValueLength(index);
      if (length > 0)
      {
         dataPtr = decodingBuffer(length);
         attrs.getValue(index, dataPtr, length);
      }
   }
   return dataPtr;
}

inline char* DtHlaStateDecoder::attributeData(
   const RTI::AttributeHandleValuePairSet& attrs, int index, RTI::ULong& length,
   unsigned int expectedDataSize, char* attrName)
{
   char* outDataPtr = 0;
   if (theUseGetValuePointer)
   {
      outDataPtr = attrs.getValuePointer(index, length);
   }
   else
   {
      length = attrs.getValueLength(index);
      if (length > 0 && length >= expectedDataSize)
      {
         outDataPtr = decodingBuffer(length);
         attrs.getValue(index, outDataPtr, length);
      }
   }

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

   return outDataPtr;
}

inline DtNetEventId* DtHlaStateDecoder::eventIdAttributeData(
   const RTI::AttributeHandleValuePairSet& attrs, int index)
{
   RTI::ULong length = 0;
   char* dataPtr = 0;
   length = attrs.getValueLength(index);
   if (length > 0)
   {
      dataPtr = decodingBuffer(length+1);
      attrs.getValue(index, dataPtr, length);
      dataPtr[length] = 0;
   }

   return (DtNetEventId*)dataPtr;
}

#define DtADD_ATTR_DECODER(attrName) \
   addDecoder((char *)#attrName, (DtAttributeDecoder) decode##attrName);

#define DtADD_ATTR_DECODER_QUIET(attrName) \
   addDecoder((char *)#attrName, (DtAttributeDecoder) decode##attrName, false);


#define DtDECLARE_ATTR_DECODER(stateRepClass, attrName) \
   static void decode##attrName(stateRepClass* stateRep, \
      const RTI::AttributeHandleValuePairSet& attrs, int pairSetIndex)


#define DtDEFINE_SIMPLE_ATTR_DECODER_WITH_CAST( \
   decClass, stateRepClass, attrName, netType, mutator, castExpr) \
void decClass::decode##attrName( \
   stateRepClass* stateRep, \
   const RTI::AttributeHandleValuePairSet& attrs, \
   int index) \
{ \
   RTI::ULong length = 0; \
   netType* netValPtr = (netType*)attributeData(attrs, index, length, sizeof(netType), #attrName); \
   if (netValPtr) \
   { \
      stateRep->mutator(castExpr *netValPtr); \
   } \
}

#define DtDEFINE_SIMPLE_ATTR_DECODER_WITH_CAST_SET( \
   decClass, stateRepClass, attrName, netType, castExpr) \
   DtDEFINE_SIMPLE_ATTR_DECODER_WITH_CAST( \
      decClass, stateRepClass, attrName, netType, set##attrName, castExpr)

#define DtDEFINE_SIMPLE_ATTR_DECODER_MUTATOR( \
   decClass, stateRepClass, attrName, netType, mutator) \
void decClass::decode##attrName( \
   stateRepClass* stateRep, \
   const RTI::AttributeHandleValuePairSet& attrs, \
   int index) \
{ \
   RTI::ULong length = 0; \
   netType* netValPtr = (netType*)attributeData(attrs, index, length, sizeof(netType), #attrName); \
   if (netValPtr) \
   { \
      stateRep->mutator(*netValPtr); \
   } \
}

#define DtDEFINE_SIMPLE_ATTR_DECODER_SET( \
   decClass, stateRepClass, attrName, netType) \
   DtDEFINE_SIMPLE_ATTR_DECODER_MUTATOR( \
   decClass, stateRepClass, attrName, netType, set##attrName)

#define DtDEFINE_SIMPLE_ATTR_DECODER_WITH_CAST_AND_PARAM( \
   decClass, stateRepClass, attrName, netType, mutator, param, castExpr) \
void decClass::decode##attrName( \
   stateRepClass* stateRep, \
   const RTI::AttributeHandleValuePairSet& attrs, \
   int index) \
{ \
   RTI::ULong length = 0; \
   netType* netValPtr = (netType*)attributeData(attrs, index, length, sizeof(netType), #attrName); \
   if (netValPtr) \
   { \
      stateRep->mutator(param, castExpr *netValPtr); \
   } \
}

#define DtDEFINE_SIMPLE_GLOBAL_OBJECT_DESIGNATOR_ATTR_DECODER( \
   decClass, stateRepClass, attrName, mutator) \
void decClass::decode##attrName( \
   stateRepClass* stateRep, \
   const RTI::AttributeHandleValuePairSet& attrs, \
   int pairSetIndex) \
{ \
   RTI::ULong length = 0; \
   DtGlobalObjectDesignator objName = (char*) attrs.getValuePointer(pairSetIndex, length); \
   stateRep->mutator(objName); \
}

#define DtDEFINE_SIMPLE_ATTR_DECODER_BUFF(decClass, stateRepClass, \
   attrName, mutator) \
void decClass::decode##attrName( \
   stateRepClass* stateRep, \
   const RTI::AttributeHandleValuePairSet& attrs, \
   int index) \
{ \
   RTI::ULong length = 0; \
   char* buff = attributeData(attrs, index, length); \
   if (length > 0) \
   { \
      stateRep->mutator(buff, length); \
   } \
}

#define DtDEFINE_SIMPLE_ATTR_DECODER( \
   decClass, stateRepClass, attrName, netType, mutator) \
   DtDEFINE_SIMPLE_ATTR_DECODER_MUTATOR(decClass, stateRepClass, \
      attrName, netType, mutator)

#endif
#endif