simpleTime13.cxx and simpleTimeFedAmb13.cxx (simpleTimeFedAmb13.h) have the RTI calls and federate ambassador calls for the HLA 1.3 version of simpleTime.

This page has the code for the following files:

simpleTime13.cxx

/*******************************************************************************
** Copyright (c) 1992-2013 VT MAK
** All rights reserved.
*******************************************************************************/
// A simple federate that updates an object with attributes whose values
// are the name of the attribute. Objects from other simple federates
// are discovered and reflected. The string values are byte encoded to allow
// compatibility between 1.3 and 1516
#ifdef WIN32
#pragma warning(disable: 4251)
#pragma warning(disable: 4786)
#pragma warning(disable: 4290)
#include <winsock2.h>
#include <process.h>
#else
#include <unistd.h>
#include <stdlib.h>
#include <sched.h>
#include <netdb.h>
#endif
#include <stdio.h>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <sstream>
#include <iterator>
#include "RTI.hh"
#include "fedtime.hh"
#include "simpleTimeFedAmb13.h"
#include "simpleTimeKeyboard.h"
#include "simpleTimeStringUtil.h"
using namespace std;
bool parseCmdLine( int argc, char* argv[] );
// Handles keyboard input without blocking
keyboard input;
// Data shared between federate and federate ambassador
DtTalkAmbData theAmbData;
// The object class name
string theClassName = "BaseEntity";
// The interaction class name
string fireInteractionName = "WeaponFire";
string detonateInteractionName = "MunitionDetonation";
// The object class handle (to be retrieved from RTI).
RTI::ObjectClassHandle theClassHandle;
// The interaction class handles (to be retrieved from RTI).
RTI::InteractionClassHandle fireInteractionHandle;
RTI::InteractionClassHandle detonateInteractionHandle;
// The object instance handle (to be retrieved from the RTI).
RTI::ObjectHandle theObjectHandle;
// This federation of simple objects has a single master object, (determined by command line arguments)
//  The master federate will keep the other federates from entering their main loop of execution until
//  all of numFederates have joined.
bool Master(false);
// numFederates is the number of federates (including the master) that the master should wait to join the 
//  federation before it allows any federate to enter its main loop. 
// This variable is only used by the master federate.
int numFederates(0);
// dedicatedMachine indicates that this federate will be as greedy as possible with the processor.
 // this is helpful for users who have two federates on separate machines and want them to time-step
 // as quickly as possible.  
// If each federate is not on a dedicated machine, this may actually slow federates.
bool dedicatedMachine(false);
// unManaged Federate will allow you to see the operation of a time regulating and constrained federate
   // when the federate does not wait for the "begin" synchronization before executing.
bool unManagedFederate(false);
// sleepTime (indicated in milliseconds, defaults to 850ms), is the time that a federate will sleep between 
 // iterations of the main loop.  This value is invalidated if (above) dedicatedMachine is set. 
// 850 ms is selected to allow the user to see the time advances progressing at a very slow pace.  
// There is no need to set this to a value > 50ms or so other than allowing the user to watch the text scroll.
int sleepTime(850);
// the name of the fed file this federate will use. Can be overridden with cmd line parameter fedFile
string fedFileName("MAKsimpletime.fed");
// the name of the federation we'll create.
string federationName("MAKsimpletime");
// The name of the initialization synchronization point that the master and other federates use to establish a 
 // synchronized starting point for the federation. 
