HLA Netdump Example

This is a simple program that prints all received HLA Interactions and all HLA Object updates.

---

/****************************************************************************
 * Copyright (c) 2014 VT MAK
 * All rights reserved.
 ****************************************************************************/


#if DtHLA

#include <vl/exerciseConn.h>
#include <vlutil/vlKeyboard.h>
#include <vlutil/vlProcessControl.h>
#include <vl/reflectedEntityList.h>
#include <vl/reflectedAggregateList.h>
#include <vl/reflectedDesignatorListHLA.h>
#include <vl/reflectedEmitterSystemListHLA.h>
#include <vl/reflectedRadioReceiverListHLA.h>
#include <vl/reflectedRadioTransmitterListHLA.h>
#include <vl/reflectedEnvironmentProcessListHLA.h>
#include <vl/reflectedGriddedDataListHLA.h>
#include <vl/reflectedIffListHLA.h>
#include <vl/reflectedDiGuyObjectListHLA.h>
#include <vl/reflectedLinearObjectListHLA.h>
#include <vl/reflectedActiveSonarListHLA.h>
#include <vl/reflectedPropulsionNoiseListHLA.h>
#include <vl/reflectedAdditionalPassiveActivitiesListHLA.h>
#include <vl/reflectedLinearObjectListHLA.h>
#include <vl/fom.h>
#include <vl/interClassDesc.h>
#include <vl/interaction.h>
#include <vl/stateMsgHLA.h>
#include <vl/simpleRprFomMapper.h>
#include "stealthControlRegister.h"
#include <vlutil/vlString.h>
#include <cmdLine/cmdLine.h>
#include <vlutil/vlMiniDumper.h>

#include "ddmFedAmb13.h"
#include "ddmFedAmb1516.h"
#include "ddmFedAmb1516e.h"
#include <vl/geodeticRegion.h>

#include <vlutil/vlStringUtil.h>

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string>

void reflectCb( const DtStateMsg& msg, DtHlaObject* obj, void* usr );
void removeObjectCb( DtHlaObject* obj, void* usr );
void discoverObjectCb( DtHlaObject* obj, void* usr );
void receiveInterCb( DtInteraction* inter, void* usr );
int keybrdTick( void );


// Control characters that are used to clear the screen.  Empty string
// means don't clear.
std::string clearScreen("");
const std::string theSeperator("************************************************************\n");

DtCmdLine::SwitchArg          raw("r", "raw", "Print Raw HLA Data", false);
DtCmdLine::SwitchArg          fullReport("M", "noFullReport", "Disable Printing of Update Specifics", true);
DtCmdLine::SwitchArg          clearScreenSwitch("c", "clearScreen", "Clear Screen Between Updates", false);
DtCmdLine::SwitchArg          ddmDump("d", "ddmDump", "Print DDM region data", false);
DtCmdLine::SwitchArg          showRegionData("", "showRegionData", "Show Region Data with Updates", false);
DtCmdLine::SwitchArg          subWithDdm("", "subWithDdm", "Subscribe with DDM", false);

#if !DtHLA_1516
std::map<RTI::ObjectHandle, DtDdmFederateAmbassador::DtRegionInfo> myRegionInfo;
#else
std::map<RTI::ObjectInstanceHandle, DtDdmFederateAmbassador::DtRegionInfo> myRegionInfo;
#endif

RTI::DimensionHandle myXHandle;
RTI::DimensionHandle myYHandle;

#if VXWORKS
#define main realMain
DT_VXWORKS_APP(hlaNetdump)
#endif


void DtRtiShutdownHandler(const char * label, void* finished)
{
   //This callback may occur multiple times, since it gets called
   //every time we make an RTI call with an error. So, we mark this
   //as finished and make sure that we only signal once.
   int* finishedInt = (int*)finished;
   if (*finishedInt)
   {
      DtWarn << "Shutting down: " << label << std::endl;
   }
   *finishedInt = 0; //Order a shutdown;
}

