pMacros.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 2013 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_PORTAL_CALLBACKS(DtBrokerObjectNamespace,DtPortalReflectedObjType) \
   virtual void createPortalPublisher(DtBrokerObjectNamespace::DtBrokerObject* brokerObject); \
   virtual bool isPortalPublishable(const DtBrokerObjectNamespace::DtBrokerObject* brokerObject) const; \
   virtual void deletePortalPublisher(DtBrokerObjectNamespace::DtBrokerObject* brokerObject); \
   virtual void discoverPortalObject(const DtPortalReflectedObjType &obj); \
   virtual void receivePortalUpdate(const DtPortalReflectedObjType &obj); \
   \
   static void portalObjectAddedCb(const DtPortalReflectedObjType &obj, void *ud); \
   static void portalObjectUpdatedCb(const DtPortalReflectedObjType &obj, void *ud); \
   static void portalObjectDeletedCb(const DtPortalReflectedObjType &obj, void *ud);


#define DT_DEFINE_CREATE_PORTAL_PUBLISHER(DtTranslatorClass,DtBrokerObjectNamespace,DtPortalObjectType,DtReflectedObject) \
   void DtTranslatorClass::createPortalPublisher( DtBrokerObjectNamespace::DtBrokerObject *brokerObject ) \
{ \
   MAKVrExchange::DtPortalObjectPublisherTemplate<DtPortalObjectType> *publisher = \
   new MAKVrExchange::DtPortalObjectPublisherTemplate<DtPortalObjectType>(broker()->portalConnection()); \
   \
   const DtReflectedObject* reflectedObj = \
   static_cast<const DtReflectedObject*>( brokerObject->reflectedObjPtr() ); \
   \
   publisher->sr()->setIdentifier(reflectedObj->globalId()); \
   brokerObject->setPublisherPtr(publisher); \
}

#define DT_DEFINE_IS_PORTAL_PUBLISHABLE(DtTranslatorClass, DtBrokerObjectNamespace, Protocol) \
bool DtTranslatorClass::isPortalPublishable( const DtBrokerObjectNamespace::DtBrokerObject *brokerObject ) const \
{  \
   assert( brokerObject->protocol() == DtBrokerObjectNamespace::DtBrokerObject::Protocol );\
   return true;\
}

#define DT_DEFINE_DELETE_PORTAL_PUBLISHER(DtTranslatorClass, DtBrokerObjectNamespace, DtPortalObjectType) \
void DtTranslatorClass::deletePortalPublisher(DtBrokerObjectNamespace::DtBrokerObject* brokerObject) \
{ \
   MAKVrExchange::DtPortalObjectPublisherTemplate<DtPortalObjectType> *publisher = \
      static_cast<MAKVrExchange::DtPortalObjectPublisherTemplate<DtPortalObjectType> *>(brokerObject->publisherPtr()); \
      \
   if (publisher) \
   { \
      DtDELETE( publisher ); \
      brokerObject->setPublisherPtr( publisher ); \
   } \
}

#define DT_DEFINE_DISCOVER_PORTAL_OBJECT(DtTranslatorClass,DtBrokerObjectNamespace,DtPortalReflectedObjType,DtProtocol) \
void DtTranslatorClass::discoverPortalObject(const DtPortalReflectedObjType &refObj) \
{ \
   DtBrokerObjectNamespace::DtBrokerObject* brokerObject = findBrokerObject(&refObj); \
   if (!brokerObject) \
   { \
      brokerObject = createBrokerObject(&refObj); \
   } \
   \
   brokerObject->setLastUpdate(myBroker->simTime()); \
   brokerObject->setObjectName(refObj.sr()->identifier()); \
   brokerObject->setIsDiscovered(true); \
   \
   create##DtProtocol##Publisher( brokerObject ); \
   \
   refObj.addUpdateCallback(DtTranslatorClass::portalObjectUpdatedCb, this); \
   receivePortalUpdate(refObj); \
}

#define DT_DEFINE_RECEIVE_PORTAL_UPDATE(DtTranslatorClass, DtBrokerObjectNamespace, DtPortalReflectedObjType, \
   DtPortalObjType, DtProtocolPublisher, DtProtocolStateRepository,DtProtocol) \