string initSyncPointLabel("begin");
// Create the federation execution
void createFedEx(RTI::RTIambassador* rtiAmb,
                 string const& fedName,
                 string const& fedFile)
{
   std::cout  << "createFederationExecution "
         << fedName.c_str() << " "
         << fedFile.c_str() << endl;
   try
   {
      rtiAmb->createFederationExecution(fedName.c_str(), fedFile.c_str());
   }
   catch(RTI::FederationExecutionAlreadyExists& ex)
   {
      std::cout  << "Could not create Federation Execution: "
            << "FederationExecutionAlreadyExists: "
            <<  ex._name << " "
            << ex._reason << endl;
   }
   catch(RTI::Exception& ex)
   {
      std::cout  << "Could not create Federation Execution: " << endl
            << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl;
      exit(0);
   }
   rtiAmb->tick(0.1, 0.2);
   std::cout << "Federation Created" << endl;
}
// Join the federation execution
void joinFedEx(
   RTI::RTIambassador* rtiAmb, MyFederateAmbassador* fedAmb,
   string const& federateType)
{
   bool joined=false;
   const int maxTry  = 10;
   int numTries = 0;
   std::cout  << "joinFederationExecution "
         << federateType.c_str() << " "
         << federationName.c_str() << endl;
   while (!joined && numTries++ < maxTry)
   {
      try
      {
         rtiAmb->joinFederationExecution(federateType.c_str(),
            federationName.c_str(), fedAmb);
         joined = true;
      }
      catch(RTI::FederationExecutionDoesNotExist)
      {
         std::cout  << "FederationExecutionDoesNotExist, try "
               << numTries << "out of "
               << maxTry << endl;
         continue;
      }
      catch(RTI::Exception& ex)
      {
         std::cout  << "RTI Exception: "
               << ex._name << " "
               << ex._reason << endl;
         return;
      }
      rtiAmb->tick(0.1, 0.2);
   }
   if (joined)
   {
      std::cout << "Joined Federation." << endl;
   }
   else
   {
      std::cout << "Giving up." << endl;
      rtiAmb->destroyFederationExecution(federationName.c_str());
      exit(0);
   }
}
// Resign and destroy the federation execution
void resignAndDestroy( RTI::RTIambassador* rtiAmb )
{
   try
   {
      rtiAmb->resignFederationExecution(RTI::DELETE_OBJECTS);
      rtiAmb->destroyFederationExecution(federationName.c_str());
   }
   catch (RTI::Exception& ex)
   {
      std::cout  << "RTI Exception: "
         << ex._name << " "
         << ex._reason << endl
         << "During resign and destroy. " << endl;
   }
}
// Publish and subscribe the object class attributes.
// Register an object instance of the class.
bool publishSubscribeAndRegisterObject(RTI::RTIambassador* rtiAmb)
{
   // Declare the attributes that we will be publishing.
   theAmbData.ourAttrs.insert(string("AccelerationVector"));
   theAmbData.ourAttrs.insert(string("DeadReckoningAlgorithm"));
   theAmbData.ourAttrs.insert(string("Orientation"));
   theAmbData.ourAttrs.insert(string("WorldLocation"));
   theAmbData.ourAttrs.insert(string("VelocityVector"));
   theAmbData.ourAttrs.insert(string("DamageState"));
   // Get the object class handle
   try
   {  
      theClassHandle = rtiAmb->getObjectClassHandle(theClassName.c_str());
      theAmbData.objectClassMap[theClassHandle] = theClassName;
   }
   catch (RTI::Exception& ex)
   {
      std::cout  << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl
            << "Could not get object class handle: "
            << theClassName.c_str() << endl;
      return false;
   }
                        
   
   // Construct an attribute handle set
   string attrName;   
   RTI::AttributeHandleSet* hSet =
      RTI::AttributeHandleSetFactory::create(theAmbData.ourAttrs.size());
   // Create an appropriately sized Attribute Handle Value Pair Set
   theAmbData.attrValues = RTI::AttributeSetFactory::create(theAmbData.ourAttrs.size());   
   set<string>::iterator attributeSetIterator = theAmbData.ourAttrs.begin();
   set<string>::iterator attributeSetEnd = theAmbData.ourAttrs.end();
   string currentAttribute("");
   RTI::AttributeHandle retrievedHandle;    
   for ( ; attributeSetIterator != attributeSetEnd; ++attributeSetIterator )
   {
      currentAttribute = *attributeSetIterator;
      try
      {
         retrievedHandle = 
            rtiAmb->getAttributeHandle(currentAttribute.c_str(), theClassHandle);
      }
      catch (RTI::Exception& ex)
      {
         std::cout  << "RTI Exception: "
               << ex._name << " "
               << ex._reason << endl
               << "Could not get attribute handle "
               << attrName.c_str() << endl;
         return false;
      }     
      // Populate the AttributeHandleSet               
      hSet->add(retrievedHandle);
      
      // Populate the attribute handle value pair set with the
           // values containing the attribute names   
      // Attribute values will be just the name of the attribute.
      theAmbData.attrValues->add(retrievedHandle,
         currentAttribute.c_str(), currentAttribute.length()+1);
      theAmbData.theAttrNameHandleMap.insert( std::make_pair(
         currentAttribute, retrievedHandle));
   }        
            
    // Publish and subscribe
   int cnt=0;
   try
   {
      rtiAmb->publishObjectClass(theClassHandle, *hSet);
      rtiAmb->tick(0.1, 0.2);
      cnt=1;
      rtiAmb->subscribeObjectClassAttributes(theClassHandle, *hSet);
      rtiAmb->tick(0.1, 0.2);
   }
   catch (RTI::Exception& ex)
   {
      std::cout  << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl
            << "Could not "
            << (cnt ? "publish" : "subscribe") << endl;
      delete hSet;
      return false;
   }
   string objectName("Talk");
   // Register the object instance
   try
   {
      unsigned int objId = abs(getpid());
      stringstream pid;
      pid << objId;
      objectName += pid.str();
      theObjectHandle = rtiAmb->registerObjectInstance(theClassHandle,
         objectName.c_str());      
      // Add name-handle to map
      theAmbData.objectInstanceMap[theObjectHandle] =
         rtiAmb->getObjectInstanceName(theObjectHandle);
      rtiAmb->tick(0.1, 0.2);
   }
   catch (RTI::Exception& ex)
   {
      std::cout  << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl
            << "Could not  Register Object "
            << objectName.c_str()
            << " with class "
            << theClassName.c_str() << endl;
      delete hSet;
      return false;
   }
   std::cout  << "Registered object "
         << objectName.c_str()
         << " with class name "
         <<  theClassName.c_str() << endl;
   delete hSet;   
   return true;
}
// Publish and Subscribe to an interaction class
bool publishAndSubscribeInteraction(RTI::RTIambassador* rtiAmb)
{
   theAmbData.ourParms.insert("EventIdentifier");
   theAmbData.ourParms.insert("FiringLocation");
   theAmbData.ourParms.insert("FiringObjectIdentifier");
   theAmbData.ourParms.insert("MunitionObjectIdentifier");
   theAmbData.ourParms.insert("TargetObjectIdentifier");   
   // Get the interaction class handle
   try
   {  
      fireInteractionHandle = rtiAmb->getInteractionClassHandle(fireInteractionName.c_str());
      theAmbData.interactionClassMap[fireInteractionHandle] = fireInteractionName;
      detonateInteractionHandle = rtiAmb->getInteractionClassHandle(
         detonateInteractionName.c_str());
      theAmbData.interactionClassMap[detonateInteractionHandle] = detonateInteractionName;
   }
   catch (RTI::Exception& ex)
   {
      std::cout  << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl
            << "Could not get interaction class handle: "
            << theClassName.c_str() << endl;
      return false;
   }
   // Construct a parameter handle value pair set with the
   // values containing the parameter names
   theAmbData.paramValues = RTI::ParameterSetFactory::create(theAmbData.ourParms.size());
      
   // Get the parameter handles and construct the name-handle map
   string paramName;
  
   set<string>::const_iterator parameterIter = theAmbData.ourParms.begin();
   set<string>::const_iterator parameterEnd = theAmbData.ourParms.end();
   RTI::ParameterHandle retrievedHandle;
   for ( ; parameterIter != parameterEnd; ++parameterIter )
   {
      paramName = *parameterIter;         
      try
      {
         retrievedHandle = 
            rtiAmb->getParameterHandle(paramName.c_str(), fireInteractionHandle);
      }
      catch (RTI::Exception& ex)
      {
         std::cout  << "RTI Exception: "
               << ex._name << " "
               << ex._reason << endl
               << "Could not get parameter handle "
               << paramName.c_str() << endl;
         return false;
      }
      // Parameter values will be just the name of the attribute.
      theAmbData.paramValues->add(retrievedHandle,
         paramName.c_str(), paramName.length()+1); 
      theAmbData.theParamNameHandleMap.insert( std::make_pair(
         paramName, retrievedHandle));
   }
   
   
   // Publish and subscribe
   int cnt=0;
   try
   {
      rtiAmb->publishInteractionClass(fireInteractionHandle);
      rtiAmb->tick(0.1, 0.2);
      rtiAmb->publishInteractionClass(detonateInteractionHandle);
      rtiAmb->tick(0.1, 0.2);
      cnt=1;
      rtiAmb->subscribeInteractionClass(fireInteractionHandle);
      rtiAmb->tick(0.1, 0.2);
      rtiAmb->subscribeInteractionClass(detonateInteractionHandle);
      rtiAmb->tick(0.1, 0.2);
   }
   catch (RTI::Exception& ex)
   {
      std::cout  << "RTI Exception: "
            << ex._name << " "
            << ex._reason << endl
            << "Could not "
            << (cnt ? "publish" : "subscribe")
            << " to interaction." << endl;
      return false;
   }
   std::cout  << "Subscribed to interaction class: "
         << fireInteractionName.c_str()
         << " with handle: "
         <<  fireInteractionHandle << endl
         << " and interaction class "
         << detonateInteractionName.c_str() 
         << " with handle: "
         << detonateInteractionHandle << endl;
   return true;
}
// This function will exit the program after resigning the federation.
void cleanUpProgram(RTI::RTIambassador* rtiAmb)
{
   try 
   {
      if ( theAmbData.isRegulating )
      {
         rtiAmb->disableTimeRegulation();
      }
      
      // Resign and destroy federation
      resignAndDestroy(rtiAmb);
      delete rtiAmb;
   }
   catch (RTI::Exception& ex)
   {
      std::cout  << "RTI Exception (during exit): "
         << ex._name << " "
         << ex._reason << endl;
   }
#ifdef WIN32
   WSACleanup();
#endif
   
   exit(0);
}
// This is a simple function to output a FedTime object.  
// Helpful for debugging and general diagnostics.
void printOutFedTime(RTI::FedTime* time)
{ 
   char* buff = new char[time->getPrintableLength()];
   time->getPrintableString(buff);
   std::cout << atof(buff) ;   
   delete [] buff;   
}
// platform independent sleep function.
void sleepFunction()
{  
   // On a dedicated machine we do not sleep, making this function a nop
   if ( ! dedicatedMachine )
   {   
#ifdef WIN32
         Sleep(sleepTime);
#else
         usleep(sleepTime * 1000);
#endif
   }
}
// platform independent sleep, for a predetermined small time. (10 ms)
void minimalSleepFunction()
{        
#ifdef WIN32
   Sleep(10);
#else
   usleep(10 * 1000);
#endif
   
}
// simply yields the current thread independent of the platform
void yieldFunction()
{
   // On a dedicated machine we do not yield the processor, making this function a nop
   if ( ! dedicatedMachine )
   {
#ifdef _WIN32
      Sleep( 0 );
#elif __solaris__
      yield();
#else
      sched_yield();
#endif 
   }
}
// This function causes the federate to become time constrained and regulating.
// If the user presses q while the federate is waiting for the callback from the RTI
 // making it time constrained, the federate will quit.
void becomeConstrainedAndRegulating(RTI::RTIambassador* rtiAmb, 
                                    RTI::FedTime* currentTime, 
                                    RTI::FedTime* lookAhead  )
{
   try
   {      
      rtiAmb->enableTimeRegulation((*currentTime), (*lookAhead));
      std::cout << "Waiting to become Time Regulating \n";
      
      rtiAmb->tick(.1, 1);
      while ( ! theAmbData.isRegulating )
      {
         std::cout << ".";
         if (input.keybrdTick() < 0)
         {
            cleanUpProgram(rtiAmb);
         }
         minimalSleepFunction();
         rtiAmb->tick(.1, 1);      
      }      
      std::cout << endl;
      
      rtiAmb->enableTimeConstrained();
      std::cout << "Waiting to become Time Constrained  \n";
      rtiAmb->tick(.1, 1);
      while ( ! theAmbData.isConstrained ) 
      {   
         std::cout << ".";
         if (input.keybrdTick() < 0 )
         {
            cleanUpProgram(rtiAmb);  
         }
         rtiAmb->tick(.1, 1);                           
         if ( ! theAmbData.isConstrained )
         {
            yieldFunction();
         }
      }      
      std::cout << endl;
   }
   catch (RTI::Exception& ) 
   {
      std::cout << " unable to become regulating and constrained\n"
                << " Exiting ...\n";
      cleanUpProgram(rtiAmb);
   }
}
// This function will not exit until numFederates (as indicated to the master 
// of this federation execution) have been made known to the master federate.
// The master then waits to have discovered  numFederates - 1, 
// (i.e. all federates but itself), then accomplished by the master registering
//  a sync point. From this point the master behaves exactly as the other federates.
// The non-master federates wait for the announceSyncPoint callback, indicating that
 // the master federate has discovered all necessary federates. They each non-master federate
// will call synchPointAchieved, indicating to the RTI that they are prepared to start.
//  Then both master and non-master simply wait for the RTI federationSynchronized callback.
//Note:  An alternative to waiting for object discovery callbacks to indicate a joined federate
 // is to use MOM interactions.  The master can subscribe to a MOM interaction and have a joined
 // federate send that interaction prior to entering the synchronizeFederation function.  