std::vector<DtString> selectFomModules(DtCmdLine::MultiArg<DtString> cmdLineFomModuleNames, bool suppressDefaultModules)
{
   std::vector<DtString> result;
   std::vector<DtString> fomModuleNames;
   fomModuleNames.insert(fomModuleNames.end(), cmdLineFomModuleNames.getValue().begin(), cmdLineFomModuleNames.getValue().end());
   if (suppressDefaultModules == false)
   {
      // Filter out default modules which are overridden by command line
      bool foundVRFExt = false;
      bool foundDIGuy = false;
      bool foundLgrControl = false;
      bool foundVRFAggregate = false;
      std::vector<DtString>::iterator modName = fomModuleNames.begin();
      std::vector<DtString>::iterator end = fomModuleNames.end();
      while (modName != end)
      {
         if ((modName->findString("MAK-") != -1) && (modName->findString("_evolved") != -1))
         {
            if (modName->findString("-VRFExt-") != -1)
            {
               DtInfo << "Overide MAK-VRFExt-1_evolved.xml with " << *modName << std::endl;
               foundVRFExt = true;
            }
            else if (modName->findString("-DIGuy-") != -1)
            {
               DtInfo << "Overide MAK-DIGuy-1_evolved.xml with " << *modName << std::endl;
               foundDIGuy = true;
            }
            else if (modName->findString("-LgrControl-") != -1)
            {
               DtInfo << "Overide MAK-LgrControl-1_evolved.xml with " << *modName << std::endl;
               foundLgrControl = true;
            }
            else if (modName->findString("-VRFAggregate-") != -1)
            {
               DtInfo << "Overide MAK-VRFAggregate-1_evolved.xml with " << *modName << std::endl;
               foundVRFAggregate = true;
            }
         }
         modName++;
      }
      if (!foundVRFExt)
      {
         result.push_back("MAK-VRFExt-1_evolved.xml");
      }
      if (!foundDIGuy)
      {
         result.push_back("MAK-DIGuy-1_evolved.xml");
      }
      if (!foundLgrControl)
      {
         result.push_back("MAK-LgrControl-1_evolved.xml");
      }
      if (!foundVRFAggregate)
      {
         result.push_back("MAK-VRFAggregate-1_evolved.xml");
      }
   }
   result.insert(result.end(), fomModuleNames.begin(), fomModuleNames.end());
   std::vector<DtString>::iterator res = fomModuleNames.begin();
   std::vector<DtString>::iterator resEnd = fomModuleNames.end();
   while (res != resEnd)
   {
      DtInfo << "Loading FOM module " << *res << std::endl;
      res++;
   }
   return result;
}