void DtTranslatorClass::receivePortalUpdate(const DtPortalReflectedObjType &refObj) \
{ \
   DtBrokerObjectNamespace::DtBrokerObject* brokerObject = findBrokerObject(&refObj); \
   assert( brokerObject ); \
   \
   brokerObject->setLastUpdate(myBroker->simTime()); \
   \
   const DtPortalObjType &sr = *(refObj.sr()); \
   \
   if (!brokerObject->isPublishable()) \
   { \
   brokerObject->setIsPublishable( is##DtProtocol##Publishable( brokerObject )); \
   } \
   \
   callObjectUpdateCallbacks( brokerObject ); \
   \
   if (brokerObject->isDropped()) \
   { \
      return; \
   } \
   \
   DtProtocolPublisher *publisher = \
      static_cast<DtProtocolPublisher*>( brokerObject->publisherPtr() ); \
   assert(publisher); \
   \
   DtProtocolStateRepository &newSr = * \
      static_cast<DtProtocolStateRepository*>(publisher->sr()); \
   \
   translate( &newSr, sr, refObj ); \
   \
   if (myBroker->isTranslatorDebuggingOn( virtualTranslatorName() )) \
   { \
      printIncomingOutgoingStateReps(sr, newSr, virtualTranslatorName()); \
   } \
   \
   if ( myBroker->brokerInitializer()->oneToOneMapping()) \
   { \
      publisher->forceUpdate(); \
   } \
   if (!myBroker->isTranslatorDisabled( virtualTranslatorName() )) \
   { \
      publisher->tick(); \
   } \
   performPortalDebugging( sr, newSr ); \
}


#define DT_DEFINE_PORTAL_CALLBACKS(DtTranslatorClass, DtPortalReflectedObjType, DtTemplates) \
   DtTemplates \
void DtTranslatorClass::portalObjectAddedCb(const DtPortalReflectedObjType & reflectedObj, void *ud) \
{ \
   DtTranslatorClass *et = (DtTranslatorClass*)ud; \
   et->discoverPortalObject(reflectedObj); \
}; \
   \
   DtTemplates \
void DtTranslatorClass::portalObjectUpdatedCb(const DtPortalReflectedObjType & reflectedObj, void *ud) \
{ \
   DtTranslatorClass *et = (DtTranslatorClass*)ud; \
   et->receivePortalUpdate(reflectedObj); \
}; \
   \
   DtTemplates \
void DtTranslatorClass::portalObjectDeletedCb(const DtPortalReflectedObjType & reflectedObj, void *ud) \
{ \
   DtTranslatorClass *et = (DtTranslatorClass*)ud; \
   et->removePortalObject(&reflectedObj); \
}


#define DT_TICK_ALL_PUBLISHERS(DtPublisherContainerType, DtBrokerObjectNamespace, DtPublisherContainer, DtPublisherType) \
   for ( DtPublisherContainerType::iterator pubItr = \
      DtPublisherContainer.begin(); pubItr != DtPublisherContainer.end(); ++pubItr) \
{ \
   DtBrokerObjectNamespace::DtBrokerObject* brokerObject = pubItr->second; \
   DtPublisherType *publisher = static_cast<DtPublisherType*>( brokerObject->publisherPtr() ); \
   if (publisher && brokerObject->isPublishable()) \
   { \
      publisher->tick(); \
   } \
}

#define DT_DECLARE_INTERACTION_PORTAL_CALLBACKS(DtPortalInteractionType,DtInteractionType) \
   virtual void createPortalInteraction( const DtInteractionType& incomming ); \
   static void receivePortalInteraction( const DtPortalInteractionType &inter, void *usr);


#define DT_DEFINE_CREATE_PORTAL_INTERACTION(DtTranslatorClass,DtPortalInteractionType,DtInteractionType,DtObjectKind) \
void DtTranslatorClass::createPortalInteraction( const DtInteractionType& in ) \
{ \
   DtPortalInteractionType out; \
   out.setKind(DtObjectKind); \
\
   translate( &out, in ); \
\
   if (broker()->isTranslatorDebuggingOn( virtualTranslatorName() )) \
   { \
      printIncomingOutgoingInteractions( in, out); \
   } \
   broker()->portalConnection()->send(out); \
}

#define DT_DEFINE_RECEIVE_PORTAL_INTERACTION(DtTranslatorClass,DtPortalInteractionType, DtProtocol) \
void DtTranslatorClass::receivePortalInteraction( \
   const DtPortalInteractionType &inter, void *usr) \
{ \
   DtTranslatorClass *trans = (DtTranslatorClass*)usr; \
   trans->create##DtProtocol##Interaction(inter); \
}