hMacros.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 2012 VT MAK
 *********************************************************************/

// This file defines macros that make creating translation easier

// The first 5 functions in this macro must be defined in your CXX file. the next 3 are automatically defined by the DT_DEFINE macro
#define DT_DECLARE_HLA_CALLBACKS(DtHlaReflectedObjType) \
   virtual void createHlaPublisher(MAKVrExchange::DtHlaBroker::DtBrokerObject* brokerObject); \
   virtual bool isHlaPublishable(const MAKVrExchange::DtHlaBroker::DtBrokerObject* brokerObject) const; \
   virtual void deleteHlaPublisher(MAKVrExchange::DtHlaBroker::DtBrokerObject* brokerObject); \
   virtual void discoverHlaObject(DtHlaReflectedObjType *obj); \
   virtual void receiveHlaUpdate(DtHlaReflectedObjType *obj); \
 \
   static void hlaObjectAddedCb(DtHlaReflectedObjType *obj, void *ud); \
   static void hlaObjectUpdatedCb(DtHlaReflectedObjType *obj, void *ud); \
   static void hlaObjectDeletedCb(DtHlaReflectedObjType *obj, void *ud); 


#define DT_DEFINE_CREATE_HLA_PUBLISHER(DtTranslatorClass,DtPortalReflectedObjType,DtHlaPublisher) \
   void DtTranslatorClass::createHlaPublisher(MAKVrExchange::DtHlaBroker::DtBrokerObject* brokerObject) \
{ \
   const DtPortalReflectedObjType* reflectedObj = \
   static_cast<const DtPortalReflectedObjType*>( brokerObject->reflectedObjPtr() ); \
   assert(reflectedObj); \
   DtString objectName = reflectedObj->sr()->identifier().c_str(); \
   \
   DtHlaPublisher* publisher = NULL; \
   try \
   { \
   publisher = new DtHlaPublisher( broker()->hlaConnection(), objectName); \
   if(publisher->name() != objectName) \
      { \
      broker()->globalIdMapper()->add(objectName,publisher->name()); \
      } \
   } \
   catch (RTI::Exception&) \
   { \
   try \
      { \
      DtWarn << "Illegal Object Name: " << objectName << " Trying to publish with new name."; \
      publisher = new DtHlaPublisher( broker()->hlaConnection()); \
      \
      if(publisher) \
         { \
         broker()->globalIdMapper()->add(objectName,publisher->name()); \
         } \
      } \
      catch (RTI::Exception& ex) \
      { \
      DtWarn << "Caught RTI Exception: "; \
      DtWarn << ex << "\n"; \
      } \
   } \
   DtCATCH_AND_WARN(DtWarn) \
   \
   brokerObject->setPublisherPtr( publisher ); \
   \
   if (publisher==NULL) \
   { \
   DtWarn << "Dropping: " << objectName << "\n"; \
   brokerObject->setIsDropped( true ); \
   } \
}

#define DT_DEFINE_IS_HLA_PUBLISHABLE(DtTranslatorClass, DtPortalReflectedObjType) \
bool DtTranslatorClass::isHlaPublishable( const MAKVrExchange::DtHlaBroker::DtBrokerObject *brokerObject ) const \
{ \
   assert( brokerObject->protocol() == MAKVrExchange::DtHlaBroker::DtBrokerObject::portal ); \
   const DtPortalReflectedObjType* reflectedObj = \
      static_cast<const DtPortalReflectedObjType*>( brokerObject->reflectedObjPtr() ); \
   assert(reflectedObj); \
   return true; \
}

#define DT_DEFINE_DELETE_HLA_PUBLISHER(DtTranslatorClass, DtHlaPublisher) \
void DtTranslatorClass::deleteHlaPublisher(MAKVrExchange::DtHlaBroker::DtBrokerObject* brokerObject) \
{ \
   DtHlaPublisher *publisher = \
      static_cast<DtHlaPublisher *>( brokerObject->publisherPtr() ); \
      \
   if (publisher) \
   { \
      DtDELETE( publisher ); \
      brokerObject->setPublisherPtr( publisher ); \
   } \
}

#define DT_DEFINE_DISCOVER_HLA_OBJECT(DtTranslatorClass, DtHlaReflectedObjType,DtProtocol) \
void DtTranslatorClass::discoverHlaObject(DtHlaReflectedObjType *refObj) \
{ \
   MAKVrExchange::DtHlaBroker::DtBrokerObject* brokerObject = findBrokerObject(refObj); \
   if (!brokerObject) \
   { \
      brokerObject = createBrokerObject(refObj); \
   } \
   brokerObject->setLastUpdate(myBroker->simTime()); \
   brokerObject->setObjectName(refObj->globalId()); \
   brokerObject->setIsDiscovered(true); \
   \
   createPortalPublisher( brokerObject ); \
   \
   refObj->addPostUpdateCallback( \
      DtTranslatorClass::hlaObjectUpdatedCb, this); \
      receive##DtProtocol##Update(refObj); \
}