void synchronizeFederation(RTI::RTIambassador* rtiAmb)
{
   if ( theAmbData.isMaster )
   {         
      std::string synchPointTag("");
      
      int maximumSize(256);
      char* hostName = new char[maximumSize];
      if ( -1 == gethostname(hostName, maximumSize) ) 
      {            
         unsigned int objId = abs(getpid());   
         std::stringstream pid;
         pid.str(std::string(""));
         pid << "unknownHostName"
             << "_" 
             << objId;
         synchPointTag = pid.str();
      }
      else
      {            
         unsigned int objId = abs(getpid());   
         std::stringstream pid;
         pid.str(std::string(""));
         pid << hostName
             << "_" 
             << objId;
         
         synchPointTag = pid.str();
         
      }
      delete hostName;
      
      // Wait until other federates have joined.
      rtiAmb->tick(0.1, 0.2);
      std::cout << " Master waiting for all federates to Join.\n";
      while ( theAmbData.otherFederatesReady < (theAmbData.numFederates - 1) )
      {  
         if (input.keybrdTick() < 0 )
         {
            cleanUpProgram(rtiAmb);  
         }                  
         yieldFunction();
         rtiAmb->tick(0.1, 0.2);
      }
      
      
      // Now that all required federates have joined, register a sync point.
      std::cout << " Master federate has discovered the required number of other federates.\n\n";
      rtiAmb->registerFederationSynchronizationPoint(initSyncPointLabel.c_str(), 
                                                    synchPointTag.c_str());
      
      rtiAmb->tick(0.1, 0.2);
      while ( !theAmbData.registerFailed  && !theAmbData.registerSucceeded )
      {  
         if (input.keybrdTick() < 0 )
         {
            cleanUpProgram(rtiAmb);  
         }                  
         yieldFunction();         
         rtiAmb->tick(0.1, 0.2);
      }
      if ( theAmbData.registerFailed )
      {
         std::cout << " We failed to register synch point " << initSyncPointLabel << std::endl
                   << " with tag " << synchPointTag << std::endl;
         cleanUpProgram(rtiAmb);
      }                 
      std::cout << "Master successfully registered\n";
   }
   else
   {
      rtiAmb->tick(0.1, 0.2);
      std::cout << " Ordinary federate is waiting for synchPoint message\n";
      while ( ! theAmbData.announceSyncReceived )
      {
         if (input.keybrdTick() < 0 )
         {
            cleanUpProgram(rtiAmb);  
         }                  
         yieldFunction();
         rtiAmb->tick(0.1, 0.2);
      }
      std::cout << "sync Point message received\n";         
   }
   // At this time, any kind of federate announces to the RTI that they have reached their 
   // synchronization.  
   try
   {         
      rtiAmb->synchronizationPointAchieved(initSyncPointLabel.c_str());
   }
   catch (RTI::Exception& )
   {
      std::cout << " Synch point achieved failed\n"  
                << " Exiting....\n";
      cleanUpProgram(rtiAmb);
   }
   
   //Then they will wait for the RTI to announce to all federates that all federates are synchronized.
   rtiAmb->tick(0.1, 0.2);
   while ( !theAmbData.federationIsSynchronized )
   {
      if (input.keybrdTick() < 0 )
      {
         cleanUpProgram(rtiAmb);  
      }                  
      minimalSleepFunction();
      rtiAmb->tick(0.1, 0.2);
   }
}
int main(int argc, char** argv)
{
   std::cout << "MAK simpleTime version 1.3" << std::endl;
   try
   {
      // Federate and Federation info
      string federateType("simpletime13");
      
      if (argc > 1)
      {
         if (!parseCmdLine(argc, argv))
         {
            exit(0);
         }
      }            
      // RTI and Federate Ambassadors
      RTI::RTIambassador* rtiAmb = new RTI::RTIambassador;
      MyFederateAmbassador fedAmb(theAmbData);
   
      // Create the federation
      createFedEx(rtiAmb, federationName, fedFileName);
      // Join the federation
      joinFedEx(rtiAmb, &fedAmb, federateType);      
    
#ifdef WIN32
      WSADATA data;
      WSAStartup(MAKEWORD(1,1), &data);
#endif
      rtiAmb->tick(0.1, 0.2);
      long count=0;
      RTI::FedTime* currentTime = RTI::FedTimeFactory::makeZero();            
      RTI::FedTime* lookAhead = new RTIfedTime(1.0);            
      RTI::FedTime* currentRTITime = RTI::FedTimeFactory::makeZero();
      RTI::FedTime* oneTimeStep  = new RTIfedTime(5.0);         
      //Become Time managed and regulating in this federation.
      becomeConstrainedAndRegulating(rtiAmb, currentTime, lookAhead);
      (*currentTime) += (*oneTimeStep);
       // Publish, subscribe and register and object
      if (!publishSubscribeAndRegisterObject(rtiAmb))
      {
         resignAndDestroy(rtiAmb);
         delete rtiAmb;
         return 0;
      }  
     
      // By using synchronization points, ensure that all expected federates
       // have joined prior to commencing.  This function requires that 
       // other federates have registered an object as it utilizes discovery
       // callbacks to count the number of federates that have joined as yet.      
      if ( !unManagedFederate )
      {
         synchronizeFederation(rtiAmb);
      }
               
      // Publish and subscribe to the required interaction      
      if (!publishAndSubscribeInteraction(rtiAmb))
      {
         resignAndDestroy(rtiAmb);
         delete rtiAmb;
         return 0;
      }                    
  
      // This is the main loop of the application.  In it, the federate ticks the RTI, updates
      // its published attributes and if indicated, fires and detonates, this continues
      // until this federate has been detonated.  
      while ( !theAmbData.timeManagedObject.isDetonated() )
      { 
         std::cout << "===================================================================\n";
         std::cout << "         Fedtime (";
         printOutFedTime(currentRTITime);
         std::cout << "), Lookahead (";
         printOutFedTime(lookAhead);
         std::cout << ") and wallclock time (";
         printOutFedTime(currentTime);
         std::cout << ")       " << std::endl; 
         std::cout << endl;
        
         stringstream ss;
         ss << "1.3-" << count++;
         string tag(ss.str()); 
                           
                                
         theAmbData.timeManagedObject.tick();                                
         theAmbData.timeManagedObject.incPosition();         
         
         try{            
            // Update the object
            rtiAmb->updateAttributeValues(
               theObjectHandle,
               *(theAmbData.attrValues),
               (*currentTime),
               tag.c_str());             
            rtiAmb->tick(0.1, 0.5);             
            
            // Send the interaction if appropriate.
            if ( theAmbData.timeManagedObject.shouldDetonate() )
            {                                     
               string munitionString = "MunitionObjectIdentifier";
               // Find the Parameter Handle that the RTI associated with this Parameter Name.
               RTI::ParameterHandle munitionHandle = 
                  theAmbData.theParamNameHandleMap.find(munitionString)->second;
               
               // By adding a munitions parameter with nothing for the data, we communicate that this 
               // interaction is a munitions interaction.
               theAmbData.paramValues->remove( munitionHandle );
               theAmbData.paramValues->add(munitionHandle, "\0", 1);
               rtiAmb->sendInteraction(                  
                  detonateInteractionHandle,
                  *theAmbData.paramValues,
                  (*currentTime),
                  tag.c_str() );
               // Restore the munitions parameter data.
               theAmbData.paramValues->remove( munitionHandle );
               theAmbData.paramValues->add(munitionHandle,
                  munitionString.c_str(), munitionString.length() + 1);
            }
            if ( theAmbData.timeManagedObject.shouldFire() ) 
            {               
               string fireString = "FiringObjectIdentifier";
               // Find the Parameter Handle that the RTI associated with the Fire Parameter.
               RTI::ParameterHandle fireHandle = theAmbData.theParamNameHandleMap.find(fireString)->second;
               // By replacing the existing fire parameter with one that has null data, we indicate
               // that this interaction is a fire interaction.
               theAmbData.paramValues->remove(fireHandle);
               theAmbData.paramValues->add(fireHandle, "\0", 1);
               rtiAmb->sendInteraction(
                  fireInteractionHandle,
                  *theAmbData.paramValues,
                  (*currentTime),
                  tag.c_str() );
                
                // Restore the fire parameter's data. 
                theAmbData.paramValues->remove(fireHandle);
                theAmbData.paramValues->add(fireHandle, fireString.c_str(), fireString.length() + 1);
            }
            
         }
         catch(RTI::InvalidFederationTime& ex)
         {
            std::cout << " caught an Invalid Federation Time !!\n";
            std::cout << ex._name << " " << ex._reason << endl;
            // A federate can easily rectify a difference in current time with the RTI's time.
            // This federate is synchronized before it advances time, this should never be reached.
            cleanUpProgram(rtiAmb);
         }                               
         int kb(0);
         try
         {         
            if ( theAmbData.isRegulating )
            {
               (*currentRTITime) += (*oneTimeStep);            
               (*currentTime) += (*oneTimeStep);
               rtiAmb->timeAdvanceRequest(*currentRTITime);
               theAmbData.timeAdvanced = false;                        
               
               rtiAmb->tick(0.1, 0.2);
               while ( ! theAmbData.timeAdvanced )
               {
                  kb = input.keybrdTick();
                  if (kb < 0)
                  {
                     break;
                  }
                  else if ( kb == 1 )
                  {                  
                     theAmbData.timeManagedObject.firePressed();
                     std::cout << "**********Firing at Fed Time " ;                          
                     printOutFedTime(currentRTITime);
                     std::cout << "*************\n";
                  }
                  else if ( !theAmbData.timeAdvanced )
                  { 
                     yieldFunction();
                     rtiAmb->tick(0.1, 0.2);
                  }
               }                
            }                      
         }
         catch( RTI::Exception& ex )
         {
            std::cout << "RTI Exception" << endl
                      << ex._name << " " << ex._reason << endl  
                      << " Could not advance time" << endl;
         }
         
         rtiAmb->tick(0.1, 0.2);
  
         if ( kb == 0 ) 
         {
            kb = input.keybrdTick();
         }
         if ( kb < 0 )
         {
            break;
         }   
         else if ( kb == 1 )
         {
            theAmbData.timeManagedObject.firePressed();
            std::cout << "**********Firing at Fed Time " ;                          
            printOutFedTime(currentRTITime);
            std::cout << "*************\n";
         }
         std::cout << "===================================================================\n\n";
         sleepFunction();         
     
         
      }
      
      delete oneTimeStep;
      delete lookAhead;      
      delete currentTime;
      delete currentRTITime;    
      delete theAmbData.paramValues;
      delete theAmbData.attrValues;
      if ( theAmbData.isRegulating )
      {
         rtiAmb->disableTimeRegulation();
      }
      
      // Resign and destroy federation
      resignAndDestroy(rtiAmb);
      delete rtiAmb;
   }   
   catch (RTI::Exception& ex)
   {
      std::cout  << "RTI Exception (main loop): "
            << ex._name << " "
            << ex._reason << endl;
   }
   
#ifdef WIN32
   WSACleanup();
#endif
   
   return 0;
}
bool parseCmdLine( int argc, char* argv[] )
{
   // Process command line input.
   vector < std::string > cmdArgs;
   copy( argv + 1, argv + argc, back_inserter(cmdArgs));
   vector<std::string>::const_iterator cur = cmdArgs.begin();
   vector<std::string>::const_iterator last = cmdArgs.end();
   
   while ( cur != last )
   {
      vector<std::string>::const_iterator next = cur + 1;
      if ( *cur == "-h" )
      {
         std::cerr << usage();
         return false;
      }
      else if ( *cur == "-fedFile" )
      {
         if ( !convert<string>(*cur, *next, fedFileName ))
         {
            std::cerr << usage();
            return false;
         }
         ++cur;
      }
      else if  (*cur == "-m" )
      {
         if ( !convert<int> (*cur, *next, theAmbData.numFederates))
         {
            std::cerr << usage();
            return false;
         }
         theAmbData.isMaster = true;
         ++cur;         
      }
      else if ( *cur == "-phaseLine" )
      {
         int phaseLine(0);
         if ( !convert<int>(*cur, *next, phaseLine))
         {
            std::cerr << usage();
            return false;
         }         
         theAmbData.timeManagedObject.setPhaseLine(phaseLine);      
         ++cur;
      }
      else if ( *cur == "-sleepTime" )
      {
         if ( !convert<int> (*cur, *next, sleepTime )) 
         {
            std::cerr << usage();
            return false;
         }
         ++cur;
      }
      else if ( *cur == "-dedicated" )
      {
         dedicatedMachine = true;
      }
      else if ( *cur == "-unManaged" )
      {
         unManagedFederate = true;         
      }
      else
      {
         std::cerr<< usage();
         return false;
      }
      ++cur;
   }
   return true;
}

