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) 2012 VT MAK
   * All rights reserved.
   ****************************************************************************/
  
  // This simple example creates a class called DtModEntityTranslator
  // which overrides some behaviors of the DtEntityTranslator. This example
  // will install the new translator (by replacing the old). 
  
  #include <modEntTrans.h>
  
  #include <hlaBroker/hlaBroker.h>
  #include <hlaBroker/hlaBrokerApp.h>
  #include <hlaBroker/hlaBrokerInitializer.h>
  
  #include <portal/pConnection.h>
  
  #include <vlutil/vlExceptions.h>
  
  #include <iostream>
  
  using namespace MAKVrExchange;
  using namespace MAKVrExchange::DtHlaBroker;
  
  int main( int argc, char* argv[] )
  {
     try
     {
        DtInfo << "Starting Modified HLA Broker Example" << std::endl;
  
        // Load the configuration options
        DtHlaBrokerInitializer* hlaInit =
           new DtHlaBrokerInitializer( argc, argv, DtPortalConnection::version().c_str() );
        hlaInit->parseCmdLine(); //Automatically loads the file specified by the CmdLine
  
        DtHlaBrokerApp brokerApp( hlaInit );
        if ( ! hlaInit->showConnectionInfoDialog() )
        {
           // Install the modified translator by creating a default factory. This needs
           // to be done before the call to DtBrokerApp::run() where all the translator
           // instances are created. The translator name is used by the factory, so 
           // if you want to replace a translator it needs to have the same name. 
           brokerApp.hlaBroker()->objectTranslatorFactory()->addCreator<DtModEntityTranslator>();
           brokerApp.run();
        }
        else
        {
           brokerApp.showInfoDialog();
        }
     }
     DtCATCH_AND_WARN( std::cout )
  
     return 0;
  }

  ---

  /*****************************************************************************
   * Copyright (c) 2012 VT MAK
   * All rights reserved.
   ****************************************************************************/
  
  
  #include "modEntTrans.h"
  #include <hlaBroker/hlaBroker.h>
  #include <hlaBroker/brokerObject.h>
  
  // Portal includes
  #include <portal/pObjectPublisher.h>
  #include <portal/pEntity.h>
  
  // VR-Link includes
  #include <vl/reflEntList.h>
  #include <vl/entityPub.h>
  #include <vl/baseEntitySR.h>
  
  #include <assert.h>
  
  using namespace MAKVrExchange;
  using namespace DtHlaBroker;
  
  DtModEntityTranslator::DtModEntityTranslator(
        DtHlaBrokerNamespace::DtHlaBroker* broker )
     : DtEntityTranslator( broker )
  {
  }
  
  DtModEntityTranslator::~DtModEntityTranslator()
  {
  }
  
  const char* DtModEntityTranslator::virtualTranslatorName() const
  {
     return DtModEntityTranslator::translatorName();
  }
  
  void DtModEntityTranslator::receiveHlaUpdate( DtReflectedEntity* refObj )
  {
  
     DtEntityTranslator::receiveHlaUpdate( refObj );
  }
  
  void DtModEntityTranslator::receivePortalUpdate(
     const DtPortalReflectedEntity& reflectedObj )
  {
     // 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::receivePortalUpdate( reflectedObj );
  
     // Lets lookup the broker object for this reflected object. This is required
     // to  find the publisher, which we need to fill data in.
     DtBrokerObject* brokerObject = findBrokerObject( &reflectedObj );
     assert( brokerObject );
  
     // Set the last time this broker was updated. Useful for GUI and
     // other record keeping.
     brokerObject->setLastUpdate( broker()->simTime() );
  
     // Get the Entity State Repository.
     const DtPortalEntity& sr = *(reflectedObj.sr());
  
     // Set the marking text in the broker. This is useful for the GUI and
     // other record keeping.
     brokerObject->setMarkingText( sr.markingText() );
  
  
     // Lets figure out if this is publishable yet, if it is lets mark it as such.
     if ( ! brokerObject->isPublishable() )
     {
        brokerObject->setIsPublishable( isHlaPublishable(brokerObject) );
     }
  
     // This calls all callbacks for this object, and is used to update the GUI
     // if required. This is called by the base class, but multiple calls won't be
     // a problem.
     callObjectUpdateCallbacks( brokerObject );
  
     // Ok, if we have dropped this object, or if it was filtered, we should bail out,
     // there will be no publisher for it.
     if ( brokerObject->isDropped() )
     {
        return;
     }
  
     // Get a Pointer to the publisher...
     DtEntityPublisher* publisher =
        static_cast<DtEntityPublisher*>( brokerObject->publisherPtr() );
     assert( publisher );
  
     // get a reference to the state repository.
     DtEntityStateRepository& newSr = *(publisher->esr());
  
     // Set a few attribute values
     newSr.setMarkingText( sr.markingText() );
     newSr.setPowerPlantOn( sr.powerPlantOn() );
     newSr.setDamageState( (DtDamageState) sr.damageState() );
     newSr.setEngineSmokeOn( sr.engineSmokeOn() );
     newSr.setFlamesPresent( sr.flamesPresent() );
     newSr.setHasFuelSupplyCap( sr.hasFuelSupplyCap() );
     newSr.setHasRecoveryCap( sr.hasRecoveryCap() );
  }
  
  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->protocol() == DtBrokerObject::hla );
  
     // 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.
     return true;
  }
  
  
  bool DtModEntityTranslator::isHlaPublishable( const DtBrokerObject* brokerObject ) const
  {
     // isHlaPublishable 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. We can
     // do a little assert for  all isHlaPublishable functions to make sure we
     // are sane.
     assert( brokerObject->protocol() == DtBrokerObject::portal );
  
     // Do our not so safe cast. Its only safe because we have made it past
     // the assert above.
     const DtPortalReflectedEntity* reflectedObj =
        static_cast<const DtPortalReflectedEntity*>( brokerObject->reflectedObjPtr() );
  
     // There should always be a reflected object, there will not be
     // a publisher at this stage.
     assert( reflectedObj );
  
     // 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 ( reflectedObj->sr()->entityType() == DtEntityType() )
     {
        return false;
     }
  
     return true;
  }