registerGenericAttributeClassHLA.h

Go to the documentation of this file.

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



#pragma once

#ifdef DtHLA

#include "vrfExtObjects/genericAttributeEncoderHLA.h"
#include "vrfExtObjects/genericAttributeDecoderHLA.h"
#include "vrfExtObjects/genericAttributeStateRepositoryHLA.h"
#include <vl/stateEncoderFactory.h>

namespace makVrfVrlinkExtToolkit
{
   template <typename StateRepType>
   void setAttributeNameToHandleMap(DtObjClassDesc* desc)
   {
      std::map<DtString, RTI::AttributeHandle> attrNamesToHandles;

      const RTI::AttributeHandleSet& ahs = desc->attrHandleSet();

      // Loop through all attribute handles. Add any attributes that do not
      // belong to the base class. Base class attributes will be handled by
      // the DtAggregateEntityEncoder set/get methods. All other attribute
      // name-to-handle mappings must be provided to the state rep.
      DtObjClassDesc* baseClass = desc->baseClass();
   #if DtHLA_1516

      RTI::AttributeHandleSet::const_iterator itr = ahs.begin();
      const RTI::AttributeHandleSet::const_iterator end = ahs.end();
      for (; itr != end; itr++)
      {
         DtString attrName = desc->attributeNameByHandle(*itr);
         if(!baseClass->hasAttribute(attrName.c_str()))
         {
            attrNamesToHandles.insert(std::make_pair(attrName, *itr));
         }
      }

   #else

      for (RTI::ULong i = 0; i < ahs.size(); i++)
      {
         RTI::AttributeHandle hdl = ahs.getHandle(i);
         DtString attrName = desc->attributeNameByHandle(hdl);
         if(!baseClass->hasAttribute(attrName.c_str()))
         {
            attrNamesToHandles.insert(std::make_pair(attrName, hdl));
         }
      }

   #endif

      DtGenericAttributeStateRepository<StateRepType>::
         setAttributeNameToHandleMap(attrNamesToHandles);
   }

   bool areClassNamesEquivalent(const DtString& name1, const DtString& name2)
   {
      const DtString hla13RootName("ObjectRoot.");
      const DtString hla1516RootName("HLAobjectRoot.");

      const char* name1Ptr = name1.c_str();
      const char* name2Ptr = name2.c_str();

      if (name1.findString(hla13RootName) == 0)
      {
         name1Ptr += hla13RootName.size();
      }
      else if (name1.findString(hla1516RootName) == 0)
      {
         name1Ptr += hla1516RootName.size();
      }

      if (name2.findString(hla13RootName) == 0)
      {
         name2Ptr += hla13RootName.size();
      }
      else if (name2.findString(hla1516RootName) == 0)
      {
         name2Ptr += hla1516RootName.size();
      }

      return (strcmp(name1Ptr, name2Ptr) == 0);
   }

   template <typename StateRepType, typename EncoderType, typename PublisherType, typename ReflectedObjType>
   void registerGenericAttributeClass(const DtString& fullClassName,
                                       const DtString& publisherName, 
                                       const DtString& reflListName,
                                       DtExerciseConn* exConn)
   {
      // Store static local copies of each of the strings. This is because the
      // char* we pass to the VRL registration functions are simply stored directly,
      // so we need to make sure they persist. Since this is a template function,
      // these will be unique for these template arguments.
      static DtString theFullClassName;
      static DtString thePublisherName;
      static DtString theReflListName;
      theFullClassName = fullClassName;
      thePublisherName = publisherName;
      theReflListName = reflListName;

      DtObjClassDesc* classDesc = exConn->fom()->objClassByName(theFullClassName.c_str());

      if(classDesc)
      {
         // Since there is no way to set an unknown attribute checker, we need to 
         // completely replace the state encoder class in order to write a new
         // encode method to override this.
         exConn->fomMapper()->stateEncoderFactory()->addEncoder(classDesc->handle(),
            DtGenericAttributeEncoder<StateRepType, EncoderType>::create(exConn, classDesc));

         // Set the generic unknown attribute encoder
         classDesc->setUnknownAttributeEncoder((DtHlaStateEncoder::DtAttributeEncoder)
            DtGenericAttributeEncoder<StateRepType, EncoderType>::encodeGenericAttribute);

         // Set the generic unknown attribute decoder
         classDesc->setUnknownAttributeDecoder((DtHlaStateDecoder::DtAttributeDecoder)
            DtGenericAttributeDecoder<StateRepType>::decodeGenericAttribute);

         // Add the new object class to the list of classes supported by the 
         // reflected list
         std::set<DtString> objClassNames;
         const std::set<DtString>* currObjClassNames = exConn->fomMapper()->objectClassNames(theReflListName.c_str());
         if(currObjClassNames)
         {
            objClassNames = *currObjClassNames;
         }

         // Add class to list of class names. Check to make sure class isn't already present in
         // another acceptable form (i.e. with or without the root class specified.
         bool alreadyPresent = false;
         std::set<DtString>::const_iterator objClassIter = objClassNames.begin();
         for (; objClassIter != objClassNames.end() && !alreadyPresent; ++objClassIter)
         {
            if (areClassNamesEquivalent(theFullClassName, *objClassIter))
            {
               alreadyPresent = true;
            }
         }

         if (!alreadyPresent)
         {
            objClassNames.insert(theFullClassName);
            exConn->fomMapper()->setObjectClassNames(theReflListName.c_str(), objClassNames);
         }

         // Set the state repository creators
         PublisherType::setStateRepCreator((typename PublisherType::DtStateRepCreator)
            DtGenericAttributeStateRepository<StateRepType>::create);
         ReflectedObjType::setStateRepCreator((typename ReflectedObjType::DtStateRepCreator)
            DtGenericAttributeStateRepository<StateRepType>::create);

         // Set the object class to publish
         exConn->fomMapper()->setObjectClassToChoose(thePublisherName.c_str(), theFullClassName.c_str());

         // Set the attribute name-handle map in the state rep class
         setAttributeNameToHandleMap<StateRepType>(classDesc);
      }
   }