simpleTimeFedAmb13.cxx

/*******************************************************************************
** Copyright (c) 2004 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleTimeFedAmb13.cxx,v $ $Revision: 1.3 $ $State: Exp $
*******************************************************************************/
#ifdef WIN32
#pragma warning(disable: 4786)
#pragma warning(disable: 4290)
#else
#include <stdio.h>
#endif
#include <cstdlib>
#include <iostream>
#include "simpleTimeFedAmb13.h"
#include "simpleTimeTimeManagedEntity.h"
using namespace std;
DtTalkAmbData::DtTalkAmbData() :      
   isConstrained(false),
   isRegulating(false),   
   timeAdvanced(false),
   otherFederatesReady(0),
   isMaster(false),
   numFederates(0),
   registerSucceeded(false),
   registerFailed(false),
   announceSyncReceived(false),
   federationIsSynchronized(false)
{ }
DtTalkAmbData::~DtTalkAmbData()
{      
}
MyFederateAmbassador::MyFederateAmbassador(DtTalkAmbData & data) :
   NullFederateAmbassador(), myData(data)
{ }
MyFederateAmbassador::~MyFederateAmbassador()
   throw (RTI::FederateInternalError)
{
}
void MyFederateAmbassador::discoverObjectInstance (
   RTI::ObjectHandle theObject,      
   RTI::ObjectClassHandle theObjectClass, 
   const char* theObjectName)
   throw (
      RTI::CouldNotDiscover,
      RTI::ObjectClassNotKnown,
      RTI::FederateInternalError)
{
   // This is an over simplification of the initialization of a federation.  
   // In our case we simply wait until there are the requisite # of known federates
   // before starting.
   ++myData.otherFederatesReady;
   if ( myData.isMaster)
   {   
      std::cout << " Master federate is aware of " 
           << myData.otherFederatesReady + 1
           << " federates, including itself\n";
   }
  // Now that we've discovered an object we should request an Attribute
  // update for all of the attributes that we're subscribed for.
  
  // Construct an attribute handle set
  RTI::AttributeHandleSet* hSet = 
    RTI::AttributeHandleSetFactory::create(myData.ourParms.size());
  for (DtAttrNameHandleMap::iterator iter = myData.theAttrNameHandleMap.begin();
       iter != myData.theAttrNameHandleMap.end();
       iter++)
    {
      hSet->add(iter->second);
    }  
  // In order to avoid making RTI calls from within an RTI callback, 
  // we'll add this attrRequest to a shared Object, allowing the 
  // call to be made from outside this callback.
  myData.updateRequestMap.insert(make_pair(theObject,hSet));
  delete hSet;
  myData.objectInstanceMap[theObject] = theObjectName;
}
// To keep callbacks expedient and simple, we simply save all pertinent information
// from this reflect in our timeManagedObject, allowing the main thread of execution
// to process the update when it chooses.
// The same can be said of the other reflectAttributeValues calls 
void MyFederateAmbassador::reflectAttributeValues (
        RTI::ObjectHandle                 theObject,     
  const RTI::AttributeHandleValuePairSet& theAttributes, 
  const RTI::FedTime&                     theTime,       
  const char                             *theTag,        
        RTI::EventRetractionHandle        theHandle)     
throw (
  RTI::ObjectNotKnown,
  RTI::AttributeNotKnown,
  RTI::FederateOwnsAttributes,
  RTI::InvalidFederationTime,
  RTI::FederateInternalError)
{ 
   myData.timeManagedObject.addAttrUpdateEvent(new attributeUpdateEvent(
                                                              theAttributes,
                                                              theTime,
                                                              theTag,
                                                              theHandle));
}
void MyFederateAmbassador::reflectAttributeValues (
        RTI::ObjectHandle                 theObject,     
  const RTI::AttributeHandleValuePairSet& theAttributes, 
  const char                             *theTag)        
throw (
  RTI::ObjectNotKnown,
  RTI::AttributeNotKnown,
  RTI::FederateOwnsAttributes,
  RTI::FederateInternalError)
{            
   myData.timeManagedObject.addAttrUpdateEvent(new attributeUpdateEvent(
                                                               theAttributes,
                                                               theTag ));
}
// Similar to the reflectAttributeValues implementations, here we do some minimal
//  interpretation of the received Interaction (whether it is a fire or detonation 
//  interaction), and add the interaction event to our timeManagedObject, allowing
//  the main thread of execution to process it as appropriate.
void MyFederateAmbassador::receiveInteraction (
        RTI::InteractionClassHandle       theInteraction, 
  const RTI::ParameterHandleValuePairSet& theParameters,  
  const RTI::FedTime&                     theTime,        
  const char                             *theTag,         
        RTI::EventRetractionHandle        theHandle)      