int main( int argc, char* argv[] )
{
   // Used for error handling
   DtINIT_MINIDUMPER( "HLA-Netdump" );

   DtCmdLine::CmdLine cmd("HLA Netdump", ' ' ,  DtExerciseConn::vrlinkVersion().c_str());
   DtString fedType = "hlaNetdump";
#if DtHLA_1516_EVOLVED
   DtCmdLine::ValueArg<DtString> fedFileName("F","fedFileName", "Fed File Name", false, "RPR_FOM_v2.0_1516-2010.xml", "File Name",cmd);
#elif DtHLA_1516
   DtCmdLine::ValueArg<DtString> fedFileName("F","fedFileName", "Fed File Name", false, "MAK-RPR2-1-1.xml", "File Name",cmd);
#else
   DtCmdLine::ValueArg<DtString> fedFileName("F","fedFileName", "Fed File Name", false, "MAK-RPR2-1-1.fed", "File Name",cmd);
#endif
   DtCmdLine::ValueArg<DtString> execName("x","execName", "Fed Execution Name", false, "MAK-RPR-2.0", "string",cmd);
   DtCmdLine::ValueArg<DtString> fomMapperLib("f","fomMapperLib", "FOM Mapper Library Name", false, "", "string",cmd);
   DtCmdLine::ValueArg<DtString> fomMapperInitData("","fomMapperInitData", "FOM Mapper Initialization String", false, "", "string",cmd);
   DtCmdLine::ValueArg<double>   rprFomVersion("R","rprFomVersion", "RPR FOM Version", false, 2.0, "double",cmd);
   DtCmdLine::ValueArg<int>      rprFomRevision("","rprFomRevision", "Internal revision of the implementation of the RPR FOM version", false, 1, "int",cmd);
   DtCmdLine::SwitchArg          includeMom("m", "printMom", "print MOM HLA data", false,cmd);
   DtCmdLine::SwitchArg          passiveSubs("p", "passive", "Passive Subscribe", false,cmd);
#if DtHLA_1516_EVOLVED
   DtCmdLine::MultiArg<DtString> fomModuleNames("", "fomModules", "Add a FOM module", false, "string", cmd);
   DtCmdLine::SwitchArg          suppressDefaultModules("s", "suppressDefaultModules", "Do not load Default FOM Modules automatically", false, cmd);
#endif

   DtCmdLine::ValueArg<double>   regionOriginLat("", "regionLat", "Region Origin Latitude (degrees)", false, 0.0, "double", cmd);
   DtCmdLine::ValueArg<double>   regionOriginLon("", "regionLon", "Region Origin Longitude (degrees)", false, 0.0, "double", cmd);
   DtCmdLine::ValueArg<double>   regionSize("", "regionSize", "Region Size (in meters)", false, 10.0, "double", cmd);


   cmd.add(raw);
   cmd.add(clearScreenSwitch);
   cmd.add(fullReport);
   cmd.add(ddmDump);
   cmd.add(showRegionData);
   cmd.add(subWithDdm);
   cmd.parse(argc, argv);

   if (clearScreenSwitch)
   {
      // will not work on all terminals
      clearScreen = "\033[H\033[2J";
   }

   if (ddmDump || showRegionData)
   {
      DtExerciseConn::setFedAmbCreator(DtDdmFederateAmbassador::create);
   }

   DtExerciseConn::InitializationStatus status = DtExerciseConn::DtINIT_SUCCESS;
   DtExerciseConn* exConn = 0;
   if ( !fomMapperLib.getValue().isEmpty() )
   {  // A FOM Mapper shared library was specified
      if ( fomMapperInitData.getValue().isEmpty() )
      {
#if DtHLA_1516_EVOLVED
         std::vector<DtString> fomModules = selectFomModules(fomModuleNames, suppressDefaultModules.getValue());
         
         exConn = new DtExerciseConn( execName.getValue().c_str(),
            "", fedType.c_str(),
            fedFileName.getValue().c_str(),
            fomMapperLib.getValue().c_str(), (void*)0,
            "", fomModules, &status);
#else
         exConn = new DtExerciseConn( execName.getValue().c_str(),
            fedType.c_str(), fomMapperLib.getValue().c_str(),
            fedFileName.getValue().c_str(), (void*)0, &status );
#endif
      }
      else
      {
#if DtHLA_1516_EVOLVED
         std::vector<DtString> fomModules = selectFomModules(fomModuleNames, suppressDefaultModules.getValue());

         exConn = new DtExerciseConn( execName.getValue().c_str(),
            "", fedType.c_str(),
            fedFileName.getValue().c_str(),
            fomMapperLib.getValue().c_str(),
            (void*)fomMapperInitData.getValue().c_str(),
            "", fomModules, &status );
#else
         exConn = new DtExerciseConn( execName.getValue().c_str(),
            fedType.c_str(), fomMapperLib.getValue().c_str(),
            fedFileName.getValue().c_str(),
            (void*)fomMapperInitData.getValue().c_str(), &status );
#endif
      }

      if (status != DtExerciseConn::DtINIT_SUCCESS)
      {
         return 1;
      }

   }
   else
   {
      // FOM Mapper shared lib was not specified
      DtFomMapper* mapper = new DtRprFomMapper( rprFomVersion, rprFomRevision );
#if DtHLA_1516_EVOLVED

      std::vector<DtString> fomModules = selectFomModules(fomModuleNames, suppressDefaultModules.getValue());

      exConn = new DtExerciseConn( execName.getValue().c_str(),
         "", fedType.c_str(), fedFileName.getValue(),
         mapper, "", fomModules,
         &status );
#else
      exConn = new DtExerciseConn( execName.getValue().c_str(),
         fedType.c_str(), mapper, fedFileName.getValue().c_str(), &status );
#endif

      if (status != DtExerciseConn::DtINIT_SUCCESS)
      {
         return 1;
      }
      if (exConn->fom()->interClassByName("ViewControl"))
      {
         // Add view control interaction encoders and decoders
         DtStealthControlRegister(exConn);
      }
   }

   //Shutdown handler in order to smoothly end if the HLA exercise shuts down
   int forever = 1;
#ifdef DtHLA
   exConn->addRtiErrorCb(&DtRtiShutdownHandler, &forever);
#endif

   if(passiveSubs)
   {
      exConn->setPassiveMode();
   }

   DtDDMRegionSP region = DtDDMRegionSP();
   DtDDMRegionSet* regionSet = 0;

   if (subWithDdm)
   {
      try
      {
         DtGeodeticRegionSP geodRegion(new DtGeodeticRegion(exConn));
         DtVector geocentricPoint;
         DtGeodeticCoord geodOrigin(DtDeg2Rad(regionOriginLat.getValue()),
            DtDeg2Rad(regionOriginLon.getValue()), 0);
         geodOrigin.getGeocentric(geocentricPoint);
         geodRegion->setRegionBounds(geocentricPoint, regionSize.getValue(),
            regionSize.getValue());
         region = geodRegion;
         regionSet = new DtDDMRegionSet();
         regionSet->insert(region);
      }
      catch (RTI::Exception& except)
      {
         std::cout << "Caught exception creating region: " << except << std::endl;
         std::cout << "Exiting..." << std::endl;
         return -1;
      }
      catch (DtException& except)
      {
         std::cout << "Caught exception creating region: " << except << std::endl;
         std::cout << "Exiting..." << std::endl;
         return -1;
      }

   }

   if (ddmDump || showRegionData)
   {
      DtDdmFederateAmbassador* fedAmb = dynamic_cast<DtDdmFederateAmbassador*>(
         exConn->fedAmb());
      if (fedAmb)
      {
         try
         {
#if !DtHLA_1516
            RTI::SpaceHandle spaceHandle = exConn->rtiAmb()->getRoutingSpaceHandle(
               "BenchmarkGeographicSpace");
            myXHandle = exConn->rtiAmb()->getDimensionHandle(
               "X", spaceHandle);
            myYHandle = exConn->rtiAmb()->getDimensionHandle(
               "Y", spaceHandle);
#else
            myXHandle = exConn->rtiAmb()->getDimensionHandle(
               DtToWString("X"));
            myYHandle = exConn->rtiAmb()->getDimensionHandle(
               DtToWString("Y"));
#endif
            fedAmb->setXHandle(myXHandle);
            fedAmb->setYHandle(myYHandle);
         }
         catch (RTI::Exception& )
         {
            // ignore
         }
         catch (...)
         {
            // ignore
         }
      }
   }

   DtFom* fom = exConn->fom();

   // The Mom Manager classes have different names in 1516 than in
   // 1.3. We can read both types of files through VR-Link so
   // we check the fom type to see which class names to use.
   DtObjClassDesc *momObjectClass = 0;
   DtObjClassDesc *rootObjectClass = 0;
   DtInterClassDesc *momInterClass = 0;
   DtInterClassDesc *rootInterClass = 0;
   if (fom->fomType() == DtFom13)
   {
      rootObjectClass = fom->objClassByName("ObjectRoot");
      rootInterClass = fom->interClassByName("InteractionRoot");
      momObjectClass = fom->objClassByName( "Manager" );
      momInterClass = fom->interClassByName("Manager");
   }
   else
   {
      rootObjectClass = fom->objClassByName("HLAobjectRoot");
      rootInterClass = fom->interClassByName("HLAinteractionRoot");
      momObjectClass = fom->objClassByName( "HLAmanager" );
      momInterClass = fom->interClassByName("HLAmanager");
   }

   DtObjClassDesc* objClassDesc = 0;
#if DtHLA_1516
   for (std::list<DtObjClassDesc*>::const_iterator item = fom->objClassList().begin();
      item != fom->objClassList().end();
      ++item)
   {
      objClassDesc = const_cast<DtObjClassDesc*>(*item);
#else
   for( objClassDesc = fom->firstObjClass();
      objClassDesc;
      objClassDesc = fom->nextObjClass( objClassDesc ) )
   {
#endif
      if ( includeMom || !momObjectClass
         || (momObjectClass && !objClassDesc->isOfClass(momObjectClass->handle())))
      {
         if (rootObjectClass && (objClassDesc->handle() != rootObjectClass->handle()))
         {
            objClassDesc->subscribe();
         }
      }
   }

   DtInterClassDesc* intClassDesc = 0;
#if DtHLA_1516
   for (std::list<DtInterClassDesc*>::const_iterator item = fom->interClassList().begin();
      item != fom->interClassList().end();
      ++item)
   {
      intClassDesc = const_cast<DtInterClassDesc*>(*item);;
#else
   for( intClassDesc = fom->firstInterClass();
      intClassDesc;
      intClassDesc = fom->nextInterClass( intClassDesc ) )
   {
#endif
      if ( includeMom || !momInterClass
         || (momInterClass && !intClassDesc->isOfClass( momInterClass->handle() )) )
      {
         if (rootInterClass && (intClassDesc->handle() != rootInterClass->handle()))
         {
            intClassDesc->subscribe();
         }
      }
   }

   DtReflectedEntityList* rel = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given an ESR.
      // needed for non-raw mode
      rel = new DtReflectedEntityList( exConn, false, regionSet );
   }

   DtReflectedAggregateList* ral = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given an ASR.
      // needed for non-raw mode
      ral = new DtReflectedAggregateList( exConn, false, regionSet );
   }

   DtReflectedDesignatorList* rdl = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given a DSR.
      // needed for non-raw mode
      rdl = new DtReflectedDesignatorList( exConn, regionSet );
   }

   DtReflectedDIGuyObjectList* rdgl = 0;
   if ( ! raw && exConn->fom()->objClassByName("DIGuyObject") )
   {
      // Ensures that each hlaObject will be given a DSR.
      // needed for non-raw mode
      rdgl = new DtReflectedDIGuyObjectList( exConn, regionSet );
   }

   DtReflectedEmitterSystemList* rsl = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given a ESR.
      // needed for non-raw mode
      rsl = new DtReflectedEmitterSystemList( exConn, true, regionSet );
   }

   DtReflectedRadioReceiverList* rrl = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given an RSR.
      // needed for non-raw mode
      rrl = new DtReflectedRadioReceiverList( exConn, regionSet );
   }

   DtReflectedRadioTransmitterList* rtl = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given an TSR.
      // needed for non-raw mode
      rtl = new DtReflectedRadioTransmitterList( exConn, regionSet );
   }

   DtReflectedIffList *ril = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given an ISR.
      // needed for non-raw mode
      ril = new DtReflectedIffList( exConn, regionSet );
   }


   DtReflectedEnvironmentProcessList* repl = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given an EPSR.
      // needed for non-raw mode
      repl = new DtReflectedEnvironmentProcessList( exConn, regionSet );
   }

   DtReflectedGriddedDataList* rgdl = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given an GDSR.
      // needed for non-raw mode
      rgdl = new DtReflectedGriddedDataList( exConn, regionSet );
   }

   DtReflectedActiveSonarList* rasl = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given an GDSR.
      // needed for non-raw mode
      rasl = new DtReflectedActiveSonarList( exConn, regionSet );
   }

   DtReflectedPropulsionNoiseList* rpnl = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given an GDSR.
      // needed for non-raw mode
      rpnl = new DtReflectedPropulsionNoiseList( exConn, regionSet );
   }

   DtReflectedAdditionalPassiveActivitiesList* rapal = 0;
   if ( !raw )
   {
      // Ensures that each hlaObject will be given an asr.
      // needed for non-raw mode
      rapal = new DtReflectedAdditionalPassiveActivitiesList( exConn, regionSet );
   }

   DtReflectedLinearObjectList* rlol = 0;
   if ( !raw )
   {
       // Ensures that each hlaObject will be given an asr.
       // needed for non-raw mode
       rlol  = new DtReflectedLinearObjectList( exConn, regionSet );
   }


