hlaStateEncoder.h

Go to the documentation of this file.

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


#ifndef DtHlaStateEncoder_H_
#define DtHlaStateEncoder_H_

#if DtHLA 


#include <vlutil/vlMachineTypes.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 DtHlaStateEncoder
{
public:

   DtHlaStateEncoder( DtExerciseConn* exConn,
      DtObjClassDesc* classDesc);

   virtual ~DtHlaStateEncoder();

   DtHlaStateEncoder(const DtHlaStateEncoder& orig);

   DtHlaStateEncoder& operator=(const DtHlaStateEncoder& orig);

   typedef void (*DtAttributeEncoder)(
      const DtStateRepository& stateRep,
      RTI::AttributeHandleValuePairSet* avList,
      RTI::AttributeHandle handle);

   typedef bool (*DtAttributeChecker)(
      const DtStateRepository& stateRep,
      const DtStateRepository& asSeenByRemote);

   typedef bool (*DtAttributeCheckerWithHandle)(
      const DtStateRepository& stateRep,
      const DtStateRepository& asSeenByRemote,
      RTI::AttributeHandle handle);


   DtAttributeEncoder addEncoder(RTI::AttributeHandle hand,
      DtAttributeEncoder func);
   DtAttributeEncoder removeEncoder(RTI::AttributeHandle hand);

   DtAttributeEncoder addEncoder(char* name,
      DtAttributeEncoder func, bool complain = true);
   DtAttributeEncoder removeEncoder(char* name, bool complain = true);

   DtAttributeChecker addChecker(RTI::AttributeHandle hand,
      DtAttributeChecker func);
   DtAttributeChecker removeChecker(RTI::AttributeHandle hand);

   DtAttributeChecker addChecker(char* name,
      DtAttributeChecker func, bool complain = true);
   DtAttributeChecker removeChecker(char* name, bool complain = true);

   inline DtAttributeEncoder encoder(const RTI::AttributeHandle &handle) ;

   inline DtAttributeChecker checker(const RTI::AttributeHandle &handle) ;

   virtual void encode(const DtStateRepository& stateRep,
      const DtStateRepository& asSeenByRemote,
      const RTI::AttributeHandleSet& neededAttrs,
      const RTI::AttributeHandleSet& includeThese,
      DtStateMsg* msg);

   virtual RTI::ObjectClassHandle objectClassHandle();

   virtual DtHlaStateEncoder* clone(DtObjClassDesc* classDesc) const;

   virtual DtHlaStateEncoder* clone() const;

   virtual void preCalculateEligible(const RTI::AttributeHandleSet& neededAttrs);
public:

   static bool trueChecker(const DtStateRepository& stateRep,
      const DtStateRepository& asSeenByRemote);

   static bool falseChecker(const DtStateRepository& stateRep,
      const DtStateRepository& asSeenByRemote);

   static void wideStringToHlaUnicodeString(const std::wstring& wideString,
      RTI::AttributeHandleValuePairSet* avList,
      RTI::AttributeHandle attrHandle);

protected:

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

   std::map<RTI::AttributeHandle,DtAttributeEncoder> myEncoderList;
   std::map<RTI::AttributeHandle,DtAttributeChecker> myCheckerList;

   std::vector<DtAttributeChecker> myCheckerCache;
   const RTI::AttributeHandleSet* myCachedSet;


   std::map<RTI::AttributeHandle,bool>  myReportedWarning;
};

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

inline DtHlaStateEncoder::DtAttributeEncoder
   DtHlaStateEncoder::encoder(const RTI::AttributeHandle &hand) 
{
   return myEncoderList[hand];
};

inline DtHlaStateEncoder::DtAttributeChecker
   DtHlaStateEncoder::checker(const RTI::AttributeHandle &hand) 
{
   return myCheckerList[hand];
};

#define DtADD_ATTR_ENCODER(attrName) \
   addEncoder((char *)#attrName, (DtAttributeEncoder) encode##attrName)

#define DtADD_ATTR_ENCODER_QUIET(attrName) \
   addEncoder((char *)#attrName, (DtAttributeEncoder) encode##attrName, false)

#define DtADD_ATTR_CHECKER(attrName) \
   addChecker((char *)#attrName, (DtAttributeChecker) need##attrName)

#define DtADD_ATTR_CHECKER_QUIET(attrName) \
   addChecker((char *)#attrName, (DtAttributeChecker) need##attrName, false)

#define DtDECLARE_ATTR_ENCODER(stateRepClass, attrName) \
   static void encode##attrName(const stateRepClass& rep, \
      RTI::AttributeHandleValuePairSet* attrs, \
      RTI::AttributeHandle attrHandle) 

#define DtDECLARE_ATTR_CHECKER(stateRepClass, attrName) \
   static bool need##attrName(const stateRepClass& stateRep, \
      const stateRepClass& asSeenByRemote)

#define DtDEFINE_SIMPLE_ATTR_ENCODER( \
   encClass, stateRepClass, attrName, netType, inspector) \
void encClass::encode##attrName(const stateRepClass& rep, \
   RTI::AttributeHandleValuePairSet* attrs, \
   RTI::AttributeHandle attrHandle) \
{ \
   netType netVal; \
   netVal = rep.inspector(); \
   attrs->add(attrHandle, (char*) &netVal, sizeof(netType)); \
}

#define DtDEFINE_SIMPLE_GLOBAL_OBJECT_DESIGNATOR_ATTR_ENCODER( \
   encClass, stateRepClass, attrName, inspector) \
void encClass::encode##attrName(const stateRepClass& rep, \
   RTI::AttributeHandleValuePairSet* attrs, \
   RTI::AttributeHandle attrHandle) \
{ \
   DtGlobalObjectDesignator netVal = rep.inspector(); \
   attrs->add(attrHandle, (char*) netVal.string(), netVal.length()+1); \
}

#define DtDEFINE_SIMPLE_ATTR_CHECKER( \
   encClass, stateRepClass, attrName, inspector) \
bool encClass::need##attrName(const stateRepClass& stateRep, \
   const stateRepClass& asSeenByRemote) \
{ \
   return (bool) !(stateRep.inspector() == asSeenByRemote.inspector()); \
}


#define DtDEFINE_SIMPLE_ATTR_ENCODER_WITH_PARAM( \
   encClass, stateRepClass, attrName, netType, inspector, param) \
void encClass::encode##attrName(const stateRepClass& rep, \
   RTI::AttributeHandleValuePairSet* attrs, \
   RTI::AttributeHandle attrHandle) \
{ \
   if (rep.hasMode(param)) { \
      netType netVal; \
      netVal = rep.inspector(param); \
      attrs->add(attrHandle, (char*) &netVal, sizeof(netType)); \
   } \
}

#define DtDEFINE_SIMPLE_ATTR_CHECKER_WITH_PARAM( \
   encClass, stateRepClass, attrName, inspector, param) \
bool encClass::need##attrName(const stateRepClass& stateRep, \
   const stateRepClass& asSeenByRemote) \
{ \
   return (bool) (stateRep.hasMode(param) && asSeenByRemote.hasMode(param) \
       && !(stateRep.inspector(param) == \
       asSeenByRemote.inspector(param))); \
}



#endif
#endif