throw (
  RTI::InteractionClassNotKnown,
  RTI::InteractionParameterNotKnown,
  RTI::InvalidFederationTime,
  RTI::FederateInternalError)
{  
   interactionEvent::interaction_type interactionType(interactionEvent::Unknown);
   string munitionString("MunitionObjectIdentifier");
   string fireString("FiringObjectIdentifier");
   RTI::ParameterHandle munitionHandle = 
      myData.theParamNameHandleMap.find(munitionString)->second;
   RTI::ParameterHandle fireHandle =
      myData.theParamNameHandleMap.find(fireString)->second;
   for ( unsigned int i(0); 
         (interactionType == interactionEvent::Unknown) && i < theParameters.size(); 
         ++i )
   {
      if ( theParameters.getHandle(i) == munitionHandle )
      {
         RTI::ULong length = theParameters.getValueLength(i);
         if ( length == 1 )
         {
            interactionType = interactionEvent::DetonationType;
         }
      }
      if ( theParameters.getHandle(i) == fireHandle )
      {
         RTI::ULong length = theParameters.getValueLength(i);
         if ( length == 1 )
         {
            interactionType = interactionEvent::FireType;
         }
      }
   }
   
   myData.timeManagedObject.addInteractionEvent(new interactionEvent ( theInteraction, 
                                                              theParameters,
                                                              theTime,
                                                              theTag,
                                                              interactionType ));
}
void MyFederateAmbassador::receiveInteraction (
        RTI::InteractionClassHandle       theInteraction, 
  const RTI::ParameterHandleValuePairSet& theParameters,  
  const char                             *theTag)         
throw (
  RTI::InteractionClassNotKnown,
  RTI::InteractionParameterNotKnown,
  RTI::FederateInternalError)
{                                                                  
  myData.timeManagedObject.addInteractionEvent(
                                       new interactionEvent( theInteraction,
                                                              theParameters,
                                                              theTag) );
}
// remove the object instance from our map of object instances.
void MyFederateAmbassador::removeObjectInstance (
        RTI::ObjectHandle          theObject, 
  const RTI::FedTime&              theTime,   
  const char                      *theTag,    
        RTI::EventRetractionHandle theHandle) 
throw (
  RTI::ObjectNotKnown,
  RTI::InvalidFederationTime,
  RTI::FederateInternalError)
{  
  if ( myData.objectInstanceMap.find(theObject) != myData.objectInstanceMap.end())
    myData.objectInstanceMap.erase(theObject);
  myData.timeManagedObject.reset();
}
void MyFederateAmbassador::removeObjectInstance (
        RTI::ObjectHandle          theObject, 
  const char                      *theTag)    
throw (
  RTI::ObjectNotKnown,
  RTI::FederateInternalError)
{   
  if ( myData.objectInstanceMap.find(theObject) != myData.objectInstanceMap.end())
    myData.objectInstanceMap.erase(theObject);
  myData.timeManagedObject.reset();
}
// A request was made for an attribute update from this update, add the request
// to our updateRequestMap.
void MyFederateAmbassador::provideAttributeValueUpdate (
        RTI::ObjectHandle        theObject,     
  const RTI::AttributeHandleSet& theAttributes) 
throw (
  RTI::ObjectNotKnown,
  RTI::AttributeNotKnown,
  RTI::AttributeNotOwned,
  RTI::FederateInternalError) 
{    
  RTI::AttributeHandleSet* hSet = 
    RTI::AttributeHandleSetFactory::create(myData.ourAttrs.size());
  for (DtAttrNameHandleMap::iterator iter = myData.theAttrNameHandleMap.begin();
       iter != myData.theAttrNameHandleMap.end();
       iter++)
    {
      hSet->add(iter->second);
    } 
  
  myData.updateRequestMap.insert( make_pair( theObject, hSet) );  
  delete hSet;
}
// Alert the user and set the isRegulating flag of our shared Object.
void MyFederateAmbassador::timeRegulationEnabled (
 const  RTI::FedTime& theFederateTime) // supplied C4
throw (
  RTI::InvalidFederationTime,
  RTI::EnableTimeRegulationWasNotPending,
  RTI::FederateInternalError)
{
   std::cout << " This federate is now able to Regulate time\n";
   myData.isRegulating = true;
}
// Alert the user and set the isConstrained flag of our shared Object.
void MyFederateAmbassador::timeConstrainedEnabled (
  const RTI::FedTime& theFederateTime)
throw (
  RTI::InvalidFederationTime,
  RTI::EnableTimeConstrainedWasNotPending,
  RTI::FederateInternalError)
{
   std::cout << " This federate is now time Constrained\n";
   myData.isConstrained = true;
}
// Alert the user and set the timeAdvanced flag of our shared Object.
void MyFederateAmbassador::timeAdvanceGrant (
  const RTI::FedTime& theTime) // supplied C4
throw (
  RTI::InvalidFederationTime,
  RTI::TimeAdvanceWasNotInProgress,
  RTI::FederateInternalError)
{
   int length = theTime.getPrintableLength();
   char* buff = new char[length + 1];
   const_cast<RTI::FedTime&>(theTime).getPrintableString(buff);   
   std::cout << " Federate Time has been advanced to " << atof(buff) << endl;
   delete [] buff;
   myData.timeAdvanced = true;
}
// set the registerSucceeded flag of our shared object. 
void MyFederateAmbassador::synchronizationPointRegistrationSucceeded (
  const char *label) // supplied C4)
throw (
  RTI::FederateInternalError) 
{
   myData.registerSucceeded = true;
}
// set the registerFailed flag of our shared Object.  
void MyFederateAmbassador::synchronizationPointRegistrationFailed (
  const char *label)
throw (
  RTI::FederateInternalError)
{
   myData.registerFailed = true;  
}
// We received a callback from the RTI announcing a synchronization point.
void MyFederateAmbassador::announceSynchronizationPoint (
  const char *label, // supplied C4
  const char *tag)   // supplied C4
throw (
  RTI::FederateInternalError)
{
   myData.announceSyncReceived = true;  
   std::cout << "Announce Sync Received for label "
        << label << " and tag "
        << tag << endl;
}
// A previous synchronization point has been achieved by all involved federates.
void MyFederateAmbassador::federationSynchronized (
  const char *label) // supplied C4)
throw (
  RTI::FederateInternalError)
{
   myData.federationIsSynchronized = true;
   std::cout << " My Federation has been synchronized.\n";
}

simpleTimeKeyboard.cxx

/*******************************************************************************
* Adapted from "Beginning Linux Programming", from Wrox Press -- www.wrox.com
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleTimeKeyboard.cxx,v $ $Revision: 1.1 $ $State: Exp $
*******************************************************************************/
#include "simpleTimeKeyboard.h"
#ifdef WIN32
#include <conio.h>
#else
#include <unistd.h>
#endif
#include <iostream>
keyboard::keyboard()
{
#ifndef WIN32
   tcgetattr(0,&initial_settings);
   new_settings = initial_settings;
   new_settings.c_lflag &= ~ICANON;
   new_settings.c_lflag &= ~ECHO;
   new_settings.c_lflag &= ~ISIG;
   new_settings.c_cc[VMIN] = 1;
   new_settings.c_cc[VTIME] = 0;
   tcsetattr(0, TCSANOW, &new_settings);
   peek_character=-1;
#endif
}
keyboard::~keyboard()
{
#ifndef WIN32
   tcsetattr(0, TCSANOW, &initial_settings);
#endif
}
int keyboard::kbhit()
{
#ifdef WIN32
   return _kbhit();
#else
   unsigned char ch;
   int nread;
   if (peek_character != -1) return 1;
   new_settings.c_cc[VMIN]=0;
   tcsetattr(0, TCSANOW, &new_settings);
   nread = read(0,&ch,1);
   new_settings.c_cc[VMIN]=1;
   tcsetattr(0, TCSANOW, &new_settings);
   if (nread == 1)
   {
      peek_character = ch;
      return 1;
   }
   return 0;
#endif
}
int keyboard::getkey()
{
   char ch;
#ifdef WIN32
   ch = _getch();
#else
   if (peek_character != -1)
   {
      ch = peek_character;
      peek_character = -1;
   }
   else
      read(0,&ch,1);
#endif
   return ch;
}
int keyboard::keybrdTick()
{
   char key = ' ';
   if (!kbhit())
      return 0;
   key = getkey();
   while (key != 'q' && key != 'Q' && kbhit())
      key = getkey();
   if ( key == 'q' || key == 'Q' ) 
   { 
      return -1;
   }
   else if ( key == 32 )
   {
      return 1;
   }
   else
   {      
      return 0;
   }
}

simpleTimeAttribute13.cxx

