HLA Broker Example

The modHlaBroker example does the following:

• It subclasses DtEntityTranslator to make a new entity translator (with the goal of modifying how Portal objects get translated to HLA objects). The class does not do much; it shows how to override functions related to translation.
• It installs the new class in the hlaBrokerApp and shows how to recompile an HLA broker.

  ---

  ---

  /*****************************************************************************
   * Copyright (c) 2015 VT MAK
   * All rights reserved.
   ****************************************************************************/
  
  
  #include "modEntTrans.h"
  #include <rprBroker/rprBroker.h>
  
  #include <portal/pObjectPublisher.h>
  #include <portal/pEntity.h>
  
  #include <vl/reflectedEntityList.h>
  #include <vl/entityPublisher.h>
  #include <vl/baseEntityStateRepository.h>
  
  #include <broker/brokerObject.h>
  
  #include <assert.h>
  
  using namespace MAKVrExchange;
  using namespace DtRprBroker;
  
  DtModEntityTranslator::DtModEntityTranslator(
        MAKVrExchange::DtBroker* broker )
     : DtEntityTranslator( broker )
  {
  }
  
  DtModEntityTranslator::~DtModEntityTranslator()
  {
  }
  
  // Translators' updatePortalBrokerObject is called while processing updates
  // to portal objects. It can be overridden to change the values stored in the
  // DtBrokerObject. This implementation duplicates some of the logic performed
  // in the base class's updatePortalBrokerObject method. Consult the
  // documentation when overriding.
  void DtModEntityTranslator::updatePortalBrokerObject( DtBrokerObject* brokerObj,
     const DtPortalEntity& sr )
  {
     // Call the base class method first. This way all the translation is done
     // and you can selectively go back and modify a few parameters. This is
     // not required of course, but it can be useful.
     DtEntityTranslator::updatePortalBrokerObject( brokerObj, sr );
  
     // Set the last time this broker was updated.
     // Useful for GUI and other record keeping.
     brokerObj->setLastUpdate( broker()->simTime() );
  
     // Lets figure out if this is publishable yet, if it is lets mark it as such.
     if ( ! brokerObj->isPublishable() )
     {
        DtPortalReflectedEntity* refObj =
           (DtPortalReflectedEntity*) brokerObj->reflectedObjPtr();
        brokerObj->setIsPublishable( isRprPublishable(brokerObj,refObj) );
     }
  
     // Set the marking text in the broker.
     // This is useful for the GUI and other record keeping.
     brokerObj->setMarkingText( sr.markingText() );
  }
  
  // In order to modify how the state is translated and/or set additional
  // values, the translate method can be overridden. This version is for
  // modifying how Portal entities are translated to HLA entities. To modify
  // HLA to Portal translation, the method signature is slightly different.
  DtEntityStateRepository* DtModEntityTranslator::translate( DtEntityStateRepository* dest,
     const DtPortalEntity& src, const DtPortalReflectedEntity& refObj )
  {
     // Call the base class method first. This way all the translation is done
     // and you can selectively go back and modify a few parameters. This is
     // not required of course, but it can be useful.
     DtEntityTranslator::translate( dest, src, refObj );
  
     // Set a few attribute values
     dest->setMarkingText( src.markingText() );
     dest->setPowerPlantOn( src.powerPlantOn() );
     dest->setDamageState( (DtDamageState) src.damageState() );
     dest->setEngineSmokeOn( src.engineSmokeOn() );
     dest->setFlamesPresent( src.flamesPresent() );
     dest->setHasFuelSupplyCap( src.hasFuelSupplyCap() );
     dest->setHasRecoveryCap( src.hasRecoveryCap() );
  
     return dest;
  }
  
  bool DtModEntityTranslator::isPortalPublishable( const DtBrokerObject* brokerObject ) const
  {
     // isPortalPublishable is called when we have an HLA object and we
     // want to figure out if its OK to pass it through the portal. This assert
     // just verifies that we understand the direction.
     assert( ! brokerObject->isPortalObject() );
  
     // We want to pass everything through, let all the filtering happen
     // coming out of  the portal. This function isn't required since non
     // of the built in translators restrict publication to the portal, and
     // the implementation you see here is the default implementation.
     return true;
  }
  
  // Translators' isRprPublishable method is called when we have a portal object
  // and we want to figure out if its OK to pass it through to the HLA Side. By
  // the time this method is called, asserts that the broker object is a portal
  // object and that it has a valid reflected object have already been performed.
  bool DtModEntityTranslator::isRprPublishable( const DtBrokerObject* brokerObj,
     const DtPortalReflectedEntity* refObj )
  {
     // Make sure that this Entity Type is not the Null Entity Type. This is an
     // HLA/VR-Link requirement. Most of the restrictions found in the isPublishable<>
     // methods will be restrictions on the outgoing protocol.
     if ( refObj->sr()->entityType() == DtEntityType() )
     {
        return false;
     }
  
     return true;
  }