   template <typename StateRepType, typename EncoderType, typename PublisherType, typename ReflectedObjType>
   void registerGenericAttributeClass(const std::vector<DtString>& fullClassNames,
                                       const DtString& publisherName, 
                                       const DtString& reflListName,
                                       DtFomMapper::DtObjectClassChooser classChooser,
                                       DtExerciseConn* exConn)
   {
      static std::vector<DtString> theFullClassNames;
      static DtString thePublisherName;
      static DtString theReflListName;
      theFullClassNames = fullClassNames;
      thePublisherName = publisherName;
      theReflListName = reflListName;

      std::set<DtString> objClassNames;

      // Get the current list of object classes supported by the reflected list
      const std::set<DtString>* currObjClassNames = *exConn->fomMapper()->objectClassNames(theReflListName.c_str());
      if(currObjClassNames)
      {
         objClassNames = *currObjClassNames;
      }

      // Set the state repository creators
      PublisherType::setStateRepCreator((typename PublisherType::DtStateRepCreator)StateRepType::create);
      ReflectedObjType::setStateRepCreator((typename ReflectedObjType::DtStateRepCreator)StateRepType::create);

      for(int i = 0; i < theFullClassNames.size(); ++i)
      {
         DtObjClassDesc* classDesc = exConn->fom()->objClassByName(theFullClassNames[i].c_str());

         if(classDesc)
         {
            // Since there is no way to set an unknown attribute checker, we need to 
            // completely replace the state encoder class in order to write a new
            // encode method to override this.
            exConn->fomMapper()->stateEncoderFactory()->addEncoder(classDesc->handle(),
               DtGenericAttributeEncoder<StateRepType, EncoderType>::create(exConn, classDesc));

            // Set the generic unknown attribute encoder
            classDesc->setUnknownAttributeEncoder((DtHlaStateEncoder::DtAttributeEncoder)
               DtGenericAttributeEncoder<StateRepType, EncoderType>::encodeGenericAttribute);

            // Set the generic unknown attribute decoder
            classDesc->setUnknownAttributeDecoder((DtHlaStateDecoder::DtAttributeDecoder)
               DtGenericAttributeDecoder<StateRepType>::decodeGenericAttribute);

            // Add class to list of class names. Check to make sure class isn't already present in
            // another acceptable form (i.e. with or without the root class specified.
            bool alreadyPresent = false;
            std::set<DtString>::const_iterator objClassIter = objClassNames.begin();
            for (; objClassIter != objClassNames.end() && !alreadyPresent; ++objClassIter)
            {
               if (areClassNamesEquivalent(theFullClassNames[i], *objClassIter))
               {
                  alreadyPresent = true;
               }
            }

            if (!alreadyPresent)
            {
               objClassNames.insert(theFullClassNames[i]);
               exConn->fomMapper()->setObjectClassNames(theReflListName.c_str(), objClassNames);
            }

            // Set the attribute name-handle map in the state rep class
            setAttributeNameToHandleMap<StateRepType>(classDesc);
         }

      }

      // Set the reflected list object class names
      exConn->fomMapper()->setObjectClassNames(theReflListName.c_str(), objClassNames);

      // Set the object class to publish chooser function
      exConn->fomMapper()->setObjectClassChooser(thePublisherName.c_str(), classChooser);
   }
}

#endif