#define DT_DEFINE_RECEIVE_HLA_UPDATE(DtTranslatorClass, DtHlaReflectedObjType, \
   DtHlaStateRepository, DtPortalObjectType, DtObjectKind) \
   void DtTranslatorClass::receiveHlaUpdate(DtHlaReflectedObjType *refObj) \
{ \
   MAKVrExchange::DtHlaBroker::DtBrokerObject* brokerObject = findBrokerObject(refObj); \
   assert( brokerObject ); \
   \
   DtHlaStateRepository &sr = * \
      static_cast<DtHlaStateRepository*>(refObj->sr()); \
      \
   brokerObject->setLastUpdate(myBroker->simTime()); \
   if (!brokerObject->isPublishable()) \
   {  \
      brokerObject->setIsPublishable(isPortalPublishable( brokerObject )); \
   } \
   \
   callObjectUpdateCallbacks( brokerObject ); \
   \
   if (brokerObject->isDropped()) \
   { \
      return; \
   } \
   \
   MAKVrExchange::DtPortalObjectPublisherTemplate<DtPortalObjectType>*publisher = \
      static_cast<MAKVrExchange::DtPortalObjectPublisherTemplate<DtPortalObjectType>*> \
      ( brokerObject->publisherPtr() ); \
   \
   DtPortalObjectType& newSr = *(publisher->sr()); \
   newSr.setKind(DtObjectKind); \
   \
   translate( &newSr, sr, *refObj ); \
   \
   if( myBroker->brokerInitializer()->oneToOneMapping() ) \
   { \
      publisher->forceUpdate(); \
   } \
   \
   if (myBroker->isTranslatorDebuggingOn( virtualTranslatorName() )) \
   { \
      printIncomingOutgoingStateReps(sr, newSr, virtualTranslatorName()); \
   } \
}

#define DT_DEFINE_HLA_CALLBACKS(DtTranslatorClass, DtHlaReflectedObjType, DtTemplates) \
DtTemplates \
void DtTranslatorClass::hlaObjectAddedCb(DtHlaReflectedObjType *reflectedObj, void *ud) \
{ \
   DtTranslatorClass *et = (DtTranslatorClass*)ud; \
   et->discoverHlaObject(reflectedObj); \
}; \
   \
   DtTemplates \
void DtTranslatorClass::hlaObjectUpdatedCb(DtHlaReflectedObjType *reflectedObj, void *ud) \
{ \
   DtTranslatorClass *et = (DtTranslatorClass*)ud; \
   et->receiveHlaUpdate(reflectedObj); \
}; \
   \
   DtTemplates \
void DtTranslatorClass::hlaObjectDeletedCb(DtHlaReflectedObjType *reflectedObj, void *ud) \
{ \
   DtTranslatorClass *et = (DtTranslatorClass*)ud; \
   et->removeHlaObject(reflectedObj); \
} 

#define DT_DECLARE_INTERACTION_HLA_CALLBACKS(DtPortalInteractionType,DtInteractionType) \
   virtual void createHlaInteraction(const DtPortalInteractionType& in); \
   static void receiveHlaInteraction(DtInteractionType *inter, void *usr);


#define DT_DEFINE_CREATE_HLA_INTERACTION(DtTranslatorClass,DtPortalInteractionType,DtInteractionType) \
   void DtTranslatorClass::createHlaInteraction(const DtPortalInteractionType& in) \
   { \
      DtInteractionType out; \
      out.setExConn(myBroker->hlaConnection(),0); \
\
      translate( &out, in ); \
\
      if (myBroker->isTranslatorDebuggingOn( virtualTranslatorName() )) \
      { \
         printIncomingOutgoingInteractions( in, out); \
      }\
      myBroker->hlaConnection()->sendStamped(out); \
   }

   
#define DT_DEFINE_RECEIVE_HLA_INTERACTION(DtTranslatorClass,DtInteractionType) \
   void DtTranslatorClass::receiveHlaInteraction(DtInteractionType *inter, void *usr) \
   { \
      DtTranslatorClass *trans = (DtTranslatorClass*)usr; \
      trans->createPortalInteraction(*inter); \
   }