hStateDecoder.h

Go to the documentation of this file.

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


#ifndef DtHlaStateDecoder_H_
#define DtHlaStateDecoder_H_

#if DtHLA 


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

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


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);

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);
}

#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 pairSetIndex) \
{ \
   RTI::ULong length = attrs.getValueLength(pairSetIndex); \
   netType netVal; \
   if (length > sizeof(netType)) \
   { \
      DtWarn("Size of value decoded from RTI update for attribute %s (%d)\n", \
         #attrName, length); \
      DtWarn(" is larger than size of %s (%d)\n", #netType, sizeof(netType)); \
      return; \
   } \
   attrs.getValue(pairSetIndex, (char*) &netVal, length); \
   stateRep->mutator(castExpr netVal); \
}

#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( \
   decClass, stateRepClass, attrName, netType, mutator) \
   DtDEFINE_SIMPLE_ATTR_DECODER_WITH_CAST(decClass, stateRepClass, \
      attrName, netType, mutator, (netType))

#endif
#endif