registerExtendedAttributeClassesHLA.h

Go to the documentation of this file.

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



#pragma once

#ifdef DtHLA

#include <vrfExtObjects/extendedAttributeEncoderHLA.h>
#include <vrfExtObjects/extendedAttributeDecoderHLA.h>
#include <vrfExtObjects/stateRepositoryWithExtendedAttributesHLA.h>
#include <vrfExtObjects/extendedAttributesObjectStateRepositoryHLA.h>
#include <vl/stateEncoderFactory.h>

#define DtALMOST(x, y, e) (((x)<=((y)+(e))) && ((x)>=((y)-(e))))

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

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

      DtObjClassDesc* baseClass = desc->baseClass();

      // Initialize the attribute name->handle map with the map from the base class
      if (baseClass)
      {
         attrNamesToHandles = StateRepType::attributeNameToHandleMap(baseClass->handle());
      }

      // Loop through all attribute handles. Add any attributes that do not
      // belong to the base class.
   #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

      StateRepType::setAttributeNameToHandleMap(desc->handle(), attrNamesToHandles);
   }

   inline void setExtendedAttributesNameToHandleMap(DtObjClassDesc* desc)
   {
      std::map<DtString, RTI::AttributeHandle> attrNamesToHandles;

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

      // Loop through all attribute handles and add all attribute mappings.
#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);
         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);
         attrNamesToHandles.insert(std::make_pair(attrName, hdl));
      }

#endif

      DtExtendedAttributesObjectStateRepository::setAttributeNameToHandleMap(attrNamesToHandles);
   }

   inline 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 PublisherType, typename ReflectedObjType>
   void registerExtendedAttributeClasses(const DtString& fullBaseClassName,
                                         const DtString& publisherName, 
                                         const DtString& reflListName,
                                         const DtFomMapper::DtObjectClassChooserWithUsrData& classChooser,
                                         void* classChooserUsr,
                                         DtExerciseConn* exConn)
   {
      static DtFomMapper::DtObjectClassChooserWithUsrData prevClassChooser = 0;
      static void* prevClassChooserUsr = 0;

      static DtString thePublisherName;
      static DtString theReflListName;
      thePublisherName = publisherName;
      theReflListName = reflListName;

      // Update class chooser if it has changed or is uninitialized
      if (classChooser &&
         thePublisherName.size() > 0 &&
         (prevClassChooser != classChooser ||
         prevClassChooserUsr != classChooserUsr))
      {
         // Set the object class to publish chooser function
         exConn->fomMapper()->setObjectClassChooser(thePublisherName.c_str(), classChooser, classChooserUsr);
      }

      // Do not reregister if already done. Need to check if this is the same exConn as last time
      // to handle the case of disconnect/reconnect. Unfortunately sometimes the memory address is
      // reused, so we can't simply check that. Instead use the exConn's clock to check the time
      // the exConn was initialized.
      static DtTime prevExConnInitTime = -1.0;
      DtTime exConnInitTime = exConn->clock()->absRealTime() - exConn->clock()->elapsedRealTime();
      if (DtALMOST(prevExConnInitTime, exConnInitTime, 0.0001))
      {
         // Already registered
         return;
      }

      static DtString theExtendedAttributesClassName = "VrfExtendedAttributes";
      static std::vector<DtString> theFullClassNames;

      std::set<DtString> objClassNames;

      // Get the list of all subclasses of the specified base class
      DtObjClassDesc* baseEntDesc = exConn->fom()->objClassByName(fullBaseClassName);
      DtObjClassDesc* classDesc = NULL;

#if DtHLA_1516
      for (std::list<DtObjClassDesc*>::const_iterator item = exConn->fom()->objClassList().begin();
         item != exConn->fom()->objClassList().end();
         ++item)
      {
         classDesc = const_cast<DtObjClassDesc*>(*item);
#else
      for (classDesc = exConn->fom()->firstObjClass(); 
         classDesc;
         classDesc = exConn->fom()->nextObjClass(classDesc))
      {
#endif
         if (baseEntDesc && classDesc->isOfClass(baseEntDesc->handle()))
         {
            theFullClassNames.push_back(classDesc->name());
         }
      }

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

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

         if(classDesc)
         {
            // Set the unknown attribute checker
            classDesc->setUnknownAttributeChecker((DtHlaStateEncoder::DtAttributeCheckerWithHandle)
               DtExtendedAttributeEncoder<StateRepType>::needExtendedAttribute);

            // Set the unknown attribute encoder
            classDesc->setUnknownAttributeEncoder((DtHlaStateEncoder::DtAttributeEncoder)
               DtExtendedAttributeEncoder<StateRepType>::encodeExtendedAttribute);

            // Set the unknown attribute decoder
            classDesc->setUnknownAttributeDecoder((DtHlaStateDecoder::DtAttributeDecoder)
               DtExtendedAttributeDecoder<StateRepType>::decodeExtendedAttribute);

            // 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 state repository creators
      PublisherType::setStateRepCreator((typename PublisherType::DtStateRepCreator)StateRepType::create);
      ReflectedObjType::setStateRepCreator((typename ReflectedObjType::DtStateRepCreator)StateRepType::create);

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

      // Now setup the Extended Attributes object attributes
      classDesc = exConn->fom()->objClassByName(theExtendedAttributesClassName.c_str());

      if (classDesc)
      {
         setExtendedAttributesNameToHandleMap(classDesc);
      }
      else
      {
         DtWarn << "Could not initialize use of extended attributes class: " <<
            theExtendedAttributesClassName << " not found in FOM." << std::endl;
      }

      prevExConnInitTime = exConnInitTime;
   }
}

#endif