genericAttributeEncoderHLA.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2013 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#ifdef DtHLA

#include <vlutil/vlString.h>
#include <vl/fom.h>
#include <vl/objClassDesc.h>
#include <vl/hlaStateEncoder.h>
#include "vrfExtObjects/genericAttributeStateRepositoryHLA.h"

namespace makVrfVrlinkExtToolkit
{
   template <typename StateRepType, typename EncoderType>
   class DtGenericAttributeEncoder : public EncoderType
   {
   public:

      DtGenericAttributeEncoder(
         DtExerciseConn* exConn,
         DtObjClassDesc* classDesc) : EncoderType(exConn, classDesc) {}

      virtual ~DtGenericAttributeEncoder() {};

      DtGenericAttributeEncoder(
         const DtGenericAttributeEncoder<StateRepType, EncoderType>& orig)
         : EncoderType(orig) {}

      DtGenericAttributeEncoder& operator=(
         const DtGenericAttributeEncoder<StateRepType, EncoderType>& orig)
      {
         EncoderType::operator=(orig);
         return *this;
      }

      static void encodeGenericAttribute(const StateRepType& rep,
                                  RTI::AttributeHandleValuePairSet* attrs,
                                  RTI::AttributeHandle attrHandle)
      {
         DtGenericAttributeStateRepository<StateRepType>* genSR =
            (DtGenericAttributeStateRepository<StateRepType>*)&rep;
         unsigned srLength = 0;
         const char* srValue = genSR->getAttributeByHandle(attrHandle, srLength);
         attrs->add(attrHandle, (char*)srValue, srLength);
      }

      virtual DtHlaStateEncoder* clone() const
      {
         return new DtGenericAttributeEncoder<StateRepType, EncoderType>(*this);
      }

      virtual DtHlaStateEncoder* clone(DtObjClassDesc* classDesc) const
      {
         if (classDesc->isOfClass(this->myClassDesc->handle()))
         {
            DtHlaStateEncoder* enc = new DtGenericAttributeEncoder
               <StateRepType, EncoderType>(this->myExConn, classDesc);

            std::map<RTI::AttributeHandle,DtHlaStateEncoder::DtAttributeEncoder>::const_iterator
               encIter = this->myEncoderList.begin();
            std::map<RTI::AttributeHandle,DtHlaStateEncoder::DtAttributeEncoder>::const_iterator
               encEnd = this->myEncoderList.end();
            for(; encIter != encEnd; ++encIter)
            {
               enc->addEncoder(encIter->first, encIter->second);
            }

            std::map<RTI::AttributeHandle,DtHlaStateEncoder::DtAttributeChecker>::const_iterator
               chIter = this->myCheckerList.begin();
            std::map<RTI::AttributeHandle,DtHlaStateEncoder::DtAttributeChecker>::const_iterator
               chEnd = this->myCheckerList.end();
            for(; chIter != chEnd; ++chIter)
            {
               enc->addChecker(chIter->first, chIter->second);
            }

            return enc;
         }
         else
         {
            DtWarn << "DtGenericAttributeEncoder: ClassDesc is not a subclass.  "
               << "Returning a normal clone " << std::endl;
            return clone();
         }
      }

      virtual void encode(const DtStateRepository& stateRep,
         const DtStateRepository& asSeenByRemote,
         const RTI::AttributeHandleSet& neededAttrs,
         const RTI::AttributeHandleSet& includeThese,
         DtStateMsg* msg)
      {
         if (!this->myClassDesc)
         {
            return;
         }

   #if DtHLA_1516
         //
         // Here we construct a Dummy wrapper AHVPS around the map.
         //
         RTI::AttributeHandleValuePairSet* avList = 
            new RTI::AttributeHandleValuePairSet(msg->handleMap());
   #else
         HandleValueMap* avList = msg->handleMap();
   #endif

   #if DtHLA_1516
         RTI::AttributeHandleSet::const_iterator end = neededAttrs.end();
         RTI::AttributeHandleSet::const_iterator pos = neededAttrs.begin();
         for (; pos != end; ++pos)
         {
            RTI::AttributeHandle handle = *pos;
   #else
         for (RTI::ULong index = 0; index < neededAttrs.size(); index++)
         {
            RTI::AttributeHandle handle = neededAttrs.getHandle(index);
   #endif

            DtHlaStateEncoder::DtAttributeEncoder enc = this->encoder(handle);
            if (!enc)
            { 
               if (handle != this->myClassDesc->privilegeHandle()) 
               {
                  DtHlaStateEncoder::DtAttributeEncoder unknownEncoder = this->myClassDesc->unknownAttributeEncoder();            
                  if (unknownEncoder)
                  {
                     // Before using the unknown encoder, use our generic unknown
                     // attribute checker
   #if DtHLA_1516
                     if(includeThese.find(handle) != includeThese.end() ||
   #else
                     if(includeThese.isMember(handle) ||
   #endif
                        needGenericAttribute(stateRep, asSeenByRemote, handle))
                     {
                        (*unknownEncoder)(stateRep, avList, handle);
                     }
                     continue;
                  }
                  else if (!this->myReportedWarning[handle])
                  {
                     DtWarn << "DtHlaStateEncoder for class "<< this->myClassDesc->name() 
                        << " has no encoder for attribute " 
                        <<  this->myClassDesc->attributeNameByHandle(handle) 
                        << std::endl;
                  }
               }
            }

            DtHlaStateEncoder::DtAttributeChecker check = this->checker(handle);
            if (!check)
            { 
               if (handle != this->myClassDesc->privilegeHandle() && !this->myReportedWarning[handle])
               {
                  DtWarn << "DtHlaStateEncoder for class "<< this->myClassDesc->name() 
                     << " has no checker for attribute " 
                     <<  this->myClassDesc->attributeNameByHandle(handle) << std::endl;
               }
            }

            if (!enc || !check)
            {
               this->myReportedWarning[handle] = true;
               continue;
            }

   #if DtHLA_1516
            if ( includeThese.find(handle) != includeThese.end() ||
               (*check)(stateRep, asSeenByRemote))
   #else
            if (includeThese.isMember(handle) ||
               (*check)(stateRep, asSeenByRemote))
   #endif
            { 
               (*enc)(stateRep, avList, handle);
            } 
         }
   #if DtHLA_1516
         delete avList;
   #endif
      }

   public:

      static DtHlaStateEncoder* create(
         DtExerciseConn* exConn,
         DtObjClassDesc* classDesc)
      {
         return new DtGenericAttributeEncoder<StateRepType, EncoderType>(exConn, classDesc);
      }

   protected:

      static bool needGenericAttribute(
         const DtStateRepository& stateRep, 
         const DtStateRepository& asSeenByRemote,
         RTI::AttributeHandle attrHandle)
      {
         const DtGenericAttributeStateRepository<StateRepType>* genSR =
            static_cast<const DtGenericAttributeStateRepository<StateRepType>*>(&stateRep);
         const DtGenericAttributeStateRepository<StateRepType>* genASBR =
            static_cast<const DtGenericAttributeStateRepository<StateRepType>*>(&asSeenByRemote);

         unsigned srLength = 0;
         unsigned asbrLength = 0;
         const char* srValue = genSR->getAttributeByHandle(attrHandle, srLength);
         const char* asbrValue = genASBR->getAttributeByHandle(attrHandle, asbrLength);

         return (srLength != asbrLength ||
            memcmp(srValue, asbrValue, srLength) != 0); 
      }

   };
}

#endif