/*******************************************************************************
** Copyright (c) 2006 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleTimeAttribute13.cxx,v $ $Revision: 1.2 $ $State: Exp $
*******************************************************************************/
#ifdef WIN32
#pragma warning(disable: 4251)
#pragma warning(disable: 4786)
#pragma warning(disable: 4290)
#endif 
#include "simpleTimeAttribute13.h"
// A simple container class for an attributeUpdate event
// Construct an attributeUpdateEvent, store pertinent information from the reflect callback.
attributeUpdateEvent::attributeUpdateEvent( 
                  const RTI::AttributeHandleValuePairSet& ahvps,
                  const RTI::FedTime& fedTime,
                  const char* tag,
                  RTI::EventRetractionHandle theRetractionHandle ) :                      
   myTag(tag),
   myRetractionHandle(theRetractionHandle)
{ 
  for ( long unsigned int i(0); i < ahvps.size(); ++i )
  {
     RTI::ULong len = ahvps.getValueLength(i);
      myAhvps.insert(std::make_pair(
                       ahvps.getHandle(i), 
                       std::string(
                           ahvps.getValuePointer(i,len))));
   }
   int length = fedTime.getPrintableLength();
   char* buff = new char[length + 1];
   const_cast<RTI::FedTime&>(fedTime).getPrintableString(buff);   
   myFedTime = std::string(buff);
   delete [] buff;
}
// Construct an attributeEvent from a non-Time Managed reflectAttributeUpdates callback.
attributeUpdateEvent::attributeUpdateEvent( 
                              const RTI::AttributeHandleValuePairSet& ahvps,
                              const char* tag ) : 
   
   
   myTag(tag)   
{ 
   for ( long unsigned int i(0); i < ahvps.size(); ++i )
   {
      RTI::ULong len = ahvps.getValueLength(i);
      myAhvps.insert(std::make_pair(
                        ahvps.getHandle(i), 
                        std::string(
                           ahvps.getValuePointer(i,len))));
   }         
   myFedTime = std::string("no Time Given");   
}
attributeUpdateEvent::~attributeUpdateEvent()
{ }
const std::map<unsigned long, std::string>& attributeUpdateEvent::getAhvps()
{
   return myAhvps;
}
const std::string& attributeUpdateEvent::getFedTime()
{
   return myFedTime;
}
const std::string& attributeUpdateEvent::getTag()
{ 
   return myTag;   
}
RTI::EventRetractionHandle attributeUpdateEvent::getRetractionHandle()
{
  return myRetractionHandle;
}

simpleTimeInteraction13.cxx

/*******************************************************************************
** Copyright (c) 2006 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleTimeInteraction13.cxx,v $ $Revision: 1.2 $ $State: Exp $
*******************************************************************************/
#ifdef WIN32
#pragma warning(disable: 4251)
#pragma warning(disable: 4786)
#pragma warning(disable: 4290)
#endif 
#include "simpleTimeInteraction13.h"
// Construct an interactionEvent, store pertinent information from the callback.
interactionEvent::interactionEvent( RTI::InteractionClassHandle theHandle,
                  const RTI::ParameterHandleValuePairSet& phvps,
                  const RTI::FedTime& fedTime,
                  const char* tag,                  
                  interaction_type theInteractionType) :                  
   myHandle(theHandle),
   myTag(tag),   
   myInteractionType(theInteractionType)
{
   for ( long unsigned int i(0); i < phvps.size(); ++i )
   {
      RTI::ULong len = phvps.getValueLength(i);
      myPhvps.insert(std::make_pair(
                       phvps.getHandle(i), 
                       std::string(
                           phvps.getValuePointer(i,len))));
   }
   int length = fedTime.getPrintableLength();
   char* buff = new char[length + 1];
   const_cast<RTI::FedTime&>(fedTime).getPrintableString(buff);   
   myFedTime = std::string(buff);
   delete [] buff;
}
// Construct an interactionEvent from a non-Time Managed callback.
interactionEvent::interactionEvent( RTI::InteractionClassHandle theHandle,
                  const RTI::ParameterHandleValuePairSet& phvps,
                  const char* tag,
                  interaction_type theInteractionType)
:  myHandle(theHandle),
   myTag(tag),   
   myFedTime(""),
   myInteractionType(theInteractionType)
{
   for ( long unsigned int i(0); i < phvps.size(); ++i )
   {
      RTI::ULong len = phvps.getValueLength(i);
      myPhvps.insert(std::make_pair(
                       phvps.getHandle(i), 
                       std::string(
                           phvps.getValuePointer(i,len))));
   }      
}
interactionEvent::~interactionEvent()
{
   
}
RTI::InteractionClassHandle interactionEvent::getHandle() 
{
  return myHandle;
}
const std::string& interactionEvent::getFedTime()
{
   return myFedTime;
}
const std::string& interactionEvent::getTag()
{ 
   return myTag;
}
int interactionEvent::getTypeOfInteraction()
{
   return myInteractionType;
}
bool interactionEvent::isFireInteraction()
{
   return myInteractionType == FireType;
}
bool interactionEvent::isDetonateInteraction()
{
   return myInteractionType == DetonationType;
}
requestUnit::requestUnit( RTI::ObjectHandle handle,
                          const RTI::AttributeHandleSet& attrHandSet ) :
  myHandle(handle),
  myAttrHandleSet(attrHandSet)
{}
requestUnit::~requestUnit() {}
const RTI::AttributeHandleSet& requestUnit::getAttrHandSet()
{ 
  return myAttrHandleSet;
}
const RTI::ObjectHandle requestUnit::getHandle()
{
  return myHandle;
}

simpleTimeTimeManagedEntity.cxx

/*******************************************************************************
** Copyright (c) 2006 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleTimeTimeManagedEntity.cxx,v $ $Revision: 1.3 $ $State: Exp $
*******************************************************************************/
#ifdef WIN32
#pragma warning(disable: 4251)
#pragma warning(disable: 4786)
#pragma warning(disable: 4290)
#endif 
// A simple object that dictates the behavior of an advancing entity.
#include "simpleTimeTimeManagedEntity.h"
#include <assert.h>
#include <iostream>
timeManagedEntity::timeManagedEntity()
 : myFirePressed(false),
   myPosition(0),
   myVelocity(0),   
   myPhysicalState(Alive),
   myState(Initial),
   myPhaseLine(150)
{ }
timeManagedEntity::~timeManagedEntity()
{
   while ( attrUpdateWaiting() )
   {  
      delete getNextAttrUpdateEvent();
   }
   while ( interactionWaiting() )
   {
      delete getNextInteractionEvent();
   }
}
bool timeManagedEntity::attrUpdateWaiting() 
{
  return myAttrUpdateQueue.size() > 0;
}
bool timeManagedEntity::interactionWaiting()
{
   return myInteractionQueue.size() > 0;
}
interactionEvent* timeManagedEntity::getNextInteractionEvent()
{
   interactionEvent* retVal = myInteractionQueue.front();
   myInteractionQueue.pop();
   return retVal;  
}
attributeUpdateEvent* timeManagedEntity::getNextAttrUpdateEvent()
{
   attributeUpdateEvent* retVal = myAttrUpdateQueue.front();
   myAttrUpdateQueue.pop();
   return retVal;
}
void timeManagedEntity::addInteractionEvent(interactionEvent* eventToAdd)
{
  myInteractionQueue.push(eventToAdd);
}
void timeManagedEntity::addAttrUpdateEvent(attributeUpdateEvent* eventToAdd)
{
   myAttrUpdateQueue.push(eventToAdd);
}
bool timeManagedEntity::shouldFire()
{
   return (myState == Firing );
}
void timeManagedEntity::reset()
{
   myState = Initial;
   myPhysicalState = Alive;
   myFirePressed = false;
}
bool timeManagedEntity::shouldDetonate()
{
   return (myState == SendDetonate );
}
bool timeManagedEntity::isFiredUpon()
{
  return ( myPhysicalState >= FiredUpon );
}
bool timeManagedEntity::isDetonated()
{
  return ( myPhysicalState >= Damaged );
}
void timeManagedEntity::setPhaseLine(int phaseLine)
{
   myPhaseLine = phaseLine;
}
void timeManagedEntity::processEvents() 
{
   if ( isDetonated() )
   {
      std::cout << "XXX   DEAD  XXX\n";
      while ( interactionWaiting() )
      {
         delete getNextInteractionEvent();       
      }
      while ( attrUpdateWaiting() )
      {
         delete getNextAttrUpdateEvent();
      }
   }
   else 
   {
      while ( interactionWaiting() )
      {
         interactionEvent* receivedInteraction = getNextInteractionEvent();
         std::string fedTime = receivedInteraction->getFedTime();
         std::string tag = receivedInteraction->getTag();         
         if ( receivedInteraction->getTypeOfInteraction() == interactionEvent::FireType 
             && myPhysicalState < FiredUpon )
         {
           std::cout << " received Fire interaction (" << tag << ") at time "
                     << fedTime.c_str() << " \n" ;                               
           myPhysicalState = FiredUpon;
         }
         if ( receivedInteraction->getTypeOfInteraction() == interactionEvent::DetonationType 
             && myPhysicalState < Damaged )
         {
           std::cout << " received Detonation interaction (" << tag << ") at time "
                     << fedTime.c_str() << " \n" ;                               
           myPhysicalState = Damaged;
         }
         delete receivedInteraction;  
      }
      while ( attrUpdateWaiting() )
      {
         attributeUpdateEvent* receivedAttrUpdate = getNextAttrUpdateEvent();
          
         std::string fedTime = receivedAttrUpdate->getFedTime();
         std::string tag = receivedAttrUpdate->getTag();
         std::cout << " received attribute update (" << tag << ") at time "
                   << fedTime.c_str() << " \n" ;
         delete receivedAttrUpdate;  
      }
   }
}    
void timeManagedEntity::incPosition()
{   
   ++myPosition;
}
void timeManagedEntity::firePressed()
{
   myFirePressed = true;
}
void timeManagedEntity::tick()
{
   if ( !isDetonated())
   {
      processEvents();
      switch ( myState ) 
      {
      case Initial :
         
         if ( myFirePressed || myPosition >= myPhaseLine )
         {
            myState = Firing;
         }     
         break;
         
      case Firing : 
         myState = SendDetonate;
         break;
         
      case SendDetonate :              
         myState = Firing;
         break;
      }
   }
   else
   {
      myState = Idle;
      myPhysicalState = Dead;
   }
} 

