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(name()) ) \
   { \
      printIncomingOutgoingStateReps( sr, newSr ); \
   } \
   \
   if ( myBroker->brokerInitializer()->oneToOneMapping() ) \
   { \
      publisher->forceUpdate(); \
   } \
   if ( ! myBroker->isTranslatorDisabled(name()) ) \
   { \
      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) \
   DtPublisherContainerType::iterator pubItr = DtPublisherContainer.begin(); \
   DtPublisherContainerType::iterator pubEnd = DtPublisherContainer.end(); \
   for ( ; pubItr != pubEnd; ++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(name()) ) \
   { \
      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 ); \
}