#if DtHLA_1516
   exConn->addDiscoverObjectCallback( RTI::ObjectClassHandle(), discoverObjectCb, 0 );
   exConn->addInteractionCallback( RTI::InteractionClassHandle(), receiveInterCb, 0,
      region );
#else
   exConn->addDiscoverObjectCallback( 0, discoverObjectCb, 0 );
   exConn->addInteractionCallback( 0, receiveInterCb, 0, region );
#endif

   // Main application loop
   while( forever )
   {
      if ( keybrdTick() == -1 )
      {
         break;
      }
      exConn->drainInput();
      DtSleep( 0.001 );
   }

   if (forever)
   {
#if DtHLA_1516
      for (std::list<DtObjClassDesc*>::const_iterator item = fom->objClassList().begin();
         item != fom->objClassList().end();
         ++item)
      {
         objClassDesc = const_cast<DtObjClassDesc*>(*item);
#else
      for( objClassDesc = fom->firstObjClass();
         objClassDesc;
         objClassDesc = fom->nextObjClass( objClassDesc ) )
      {
#endif
         if (includeMom || !momObjectClass
            || (momObjectClass && !objClassDesc->isOfClass(momObjectClass->handle())))
         {
            objClassDesc->unsubscribe();
         }
      }

#if DtHLA_1516
      for (std::list<DtInterClassDesc*>::const_iterator item = fom->interClassList().begin();
         item != fom->interClassList().end();
         ++item)
      {
         intClassDesc = const_cast<DtInterClassDesc*>(*item);
#else

      for( intClassDesc = fom->firstInterClass();
         intClassDesc;
         intClassDesc = fom->nextInterClass( intClassDesc ) )
      {
#endif
         if (includeMom || !momInterClass
            || (momInterClass && !intClassDesc->isOfClass(momInterClass->handle())))
         {
            intClassDesc->subscribe();
         }
      }
   }

   DtDELETE ( rel );
   DtDELETE ( ral );
   DtDELETE ( rdl );
   DtDELETE ( rsl );
   DtDELETE ( rrl );
   DtDELETE ( rtl );
   DtDELETE ( ril );
   DtDELETE ( repl );
   DtDELETE ( rgdl );
   DtDELETE ( rasl );
   DtDELETE ( rpnl );
   DtDELETE ( rapal );

   if (subWithDdm)
   {
      delete regionSet;
      region.reset();
   }

   DtDELETE ( exConn );

   return 0;
}


void reflectCb( const DtStateMsg& msg, DtHlaObject* obj, void* usr )
{
   DtExerciseConn* exConn = obj->exerciseConn();
   DtClock* clock = obj->exerciseConn()->clock();
   DtString lastProducingFederateName = "Unknown";
#if DtHLA_1516_EVOLVED
   lastProducingFederateName = obj->lastProducingFederate();
#endif

   if (ddmDump)
   {
      DtDdmFederateAmbassador* ddmFedAmb = dynamic_cast<DtDdmFederateAmbassador*>(
         obj->exerciseConn()->fedAmb());

      const DtDdmFederateAmbassador::DtRegionInfo& regionInfo =
         ddmFedAmb->regionInfoForObject(obj->objectId());

      bool printProducingFederate = false;

      if (regionInfo.infoSet)
      {
         std::map<RTI::ObjectHandle, DtDdmFederateAmbassador::DtRegionInfo>::iterator iter =
            myRegionInfo.find(obj->objectId());

         if (iter == myRegionInfo.end())
         {
            myRegionInfo[obj->objectId()] = regionInfo;
            std::cout
               << clearScreen
               << theSeperator
               << "*************** Update at "
               << clock->elapsedRealTime() << "secs ***************\n" << theSeperator
               << "Object: " << obj->objectId() << "\n"
               << "Name: " << obj->name() << "\n";
#if DtHLA_1516_EVOLVED
            if (!lastProducingFederateName.isEmpty())
            {
               std::cout
                  << "Updated by Federate: "
                  << lastProducingFederateName
                  << "\n";
            }
#endif
            std::cout
               << "DDM Info: " << "\n"
               << " -- Lower X Bound: " << regionInfo.lowerXBound << "\n"
               << " -- Upper X Bound: " << regionInfo.upperXBound << "\n"
               << " -- Lower Y Bound: " << regionInfo.lowerYBound << "\n"
               << " -- Upper Y Bound: " << regionInfo.upperYBound << "\n";
         }
         else
         {
            // See if it's changed.  If so, update it and print it out
            const DtDdmFederateAmbassador::DtRegionInfo& lastRegion = iter->second;
            if (regionInfo.lowerXBound != lastRegion.lowerXBound ||
                regionInfo.upperXBound != lastRegion.upperXBound ||
                regionInfo.lowerYBound != lastRegion.lowerYBound ||
                regionInfo.upperYBound != lastRegion.upperYBound)
            {
               myRegionInfo[obj->objectId()] = regionInfo;
               std::cout
                  << clearScreen
                  << theSeperator
                  << "*************** Update at "
                  << clock->elapsedRealTime() << "secs ***************\n" << theSeperator
                  << "Object: " << obj->objectId() << "\n"
                  << "Name: " << obj->name() <<  "\n";
#if DtHLA_1516_EVOLVED
               if (!lastProducingFederateName.isEmpty())
               {
                  std::cout
                     << "Updated by Federate: "
                     << lastProducingFederateName << "\n";
               }
#endif
               std::cout
                  << "DDM Info: " << "\n"
                  << " -- Lower X Bound: " << regionInfo.lowerXBound << "\n"
                  << " -- Upper X Bound: " << regionInfo.upperXBound << "\n"
                  << " -- Lower Y Bound: " << regionInfo.lowerYBound << "\n"
                  << " -- Upper Y Bound: " << regionInfo.upperYBound << "\n";
            }
         }
      }
      else
      {
         std::cout
            << clearScreen
            << theSeperator
            << "*************** Update at "
            << clock->elapsedRealTime() << "secs ***************\n"
            << theSeperator
            << "Object: " << obj->objectId() << "\n"
            << "Name: " << obj->name() << "\n";
#if DtHLA_1516_EVOLVED
         if (!lastProducingFederateName.isEmpty())
         {
            std::cout
               << "Updated by Federate: "
               << lastProducingFederateName
               << "\n";
         }
#endif
         std::cout
            << "DDM Info: " << "\n"
            << " -- No DDM Region information set." << "\n";
      }
   }
   else
   {

      std::cout
         << clearScreen
         << theSeperator
         << "*************** Update at "
         << clock->elapsedRealTime() << "secs ***************\n"
         << theSeperator;
#if DtHLA_1516_EVOLVED
      if (!lastProducingFederateName.isEmpty())
      {
         std::cout
            << "Updated by Federate: "
            << lastProducingFederateName;
         std::cout
            << "\n";
      }
#endif

      if ( raw )
      {
         msg.print( obj->exerciseConn(), obj->objectClassHandle() );
      }
      else
      {
         msg.print( obj, fullReport );
      }
      if (showRegionData)
      {
         DtDdmFederateAmbassador* ddmFedAmb = dynamic_cast<DtDdmFederateAmbassador*>(
            obj->exerciseConn()->fedAmb());
         const DtDdmFederateAmbassador::DtRegionInfo& regionInfo =
            ddmFedAmb->regionInfoForObject(obj->objectId());
         std::cout << "DDM Region Data: ";

         if (regionInfo.infoSet)
         {
            std::cout
               << "\n"
               << " -- Lower X Bound: " << regionInfo.lowerXBound << "\n"
               << " -- Upper X Bound: " << regionInfo.upperXBound << "\n"
               << " -- Lower Y Bound: " << regionInfo.lowerYBound << "\n"
               << " -- Upper Y Bound: " << regionInfo.upperYBound << "\n";
         }
         else
         {
            std::cout << "None" << "\n";
         }
      }

      std::cout << std::endl;
   }
}


void removeObjectCb( DtHlaObject* obj, void* usr )
{
   obj->removeRemoveObjectCb( removeObjectCb, 0 );
   obj->removePostReflectCb( reflectCb, 0 );
}


void discoverObjectCb( DtHlaObject* obj, void* usr )
{
   obj->addPostReflectCb( reflectCb, 0 );
   obj->addRemoveObjectCb( removeObjectCb, 0 );
}


void receiveInterCb( DtInteraction* inter, void* usr )
{
   DtClock* clock = inter->exerciseConn()->clock();

   std::cout << clearScreen << theSeperator << "*************** Interaction at "
      << clock->elapsedRealTime() << "secs ***************\n" << theSeperator;

   if (!ddmDump)
   {

      if ( raw )
      {
         inter->printParams( true );
      }
      else
      {
         inter->print();
      }

      if (showRegionData)
      {
         DtDdmFederateAmbassador* ddmFedAmb = dynamic_cast<DtDdmFederateAmbassador*>(
            inter->exerciseConn()->fedAmb());

         DtDdmFederateAmbassador::DtRegionInfo regionInfo = ddmFedAmb->lastInteractionRegion();
         ddmFedAmb->clearLastInteractionRegion();
         std::cout << "DDM Region Data: ";

         if (regionInfo.infoSet)
         {
            std::cout << std::endl;
            std::cout << " -- Lower X Bound: " << regionInfo.lowerXBound << std::endl;
            std::cout << " -- Upper X Bound: " << regionInfo.upperXBound << std::endl;
            std::cout << " -- Lower Y Bound: " << regionInfo.lowerYBound << std::endl;
            std::cout << " -- Upper Y Bound: " << regionInfo.upperYBound << std::endl;
         }
         else
         {
            std::cout << "None" << std::endl;
         }
      }
      std::cout << std::endl;
   }
   else
   {
      std::cout << "Interaction Class: " << inter->interactionClassName() << std::endl;
      DtDdmFederateAmbassador* ddmFedAmb = dynamic_cast<DtDdmFederateAmbassador*>(
         inter->exerciseConn()->fedAmb());

      DtDdmFederateAmbassador::DtRegionInfo regionInfo = ddmFedAmb->lastInteractionRegion();
      ddmFedAmb->clearLastInteractionRegion();

      if (regionInfo.infoSet)
      {
         std::cout << " -- Lower X Bound: " << regionInfo.lowerXBound << std::endl;
         std::cout << " -- Upper X Bound: " << regionInfo.upperXBound << std::endl;
         std::cout << " -- Lower Y Bound: " << regionInfo.lowerYBound << std::endl;
         std::cout << " -- Upper Y Bound: " << regionInfo.upperYBound << std::endl;
      }
      else
      {
         std::cout << "-- No Interaction Region" << std::endl;
      }
   }
}


// ---------keyboard input ----------------------
int keybrdTick()
{
   char* keyPtr = DtPollBlockingInputLine();
   if ( !keyPtr )
   {
      return 0;  // no input
   }

   switch( *keyPtr )
   {
      case 'q':
      case 'Q':
         {
            return -1;
         }
      default:
         {
            std::cout <<  "Unrecognized command key <"<< *keyPtr <<">" << std::endl;
            break;
         }
   }
   return 0;
}

#endif // DtHLA

---