timeManagedEntity.cxx

simpleTimeFedAmb13.h

/*******************************************************************************
** Copyright (c) 2004 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleTimeFedAmb13.h,v $ $Revision: 1.2 $ $State: Exp $
*******************************************************************************/
#pragma warning(disable: 4786)
#pragma warning(disable: 4290)
#include "NullFederateAmbassador.hh"
#include <map>
#include <set>
#include <string>
#include "simpleTimeTimeManagedEntity.h"
// Map between strings and attribute handles
typedef std::map<std::string, RTI::AttributeHandle>  DtAttrNameHandleMap;
typedef std::map<std::string, RTI::ParameterHandle> DtParamNameHandleMap;
class DtTalkAmbData{
   
public :
   DtTalkAmbData();
   ~DtTalkAmbData();
 
public:
 std::map<RTI::ObjectClassHandle, std::string> objectClassMap;
 std::map<RTI::ObjectHandle, std::string> objectInstanceMap;
 std::map<RTI::InteractionClassHandle, std::string> interactionClassMap; 
 std::map<RTI::ObjectHandle, RTI::AttributeHandleSet*> updateRequestMap;
 // Map between strings and attribute handles
 DtAttrNameHandleMap theAttrNameHandleMap; 
 // Map between strings and attribute handles
 DtParamNameHandleMap theParamNameHandleMap;
 // The set of Attributes that this federate's published objects will contain.
 std::set <std::string> ourAttrs;
 // The set of Parameters that this federate's published interactions will contain.
 std::set <std::string> ourParms;  
 // This federation of simple objects has a single master object, (determined by command line arguments)
 //  The master federate will keep the other federates from entering their main loop of execution until
 //  all of numFederates have joined.
 bool isMaster;
 // numFederates is the number of federates (including the master) that the master should wait to join the 
 //  federation before it allows any federate to enter its main loop. 
 // This variable is only used by the master federate.
 int numFederates;
 
 RTI::AttributeHandleValuePairSet* attrValues;
 RTI::ParameterHandleValuePairSet* paramValues;
 bool isConstrained;
 bool isRegulating;
 bool timeAdvanced;
 int otherFederatesReady;
 bool registerFailed;
 bool registerSucceeded;
 bool announceSyncReceived;
 bool federationIsSynchronized;
 timeManagedEntity timeManagedObject; 
};
class MyFederateAmbassador : public NullFederateAmbassador
{
public:
   MyFederateAmbassador(DtTalkAmbData & data);
   virtual ~MyFederateAmbassador() 
     throw (RTI::FederateInternalError);
   // Object Management Services //
   virtual void discoverObjectInstance (
           RTI::ObjectHandle          theObject,      // supplied C1
           RTI::ObjectClassHandle     theObjectClass, // supplied C1
     const char*                      theObjectName)  // supplied C4  
   throw (
     RTI::CouldNotDiscover,
     RTI::ObjectClassNotKnown,
     RTI::FederateInternalError);
   virtual void reflectAttributeValues (
           RTI::ObjectHandle                 theObject,     // supplied C1
     const RTI::AttributeHandleValuePairSet& theAttributes, // supplied C4
     const RTI::FedTime&                     theTime,       // supplied C1
     const char                             *theTag,        // supplied C4
           RTI::EventRetractionHandle        theHandle)     // supplied C1
   throw (
     RTI::ObjectNotKnown,
     RTI::AttributeNotKnown,
     RTI::FederateOwnsAttributes,
     RTI::InvalidFederationTime,
     RTI::FederateInternalError);
   virtual void reflectAttributeValues (
           RTI::ObjectHandle                 theObject,     // supplied C1
     const RTI::AttributeHandleValuePairSet& theAttributes, // supplied C4
     const char                             *theTag)        // supplied C4
   throw (
     RTI::ObjectNotKnown,
     RTI::AttributeNotKnown,
     RTI::FederateOwnsAttributes,
     RTI::FederateInternalError);
   // 4.6
   virtual void receiveInteraction (
           RTI::InteractionClassHandle       theInteraction, // supplied C1
     const RTI::ParameterHandleValuePairSet& theParameters,  // supplied C4
     const RTI::FedTime&                     theTime,        // supplied C4
     const char                             *theTag,         // supplied C4
           RTI::EventRetractionHandle        theHandle)      // supplied C1
   throw (
     RTI::InteractionClassNotKnown,
     RTI::InteractionParameterNotKnown,
     RTI::InvalidFederationTime,
     RTI::FederateInternalError);
   virtual void receiveInteraction (
           RTI::InteractionClassHandle       theInteraction, // supplied C1
     const RTI::ParameterHandleValuePairSet& theParameters,  // supplied C4
     const char                             *theTag)         // supplied C4
   throw (
     RTI::InteractionClassNotKnown,
     RTI::InteractionParameterNotKnown,
     RTI::FederateInternalError);
   virtual void removeObjectInstance (
           RTI::ObjectHandle          theObject, // supplied C1
     const RTI::FedTime&              theTime,   // supplied C4
     const char                      *theTag,    // supplied C4
           RTI::EventRetractionHandle theHandle) // supplied C1
   throw (
     RTI::ObjectNotKnown,
     RTI::InvalidFederationTime,
     RTI::FederateInternalError);
   virtual void removeObjectInstance (
           RTI::ObjectHandle          theObject, // supplied C1
     const char                      *theTag)    // supplied C4
   throw (
     RTI::ObjectNotKnown,
     RTI::FederateInternalError);
virtual void provideAttributeValueUpdate (
        RTI::ObjectHandle        theObject,     
  const RTI::AttributeHandleSet& theAttributes) 
throw (
  RTI::ObjectNotKnown,
  RTI::AttributeNotKnown,
  RTI::AttributeNotOwned,
  RTI::FederateInternalError);
virtual void timeRegulationEnabled (
 const  RTI::FedTime& theFederateTime) // supplied C4
throw (
  RTI::InvalidFederationTime,
  RTI::EnableTimeRegulationWasNotPending,
  RTI::FederateInternalError);
virtual void timeConstrainedEnabled (
  const RTI::FedTime& theFederateTime) // supplied C4
throw (
  RTI::InvalidFederationTime,
  RTI::EnableTimeConstrainedWasNotPending,
  RTI::FederateInternalError);
virtual void timeAdvanceGrant (
  const RTI::FedTime& theTime) // supplied C4
throw (
  RTI::InvalidFederationTime,
  RTI::TimeAdvanceWasNotInProgress,
  RTI::FederateInternalError);
virtual void synchronizationPointRegistrationSucceeded (
  const char *label) // supplied C4)
throw (
  RTI::FederateInternalError);
virtual void synchronizationPointRegistrationFailed (
  const char *label) // supplied C4)
throw (
  RTI::FederateInternalError);
virtual void announceSynchronizationPoint (
  const char *label, // supplied C4
  const char *tag)   // supplied C4
throw (
  RTI::FederateInternalError);
virtual void federationSynchronized (
  const char *label) // supplied C4)
throw (
  RTI::FederateInternalError);
 
public:
   DtTalkAmbData & myData;
};

simpleTimeKeyboard.h

/*******************************************************************************
* Adapted from "Beginning Linux Programming", from Wrox Press -- www.wrox.com
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleTimeKeyboard.h,v $ $Revision: 1.1 $ $State: Exp $
*******************************************************************************/
// Utility to allow keyboard input without blocking
#ifndef MYKBHIT_H_
#define MYKBHIT_H_
#ifndef WIN32
#include <termios.h>
#endif
class keyboard
{
public:
   keyboard();
   ~keyboard();
   // Returns 1 if keyboard input is ready; otherwise, 0
   int kbhit();
   // Returns character from keyboard if avaialable; otherwise, 0
   int keybrdTick();
protected:
   // Return character from keyboard input
   int getkey();
private:
#ifndef WIN32
   struct termios initial_settings, new_settings;
   int peek_character;
#endif
};
#endif

simpleTimeTimeManagedEntity.h

/*******************************************************************************
** Copyright (c) 2006 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleTimeTimeManagedEntity.h,v $ $Revision: 1.3 $ $State: Exp $
*******************************************************************************/
#ifndef _TIMEMANAGEDOBJECTDEFINITION_
#define _TIMEMANAGEDOBJECTDEFINITION_
// A simple object that dictates the behavior of an advancing entity.
#ifdef DtIFSPEC1516
#include "simpleTimeAttribute1516.h"
#include "simpleTimeInteraction1516.h"
#elif defined(DtIFSPEC1516E)
#include "simpleTimeAttribute1516e.h"
#include "simpleTimeInteraction1516e.h"
#else
#ifdef DtIFSPEC13DLC
#include "simpleTimeAttribute13dlc.h"
#include "simpleTimeInteraction13dlc.h"
#else
#include "simpleTimeAttribute13.h"
#include "simpleTimeInteraction13.h"
#endif
#endif
#include <queue>
class timeManagedEntity
{
 public:
  enum entity_state{ Alive = 0,
                     FiredUpon = 1,
                     Damaged = 2,
                     Dead = 3 }; 
  enum active_state{ Initial = 0,
                     Firing = 1, 
                     SendDetonate = 3, 
                     Idle = 5};
  // constructor and destructor for timeManagedEntity
  timeManagedEntity();
  ~timeManagedEntity();
  
  // Peek at our queue's of attributes and Interaction to see if there 
  // is an event waiting to be processed.
  bool attrUpdateWaiting();
  bool interactionWaiting();
  
  // retreive an event from one of the event queue's
  attributeUpdateEvent* getNextAttrUpdateEvent();
  interactionEvent* getNextInteractionEvent();
  
  // add an event to our event queue.
  void addAttrUpdateEvent(attributeUpdateEvent*);
  void addInteractionEvent(interactionEvent*);
  
  // access this timeManagedEntity's state.  
  bool shouldFire();
  bool shouldDetonate();
  bool isFiredUpon();
  bool isDetonated();
  // Change this timeManagedEntity's state.
  void setPhaseLine(int phaseLine);
  void incPosition();
  void firePressed();
  void reset();
  
  // Sets myState to the correct Value. 
  void tick();
  
private:
  void sendFire();
  void sendDetonate();
  void processEvents();
  
private:
  
  bool myFirePressed;
  unsigned int myPosition;
  unsigned int myVelocity;
  
  // myPhaseLine acts as a boundary for this federate.  When the position of the timeManagedEntity is past
  // the myPhaseLine, the timeManagedEntity will start firing on other federates.
  unsigned int myPhaseLine;
  entity_state myPhysicalState;
  active_state myState;   
  std::queue< attributeUpdateEvent* > myAttrUpdateQueue;
  std::queue< interactionEvent* > myInteractionQueue;
};
#endif

simpleTimeStringUtil.h

/*******************************************************************************
** Copyright (c) 2004 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleTimeStringUtil.h,v $ $Revision: 1.2 $ $State: Exp $
*******************************************************************************/
#ifndef stringUtil_H_
#define stringUtil_H_
#include <string>
#include <sstream>
#include <iomanip>
#include <iostream>
using namespace std;
// Convert narrow C string to wide string
inline wstring DtToWString(const char * in_val)
{
   wstring temp;
   while (*in_val != '\0')
   temp += *in_val++;
   return temp;
}
// Convert narrow string to wide string
inline string DtToString(const wstring &in_val)
{
   string temp;
   wstring::const_iterator b = in_val.begin();
   const wstring::const_iterator e = in_val.end();
   while (b != e)
   {
      temp += static_cast<char>(*b);
      ++b;
   }
   return temp;
}
inline string usage()
{
   ostringstream ostr;
   ostr << "Usage: simpletime13/1516(d) [-fedFile fedFileName][-m #Federates][-phaseLine #][-sleepTime s][-dedicated][-unManaged]"
        << endl << endl
        << setw( 20 ) << " -fedFile "
        << " Specify the Fed file name \n"
        << setw ( 24 ) << " " << "Default : MAKsimple.xml/fed. \n"     
      
        << setw( 20 ) << " -m "
        << " Specify whether this federate is the master and if so, how many \n"
        << setw( 24 ) << " " << "total federates it should wait for. \n"
        << setw( 20 ) << " -phaseLine "
        << " Specify the boundary, which when this federate\n"
        << setw( 24 ) << " " << "crosses it, it starts firing.\n"
        << setw( 24 ) << " " << "  Default is 75 units. \n"
        << setw( 20 ) << " -sleepTime "
        << " Specify the time in ms to sleep between iterations of the main loop. \n"
        << setw( 24 ) << " " << "  Default is 850 ms. \n"
            
        << setw( 20 ) << " -dedicated "
        << " Specify whether this federate is on a machine dedicated to running\n"
        << setw( 24 ) << " " 
        << " this federate.  Invalidates all sleeps and yields.\n"
                
        << setw( 20 ) << " -unManaged "
        << " Specify whether this federate will respect the synchronization step\n"
        << setw( 24 ) << " " << " before time advancing.\n"
        << endl; 
   return ostr.str();
}
template< class T > 
bool convert( const string& param,
             const string& value,
             T& dest )
{
   istringstream convert( value );
   convert >> dest;
   if ( convert.fail() )
   {
      std::cout << "Bad Parameter Value\n"
         << "Param: " << param
         << "\tValue: " << value << endl;
      return false;
   }
   return true;
}
#endif

simpleTimeAttribute13.h

/*******************************************************************************
** Copyright (c) 2006 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleTimeAttribute13.h,v $ $Revision: 1.1 $ $State: Exp $
*******************************************************************************/
#ifndef _ATTRIBUTE13DEFINITION_
#define _ATTRIBUTE13DEFINITION_
// A simple container class for an attribute update event.
#include <map>
#include <string>
#include "RTI.hh"
// An attributeUpdateEvent object encapsulates the contents of a 
// reflectattributeupdates callback.  Note, that not all contents of the 
// callback are stored, only those required for our specific application.
// That information can then be stored and later retrieved to be processed.  
class attributeUpdateEvent
{
 public:
  attributeUpdateEvent(  
                  const RTI::AttributeHandleValuePairSet& pvhps,
                  const RTI::FedTime& fedTime,
                  const char* tag,
                  RTI::EventRetractionHandle theRetractionHandle
                  );
  attributeUpdateEvent(
                  const RTI::AttributeHandleValuePairSet& phvps,                
                  const char* tag
                  );
  ~attributeUpdateEvent();
  
  RTI::ObjectHandle getHandle();  
  const std::map<unsigned long, std::string>& getAhvps();
  const std::string& getFedTime();
  const std::string& getTag();
  RTI::EventRetractionHandle getRetractionHandle();
private:
  RTI::ObjectHandle myHandle;
  std::map<unsigned long, std::string> myAhvps;
  std::string myFedTime;  
  std::string myTag;
  RTI::EventRetractionHandle myRetractionHandle;
};
#endif // #define _ATTRIBUTE13DEFINITION_

simpleTimeInteraction13.h

/*******************************************************************************
** Copyright (c) 2006 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleTimeInteraction13.h,v $ $Revision: 1.1 $ $State: Exp $
*******************************************************************************/
#ifndef _INTERACTIONDEFINITION_
#define _INTERACTIONDEFINITION_
// A simple container class for an interaction event
#include <map>
#include <string>
#include "RTI.hh"
// An interactionEvent object encapsulates the contents of a 
// receiveInteraction callback.  Note, that not all contents of the 
// callback are stored, only those required for our specific application.
// That information can then be stored and later retrieved to be processed.
class interactionEvent
{
 public:
   enum interaction_type{ Unknown, FireType, DetonationType };
  interactionEvent(RTI::InteractionClassHandle theHandle,
        const RTI::ParameterHandleValuePairSet& pvhps,
        const RTI::FedTime& fedTime,
        const char* tag,        
                  interaction_type theInteractionType = Unknown                  
                  );
  // Constructor for an interaction with no reported FedTime.
  interactionEvent(RTI::InteractionClassHandle theHandle,
        const RTI::ParameterHandleValuePairSet& pvhps,        
        const char* tag,
                  interaction_type theInteractionType = Unknown
                  );
  
  ~interactionEvent();
  
  RTI::InteractionClassHandle getHandle();
//  const std::map<unsigned long, std::string>& getPhvps();
  bool isFireInteraction();
  bool isDetonateInteraction();
  const std::string& getFedTime();
  const std::string& getTag();
  RTI::EventRetractionHandle getRetractionHandle();
  int getTypeOfInteraction();
private:
  RTI::InteractionClassHandle myHandle;
  std::map<unsigned long, std::string> myPhvps;
  std::string myFedTime;
  std::string myTag;  
  int  myInteractionType;
  
};
class requestUnit
{
 public: 
  requestUnit( RTI::ObjectHandle, 
               const RTI::AttributeHandleSet& attrHandSet );
  ~requestUnit();
  
  const RTI::AttributeHandleSet& getAttrHandSet();
  const RTI::ObjectHandle getHandle();
  
private:
  const RTI::AttributeHandleSet& myAttrHandleSet;
  RTI::ObjectHandle myHandle;
};
#endif